legacy-libs/grpc-cloned/deps/grpc/third_party/abseil-cpp/absl/container/internal/raw_hash_map.h

   1 // Copyright 2018 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_RAW_HASH_MAP_H_
  16 #define ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
  17
  18 #include <tuple>
  19 #include <type_traits>
  20 #include <utility>
  21
  22 #include "absl/container/internal/container_memory.h"
  23 #include "absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
  24
  25 namespace absl {
  26 namespace container_internal {
  27
  28 template <class Policy, class Hash, class Eq, class Alloc>
  29 class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
  30   // P is Policy. It's passed as a template argument to support maps that have
  31   // incomplete types as values, as in unordered_map<K, IncompleteType>.
  32   // MappedReference<> may be a non-reference type.
  33   template <class P>
  34   using MappedReference = decltype(P::value(
  35       std::addressof(std::declval<typename raw_hash_map::reference>())));
  36
  37   // MappedConstReference<> may be a non-reference type.
  38   template <class P>
  39   using MappedConstReference = decltype(P::value(
  40       std::addressof(std::declval<typename raw_hash_map::const_reference>())));
  41
  42   using KeyArgImpl =
  43       KeyArg<IsTransparent<Eq>::value && IsTransparent<Hash>::value>;
  44
  45  public:
  46   using key_type = typename Policy::key_type;
  47   using mapped_type = typename Policy::mapped_type;
  48   template <class K>
  49   using key_arg = typename KeyArgImpl::template type<K, key_type>;
  50
  51   static_assert(!std::is_reference<key_type>::value, "");
  52   // TODO(alkis): remove this assertion and verify that reference mapped_type is
  53   // supported.
  54   static_assert(!std::is_reference<mapped_type>::value, "");
  55
  56   using iterator = typename raw_hash_map::raw_hash_set::iterator;
  57   using const_iterator = typename raw_hash_map::raw_hash_set::const_iterator;
  58
  59   raw_hash_map() {}
  60   using raw_hash_map::raw_hash_set::raw_hash_set;
  61
  62   // The last two template parameters ensure that both arguments are rvalues
  63   // (lvalue arguments are handled by the overloads below). This is necessary
  64   // for supporting bitfield arguments.
  65   //
  66   //   union { int n : 1; };
  67   //   flat_hash_map<int, int> m;
  68   //   m.insert_or_assign(n, n);
  69   template <class K = key_type, class V = mapped_type, K* = nullptr,
  70             V* = nullptr>
  71   std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, V&& v) {
  72     return insert_or_assign_impl(std::forward<K>(k), std::forward<V>(v));
  73   }
  74
  75   template <class K = key_type, class V = mapped_type, K* = nullptr>
  76   std::pair<iterator, bool> insert_or_assign(key_arg<K>&& k, const V& v) {
  77     return insert_or_assign_impl(std::forward<K>(k), v);
  78   }
  79
  80   template <class K = key_type, class V = mapped_type, V* = nullptr>
  81   std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, V&& v) {
  82     return insert_or_assign_impl(k, std::forward<V>(v));
  83   }
  84
  85   template <class K = key_type, class V = mapped_type>
  86   std::pair<iterator, bool> insert_or_assign(const key_arg<K>& k, const V& v) {
  87     return insert_or_assign_impl(k, v);
  88   }
  89
  90   template <class K = key_type, class V = mapped_type, K* = nullptr,
  91             V* = nullptr>
  92   iterator insert_or_assign(const_iterator, key_arg<K>&& k, V&& v) {
  93     return insert_or_assign(std::forward<K>(k), std::forward<V>(v)).first;
  94   }
  95
  96   template <class K = key_type, class V = mapped_type, K* = nullptr>
  97   iterator insert_or_assign(const_iterator, key_arg<K>&& k, const V& v) {
  98     return insert_or_assign(std::forward<K>(k), v).first;
  99   }
 100
 101   template <class K = key_type, class V = mapped_type, V* = nullptr>
 102   iterator insert_or_assign(const_iterator, const key_arg<K>& k, V&& v) {
 103     return insert_or_assign(k, std::forward<V>(v)).first;
 104   }
 105
 106   template <class K = key_type, class V = mapped_type>
 107   iterator insert_or_assign(const_iterator, const key_arg<K>& k, const V& v) {
 108     return insert_or_assign(k, v).first;
 109   }
 110
 111   template <class K = key_type, class... Args,
 112             typename std::enable_if<
 113                 !std::is_convertible<K, const_iterator>::value, int>::type = 0,
 114             K* = nullptr>
 115   std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) {
 116     return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
 117   }
 118
 119   template <class K = key_type, class... Args,
 120             typename std::enable_if<
 121                 !std::is_convertible<K, const_iterator>::value, int>::type = 0>
 122   std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) {
 123     return try_emplace_impl(k, std::forward<Args>(args)...);
 124   }
 125
 126   template <class K = key_type, class... Args, K* = nullptr>
 127   iterator try_emplace(const_iterator, key_arg<K>&& k, Args&&... args) {
 128     return try_emplace(std::forward<K>(k), std::forward<Args>(args)...).first;
 129   }
 130
 131   template <class K = key_type, class... Args>
 132   iterator try_emplace(const_iterator, const key_arg<K>& k, Args&&... args) {
 133     return try_emplace(k, std::forward<Args>(args)...).first;
 134   }
 135
 136   template <class K = key_type, class P = Policy>
 137   MappedReference<P> at(const key_arg<K>& key) {
 138     auto it = this->find(key);
 139     if (it == this->end()) std::abort();
 140     return Policy::value(&*it);
 141   }
 142
 143   template <class K = key_type, class P = Policy>
 144   MappedConstReference<P> at(const key_arg<K>& key) const {
 145     auto it = this->find(key);
 146     if (it == this->end()) std::abort();
 147     return Policy::value(&*it);
 148   }
 149
 150   template <class K = key_type, class P = Policy, K* = nullptr>
 151   MappedReference<P> operator[](key_arg<K>&& key) {
 152     return Policy::value(&*try_emplace(std::forward<K>(key)).first);
 153   }
 154
 155   template <class K = key_type, class P = Policy>
 156   MappedReference<P> operator[](const key_arg<K>& key) {
 157     return Policy::value(&*try_emplace(key).first);
 158   }
 159
 160  private:
 161   template <class K, class V>
 162   std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
 163     auto res = this->find_or_prepare_insert(k);
 164     if (res.second)
 165       this->emplace_at(res.first, std::forward<K>(k), std::forward<V>(v));
 166     else
 167       Policy::value(&*this->iterator_at(res.first)) = std::forward<V>(v);
 168     return {this->iterator_at(res.first), res.second};
 169   }
 170
 171   template <class K = key_type, class... Args>
 172   std::pair<iterator, bool> try_emplace_impl(K&& k, Args&&... args) {
 173     auto res = this->find_or_prepare_insert(k);
 174     if (res.second)
 175       this->emplace_at(res.first, std::piecewise_construct,
 176                        std::forward_as_tuple(std::forward<K>(k)),
 177                        std::forward_as_tuple(std::forward<Args>(args)...));
 178     return {this->iterator_at(res.first), res.second};
 179   }
 180 };
 181
 182 }  // namespace container_internal
 183 }  // namespace absl
 184
 185 #endif  // ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_