Improvements to uses of base::SmallMap

base/containers/small_map.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_CONTAINERS_SMALL_MAP_H_
 #define BASE_CONTAINERS_SMALL_MAP_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 13 matching lines @@
 // WHAT TYPE OF MAP SHOULD YOU USE?
 // --------------------------------
 //
 //  - std::map should be the default if you're not sure, since it's the most
 //    difficult to mess up. Generally this is backed by a red-black tree. It
 //    will generate a lot of code (if you use a common key type like int or
 //    string the linker will probably emiminate the duplicates). It will
 //    do heap allocations for each element.
 //
 //  - If you only ever keep a couple of items and have very simple usage,
-//    consider whether a using a vector and brute-force searching it will be
-//    the most efficient. It's not a lot of generated code (less than a
-//    red-black tree if your key is "weird" and not eliminated as duplicate of
-//    something else) and will probably be faster and do fewer heap allocations
-//    than std::map if you have just a couple of items.
+//    use a base::flat_map.
 //
-//  - base::hash_map should be used if you need O(1) lookups. It may waste
+//  - std::unordered_map should be used if you need O(1) lookups. It may waste
 //    space in the hash table, and it can be easy to write correct-looking
 //    code with the default hash function being wrong or poorly-behaving.
 //
-//  - SmallMap combines the performance benefits of the brute-force-searched
-//    vector for small cases (no extra heap allocations), but can efficiently
-//    fall back if you end up adding many items. It will generate more code
-//    than std::map (at least 160 bytes for operator[]) which is bad if you
-//    have a "weird" key where map functions can't be
+//  - base::small_map combines the performance benefits of the
+//    brute-force-searched vector for small cases (no extra heap allocations),
+//    but can efficiently fall back if you end up adding many items. It will
+//    generate more code than std::map (at least 160 bytes for operator[])
+//    which is bad if you have a "weird" key where map functions can't be
 //    duplicate-code-eliminated. If you have a one-off key and aren't in
 //    performance-critical code, this bloat may negate some of the benefits and
 //    you should consider on of the other options.
 //
-// SmallMap will pick up the comparator from the underlying map type. In
+// base::small_map will pick up the comparator from the underlying map type. In
 // std::map (and in MSVC additionally hash_map) only a "less" operator is
 // defined, which requires us to do two comparisons per element when doing the
 // brute-force search in the simple array.
 //
 // We define default overrides for the common map types to avoid this
 // double-compare, but you should be aware of this if you use your own
-// operator< for your map and supply yor own version of == to the SmallMap.
+// operator< for your map and supply yor own version of == to the small_map.
 // You can use regular operator== by just doing:
 //
-//   base::SmallMap<std::map<MyKey, MyValue>, 4, std::equal_to<KyKey> >
+//   base::small_map<std::map<MyKey, MyValue>, 4, std::equal_to<KyKey> >

[danakj, 2017/04/19 17:32:16]

Oh, this has an extra space in the > > too 

 //
 //
 // USAGE
 // -----
 //
 // NormalMap:  The map type to fall back to.  This also defines the key
-//             and value types for the SmallMap.
+//             and value types for the small_map.
 // kArraySize:  The size of the initial array of results. This will be
-//              allocated with the SmallMap object rather than separately on
+//              allocated with the small_map object rather than separately on
 //              the heap. Once the map grows beyond this size, the map type
 //              will be used instead.
 // EqualKey:  A functor which tests two keys for equality.  If the wrapped
 //            map type has a "key_equal" member (hash_map does), then that will
 //            be used by default. If the wrapped map type has a strict weak
 //            ordering "key_compare" (std::map does), that will be used to
 //            implement equality by default.
 // MapInit: A functor that takes a ManualConstructor<NormalMap>* and uses it to
 //          initialize the map. This functor will be called at most once per
-//          SmallMap, when the map exceeds the threshold of kArraySize and we
+//          small_map, when the map exceeds the threshold of kArraySize and we
 //          are about to copy values from the array to the map. The functor
 //          *must* call one of the Init() methods provided by
 //          ManualConstructor, since after it runs we assume that the NormalMap
 //          has been initialized.
 //
 // example:
-//   base::SmallMap< std::map<string, int> > days;
+//   base::small_map<std::map<string, int>> days;
 //   days["sunday"   ] = 0;
 //   days["monday"   ] = 1;
 //   days["tuesday"  ] = 2;
 //   days["wednesday"] = 3;
 //   days["thursday" ] = 4;
 //   days["friday"   ] = 5;
 //   days["saturday" ] = 6;
 //
