// Copyright 2022 The Abseil Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_ #define ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_ #include #include #include #include #include #include #include "absl/meta/type_traits.h" namespace absl { ABSL_NAMESPACE_BEGIN namespace container_internal { // Defines how slots are initialized/destroyed/moved. template struct common_policy_traits { // The actual object stored in the container. using slot_type = typename Policy::slot_type; using reference = decltype(Policy::element(std::declval())); using value_type = typename std::remove_reference::type; // PRECONDITION: `slot` is UNINITIALIZED // POSTCONDITION: `slot` is INITIALIZED template static void construct(Alloc* alloc, slot_type* slot, Args&&... args) { Policy::construct(alloc, slot, std::forward(args)...); } // PRECONDITION: `slot` is INITIALIZED // POSTCONDITION: `slot` is UNINITIALIZED template static void destroy(Alloc* alloc, slot_type* slot) { Policy::destroy(alloc, slot); } // Transfers the `old_slot` to `new_slot`. Any memory allocated by the // allocator inside `old_slot` to `new_slot` can be transferred. // // OPTIONAL: defaults to: // // clone(new_slot, std::move(*old_slot)); // destroy(old_slot); // // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is // UNINITIALIZED template static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) { transfer_impl(alloc, new_slot, old_slot, 0); } // PRECONDITION: `slot` is INITIALIZED // POSTCONDITION: `slot` is INITIALIZED // Note: we use remove_const_t so that the two overloads have different args // in the case of sets with explicitly const value_types. template static auto element(absl::remove_const_t* slot) -> decltype(P::element(slot)) { return P::element(slot); } template static auto element(const slot_type* slot) -> decltype(P::element(slot)) { return P::element(slot); } private: // Use auto -> decltype as an enabler. template static auto transfer_impl(Alloc* alloc, slot_type* new_slot, slot_type* old_slot, int) -> decltype((void)P::transfer(alloc, new_slot, old_slot)) { P::transfer(alloc, new_slot, old_slot); } template static void transfer_impl(Alloc* alloc, slot_type* new_slot, slot_type* old_slot, char) { #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 if (absl::is_trivially_relocatable()) { // TODO(b/247130232): remove cast after fixing class-memaccess warning. std::memcpy(static_cast( std::launder(const_cast*>( &element(new_slot)))), &element(old_slot), sizeof(value_type)); return; } #endif construct(alloc, new_slot, std::move(element(old_slot))); destroy(alloc, old_slot); } }; } // namespace container_internal ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_