/src/abseil-cpp/absl/container/internal/common_policy_traits.h
Line | Count | Source (jump to first uncovered line) |
1 | | // Copyright 2022 The Abseil Authors. |
2 | | // |
3 | | // Licensed under the Apache License, Version 2.0 (the "License"); |
4 | | // you may not use this file except in compliance with the License. |
5 | | // You may obtain a copy of the License at |
6 | | // |
7 | | // https://www.apache.org/licenses/LICENSE-2.0 |
8 | | // |
9 | | // Unless required by applicable law or agreed to in writing, software |
10 | | // distributed under the License is distributed on an "AS IS" BASIS, |
11 | | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
12 | | // See the License for the specific language governing permissions and |
13 | | // limitations under the License. |
14 | | |
15 | | #ifndef ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_ |
16 | | #define ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_ |
17 | | |
18 | | #include <cstddef> |
19 | | #include <cstring> |
20 | | #include <memory> |
21 | | #include <new> |
22 | | #include <type_traits> |
23 | | #include <utility> |
24 | | |
25 | | #include "absl/meta/type_traits.h" |
26 | | |
27 | | namespace absl { |
28 | | ABSL_NAMESPACE_BEGIN |
29 | | namespace container_internal { |
30 | | |
31 | | // Defines how slots are initialized/destroyed/moved. |
32 | | template <class Policy, class = void> |
33 | | struct common_policy_traits { |
34 | | // The actual object stored in the container. |
35 | | using slot_type = typename Policy::slot_type; |
36 | | using reference = decltype(Policy::element(std::declval<slot_type*>())); |
37 | | using value_type = typename std::remove_reference<reference>::type; |
38 | | |
39 | | // PRECONDITION: `slot` is UNINITIALIZED |
40 | | // POSTCONDITION: `slot` is INITIALIZED |
41 | | template <class Alloc, class... Args> |
42 | 16 | static void construct(Alloc* alloc, slot_type* slot, Args&&... args) { |
43 | 16 | Policy::construct(alloc, slot, std::forward<Args>(args)...); |
44 | 16 | } void absl::container_internal::common_policy_traits<absl::container_internal::FlatHashMapPolicy<std::__1::basic_string_view<char, std::__1::char_traits<char> >, absl::CommandLineFlag*>, void>::construct<std::__1::allocator<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> > const, absl::CommandLineFlag*> >, std::__1::piecewise_construct_t const&, std::__1::tuple<std::__1::basic_string_view<char, std::__1::char_traits<char> > const&&>, std::__1::tuple<absl::CommandLineFlag*&&> >(std::__1::allocator<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> > const, absl::CommandLineFlag*> >*, absl::container_internal::map_slot_type<std::__1::basic_string_view<char, std::__1::char_traits<char> >, absl::CommandLineFlag*>*, std::__1::piecewise_construct_t const&, std::__1::tuple<std::__1::basic_string_view<char, std::__1::char_traits<char> > const&&>&&, std::__1::tuple<absl::CommandLineFlag*&&>&&) Line | Count | Source | 42 | 16 | static void construct(Alloc* alloc, slot_type* slot, Args&&... args) { | 43 | 16 | Policy::construct(alloc, slot, std::forward<Args>(args)...); | 44 | 16 | } |
Unexecuted instantiation: void absl::container_internal::common_policy_traits<absl::container_internal::FlatHashMapPolicy<std::__1::basic_string_view<char, std::__1::char_traits<char> >, absl::CommandLineFlag*>, void>::construct<std::__1::allocator<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> > const, absl::CommandLineFlag*> >, std::__1::piecewise_construct_t const&, std::__1::tuple<std::__1::basic_string_view<char, std::__1::char_traits<char> >&&>, std::__1::tuple<absl::CommandLineFlag*&&> >(std::__1::allocator<std::__1::pair<std::__1::basic_string_view<char, std::__1::char_traits<char> > const, absl::CommandLineFlag*> >*, absl::container_internal::map_slot_type<std::__1::basic_string_view<char, std::__1::char_traits<char> >, absl::CommandLineFlag*>*, std::__1::piecewise_construct_t const&, std::__1::tuple<std::__1::basic_string_view<char, std::__1::char_traits<char> >&&>&&, std::__1::tuple<absl::CommandLineFlag*&&>&&) |
45 | | |
46 | | // PRECONDITION: `slot` is INITIALIZED |
47 | | // POSTCONDITION: `slot` is UNINITIALIZED |
48 | | // Returns std::true_type in case destroy is trivial. |
49 | | template <class Alloc> |
50 | 0 | static auto destroy(Alloc* alloc, slot_type* slot) { |
51 | 0 | return Policy::destroy(alloc, slot); |
52 | 0 | } |
53 | | |
54 | | // Transfers the `old_slot` to `new_slot`. Any memory allocated by the |
55 | | // allocator inside `old_slot` to `new_slot` can be transferred. |
56 | | // |
57 | | // OPTIONAL: defaults to: |
58 | | // |
59 | | // clone(new_slot, std::move(*old_slot)); |
60 | | // destroy(old_slot); |
61 | | // |
62 | | // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED |
63 | | // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is |
64 | | // UNINITIALIZED |
65 | | template <class Alloc> |
66 | 0 | static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) { |
67 | 0 | transfer_impl(alloc, new_slot, old_slot, Rank2{}); |
68 | 0 | } |
69 | | |
70 | | // PRECONDITION: `slot` is INITIALIZED |
71 | | // POSTCONDITION: `slot` is INITIALIZED |
72 | | // Note: we use remove_const_t so that the two overloads have different args |
73 | | // in the case of sets with explicitly const value_types. |
74 | | template <class P = Policy> |
75 | | static auto element(absl::remove_const_t<slot_type>* slot) |
76 | 35 | -> decltype(P::element(slot)) { |
77 | 35 | return P::element(slot); |
78 | 35 | } |
79 | | template <class P = Policy> |
80 | | static auto element(const slot_type* slot) -> decltype(P::element(slot)) { |
81 | | return P::element(slot); |
82 | | } |
83 | | |
84 | 0 | static constexpr bool transfer_uses_memcpy() { |
85 | 0 | return std::is_same<decltype(transfer_impl<std::allocator<char>>( |
86 | 0 | nullptr, nullptr, nullptr, Rank2{})), |
87 | 0 | std::true_type>::value; |
88 | 0 | } |
89 | | |
90 | | // Returns true if destroy is trivial and can be omitted. |
91 | | template <class Alloc> |
92 | 0 | static constexpr bool destroy_is_trivial() { |
93 | 0 | return std::is_same<decltype(destroy<Alloc>(nullptr, nullptr)), |
94 | 0 | std::true_type>::value; |
95 | 0 | } |
96 | | |
97 | | private: |
98 | | // Use go/ranked-overloads for dispatching. |
99 | | struct Rank0 {}; |
100 | | struct Rank1 : Rank0 {}; |
101 | | struct Rank2 : Rank1 {}; |
102 | | |
103 | | // Use auto -> decltype as an enabler. |
104 | | // P::transfer returns std::true_type if transfer uses memcpy (e.g. in |
105 | | // node_slot_policy). |
106 | | template <class Alloc, class P = Policy> |
107 | | static auto transfer_impl(Alloc* alloc, slot_type* new_slot, |
108 | | slot_type* old_slot, |
109 | | Rank2) -> decltype(P::transfer(alloc, new_slot, |
110 | 0 | old_slot)) { |
111 | 0 | return P::transfer(alloc, new_slot, old_slot); |
112 | 0 | } |
113 | | #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 |
114 | | // This overload returns true_type for the trait below. |
115 | | // The conditional_t is to make the enabler type dependent. |
116 | | template <class Alloc, |
117 | | typename = std::enable_if_t<absl::is_trivially_relocatable< |
118 | | std::conditional_t<false, Alloc, value_type>>::value>> |
119 | | static std::true_type transfer_impl(Alloc*, slot_type* new_slot, |
120 | | slot_type* old_slot, Rank1) { |
121 | | // TODO(b/247130232): remove casts after fixing warnings. |
122 | | // TODO(b/251814870): remove casts after fixing warnings. |
123 | | std::memcpy( |
124 | | static_cast<void*>(std::launder( |
125 | | const_cast<std::remove_const_t<value_type>*>(&element(new_slot)))), |
126 | | static_cast<const void*>(&element(old_slot)), sizeof(value_type)); |
127 | | return {}; |
128 | | } |
129 | | #endif |
130 | | |
131 | | template <class Alloc> |
132 | | static void transfer_impl(Alloc* alloc, slot_type* new_slot, |
133 | | slot_type* old_slot, Rank0) { |
134 | | construct(alloc, new_slot, std::move(element(old_slot))); |
135 | | destroy(alloc, old_slot); |
136 | | } |
137 | | }; |
138 | | |
139 | | } // namespace container_internal |
140 | | ABSL_NAMESPACE_END |
141 | | } // namespace absl |
142 | | |
143 | | #endif // ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_ |