-// You should assume that SmallMap might invalidate all the iterators
+// You should assume that small_map might invalidate all the iterators
 // on any call to erase(), insert() and operator[].
 
 namespace internal {
 
 template <typename NormalMap>
-class SmallMapDefaultInit {
+class small_map_default_init {
  public:
   void operator()(ManualConstructor<NormalMap>* map) const {
     map->Init();
   }
 };
 
 // has_key_equal<M>::value is true iff there exists a type M::key_equal. This is
 // used to dispatch to one of the select_equal_key<> metafunctions below.
 template <typename M>
 struct has_key_equal {
@@ skipping 56 matching lines @@
 // hash_map<>.
 template <typename M>
 struct select_equal_key<M, true> {
   typedef typename M::key_equal equal_key;
 };
 
 }  // namespace internal
 
 template <typename NormalMap,
           int kArraySize = 4,
-          typename EqualKey =
-              typename internal::select_equal_key<
-                  NormalMap,
-                  internal::has_key_equal<NormalMap>::value>::equal_key,
-          typename MapInit = internal::SmallMapDefaultInit<NormalMap> >
-class SmallMap {
+          typename EqualKey = typename internal::select_equal_key<
+              NormalMap,
+              internal::has_key_equal<NormalMap>::value>::equal_key,
+          typename MapInit = internal::small_map_default_init<NormalMap>>
+class small_map {
   // We cannot rely on the compiler to reject array of size 0.  In
   // particular, gcc 2.95.3 does it but later versions allow 0-length
   // arrays.  Therefore, we explicitly reject non-positive kArraySize
   // here.
   static_assert(kArraySize > 0, "default initial size should be positive");
 
  public:
   typedef typename NormalMap::key_type key_type;
   typedef typename NormalMap::mapped_type data_type;
   typedef typename NormalMap::mapped_type mapped_type;
   typedef typename NormalMap::value_type value_type;
   typedef EqualKey key_equal;
 
-  SmallMap() : size_(0), functor_(MapInit()) {}
+  small_map() : size_(0), functor_(MapInit()) {}
 
-  explicit SmallMap(const MapInit& functor) : size_(0), functor_(functor) {}
+  explicit small_map(const MapInit& functor) : size_(0), functor_(functor) {}
 
   // Allow copy-constructor and assignment, since STL allows them too.
-  SmallMap(const SmallMap& src) {
+  small_map(const small_map& src) {
     // size_ and functor_ are initted in InitFrom()
     InitFrom(src);
   }
-  void operator=(const SmallMap& src) {
+  void operator=(const small_map& src) {
     if (&src == this) return;
 
     // This is not optimal. If src and dest are both using the small
     // array, we could skip the teardown and reconstruct. One problem
     // to be resolved is that the value_type itself is pair<const K,
     // V>, and const K is not assignable.
     Destroy();
     InitFrom(src);
   }
-  ~SmallMap() {
-    Destroy();
-  }
+  ~small_map() { Destroy(); }
 
   class const_iterator;
 
   class iterator {
    public:
     typedef typename NormalMap::iterator::iterator_category iterator_category;
     typedef typename NormalMap::iterator::value_type value_type;
     typedef typename NormalMap::iterator::difference_type difference_type;
     typedef typename NormalMap::iterator::pointer pointer;
     typedef typename NormalMap::iterator::reference reference;
@@ skipping 51 matching lines @@
     }
 
     inline bool operator!=(const iterator& other) const {
       return !(*this == other);
     }
 
     bool operator==(const const_iterator& other) const;
     bool operator!=(const const_iterator& other) const;
 
    private:
-    friend class SmallMap;
+    friend class small_map;
     friend class const_iterator;
     inline explicit iterator(ManualConstructor<value_type>* init)
       : array_iter_(init) {}
     inline explicit iterator(const typename NormalMap::iterator& init)
       : array_iter_(NULL), hash_iter_(init) {}
 
     ManualConstructor<value_type>* array_iter_;
     typename NormalMap::iterator hash_iter_;
   };
 
@@ skipping 61 matching lines @@
       } else {
         return other.array_iter_ == NULL && hash_iter_ == other.hash_iter_;
       }
     }
 
     inline bool operator!=(const const_iterator& other) const {
       return !(*this == other);
     }
 
    private:
-    friend class SmallMap;
+    friend class small_map;
     inline explicit const_iterator(
         const ManualConstructor<value_type>* init)
       : array_iter_(init) {}
     inline explicit const_iterator(
         const typename NormalMap::const_iterator& init)
       : array_iter_(NULL), hash_iter_(init) {}
 
     const ManualConstructor<value_type>* array_iter_;
     typename NormalMap::const_iterator hash_iter_;
   };
@@ skipping 214 matching lines @@
     functor_(&map_);
 
     // Insert elements into it.
     for (int i = 0; i < kArraySize; i++) {
       map_->insert(std::move(*temp_array[i]));
       temp_array[i].Destroy();
     }
   }
 
   // Helpers for constructors and destructors.
-  void InitFrom(const SmallMap& src) {
+  void InitFrom(const small_map& src) {
     functor_ = src.functor_;
     size_ = src.size_;
     if (src.size_ >= 0) {
       for (int i = 0; i < size_; i++) {
         array_[i].Init(*src.array_[i]);
       }
     } else {
       functor_(&map_);
       (*map_.get()) = (*src.map_.get());
     }
   }
   void Destroy() {
     if (size_ >= 0) {
       for (int i = 0; i < size_; i++) {
         array_[i].Destroy();
       }
     } else {
       map_.Destroy();
     }
   }
 };
 
-template <typename NormalMap, int kArraySize, typename EqualKey,
+template <typename NormalMap,
+          int kArraySize,
+          typename EqualKey,
           typename Functor>
-inline bool SmallMap<NormalMap, kArraySize, EqualKey,
-                     Functor>::iterator::operator==(
-    const const_iterator& other) const {
+inline bool small_map<NormalMap, kArraySize, EqualKey, Functor>::iterator::
+operator==(const const_iterator& other) const {
   return other == *this;
 }
-template <typename NormalMap, int kArraySize, typename EqualKey,
+template <typename NormalMap,
+          int kArraySize,
+          typename EqualKey,
           typename Functor>
-inline bool SmallMap<NormalMap, kArraySize, EqualKey,
-                     Functor>::iterator::operator!=(
-    const const_iterator& other) const {
+inline bool small_map<NormalMap, kArraySize, EqualKey, Functor>::iterator::
+operator!=(const const_iterator& other) const {
   return other != *this;
 }
 
 }  // namespace base
 
 #endif  // BASE_CONTAINERS_SMALL_MAP_H_