Mojo C++ bindings: custom type mapping of map

mojo/public/cpp/bindings/map.h

 // Copyright 2014 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 MOJO_PUBLIC_CPP_BINDINGS_MAP_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_MAP_H_
 
 #include <stddef.h>
 #include <map>
 #include <utility>
@@ skipping 18 matching lines @@
   MOVE_ONLY_TYPE_FOR_CPP_03(Map);
 
  public:
   using Key = K;
   using Value = V;
 
   // Map keys cannot be move only classes.
   static_assert(!internal::IsMoveOnlyType<Key>::value,
                 "Map keys cannot be move only types.");
 
+  using Iterator = typename std::map<Key, Value>::iterator;
   using ConstIterator = typename std::map<Key, Value>::const_iterator;
 
   using Data_ = internal::Map_Data<
       typename internal::GetDataTypeAsArrayElement<Key>::Data,
       typename internal::GetDataTypeAsArrayElement<Value>::Data>;
 
   // Constructs an empty map.
   Map() : is_null_(false) {}
   // Constructs a null map.
   Map(std::nullptr_t null_pointer) : is_null_(true) {}
@@ skipping 167 matching lines @@
         return false;
       ++i;
       ++j;
     }
     return true;
   }
 
   // Provide read-only iteration over map members in a way similar to STL
   // collections.
   ConstIterator begin() const { return map_.begin(); }
+  Iterator begin() { return map_.begin(); }
+
   ConstIterator end() const { return map_.end(); }
+  Iterator end() { return map_.end(); }
 
   // Returns the iterator pointing to the entry for |key|, if present, or else
   // returns end().
   ConstIterator find(const Key& key) const { return map_.find(key); }
+  Iterator find(const Key& key) { return map_.find(key); }
 
  private:
   typedef std::map<Key, Value> Map::*Testable;
 
  public:
   // The Map may be used in boolean expressions to determine if it is non-null,
   // but is not implicitly convertible to an actual bool value (which would be
   // dangerous).
   operator Testable() const { return is_null_ ? 0 : &Map::map_; }
 
  private:
   using Traits =
-      internal::MapTraits<Key, Value, internal::IsMoveOnlyType<Value>::value>;
+      internal::MapCloneTraits<Key,
+                               Value,
+                               internal::IsMoveOnlyType<Value>::value>;
 
   // Forbid the == and != operators explicitly, otherwise Map will be converted
   // to Testable to do == or != comparison.
   template <typename T, typename U>
   bool operator==(const Map<T, U>& other) const = delete;
   template <typename T, typename U>
   bool operator!=(const Map<T, U>& other) const = delete;
 
   void Take(Map* other) {
     operator=(nullptr);
@@ skipping 39 matching lines @@
             TypeConverter<STLValue, MojoValue>::Convert(it->second)));
       }
     }
     return result;
   }
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_MAP_H_