Remove mojo::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 <unordered_map>
 #include <utility>
 
-#include "base/logging.h"
-#include "base/macros.h"
-#include "mojo/public/cpp/bindings/array.h"
-#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
-#include "mojo/public/cpp/bindings/lib/template_util.h"
-#include "mojo/public/cpp/bindings/type_converter.h"
-
 namespace mojo {
 
-// A move-only map that can handle move-only values. Map has the following
-// characteristics:
-//   - The map itself can be null, and this is distinct from empty.
-//   - Keys must not be move-only.
-//   - The Key-type's "<" operator is used to sort the entries, and also is
-//     used to determine equality of the key values.
-//   - There can only be one entry per unique key.
-//   - Values of move-only types will be moved into the Map when they are added
-//     using the insert() method.
-template <typename K, typename V>
-class 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;
-
-  // Constructs an empty map.
-  Map() : is_null_(false) {}
-  // Constructs a null map.
-  Map(std::nullptr_t null_pointer) : is_null_(true) {}
-
-  // Constructs a non-null Map containing the specified |keys| mapped to the
-  // corresponding |values|.
-  Map(mojo::Array<Key> keys, mojo::Array<Value> values) : is_null_(false) {
-    DCHECK(keys.size() == values.size());
-    for (size_t i = 0; i < keys.size(); ++i)
-      map_.insert(std::make_pair(keys[i], std::move(values[i])));
-  }
-
-  ~Map() {}
-
-  Map(std::map<Key, Value>&& other) : map_(std::move(other)), is_null_(false) {}
-  Map(Map&& other) : is_null_(true) { Take(&other); }
-
-  Map& operator=(std::map<Key, Value>&& other) {
-    is_null_ = false;
-    map_ = std::move(other);
-    return *this;
-  }
-  Map& operator=(Map&& other) {
-    Take(&other);
-    return *this;
-  }
-
-  Map& operator=(std::nullptr_t null_pointer) {
-    is_null_ = true;
-    map_.clear();
-    return *this;
-  }
-
-  // Copies the contents of some other type of map into a new Map using a
-  // TypeConverter. A TypeConverter for std::map to Map is defined below.
-  template <typename U>
-  static Map From(const U& other) {
-    return TypeConverter<Map, U>::Convert(other);
-  }
-
-  // Copies the contents of the Map into some other type of map. A TypeConverter
-  // for Map to std::map is defined below.
-  template <typename U>
-  U To() const {
-    return TypeConverter<U, Map>::Convert(*this);
-  }
-
-  // Indicates whether the map is null (which is distinct from empty).
-  bool is_null() const { return is_null_; }
-
-  // Indicates whether the map is empty (which is distinct from null).
-  bool empty() const { return map_.empty() && !is_null_; }
-
-  // Indicates the number of keys in the map, which will be zero if the map is
-  // null.
-  size_t size() const { return map_.size(); }
-
-  // Inserts a key-value pair into the map. Like std::map, this does not insert
-  // |value| if |key| is already a member of the map.
-  void insert(const Key& key, const Value& value) {
-    is_null_ = false;
-    map_.insert(std::make_pair(key, value));
-  }
-  void insert(const Key& key, Value&& value) {
-    is_null_ = false;
-    map_.insert(std::make_pair(key, std::move(value)));
-  }
-
-  // Returns a reference to the value associated with the specified key,
-  // crashing the process if the key is not present in the map.
-  Value& at(const Key& key) { return map_.at(key); }
-  const Value& at(const Key& key) const { return map_.at(key); }
-
-  // Returns a reference to the value associated with the specified key,
-  // creating a new entry if the key is not already present in the map. A
-  // newly-created value will be value-initialized (meaning that it will be
-  // initialized by the default constructor of the value type, if any, or else
-  // will be zero-initialized).
-  Value& operator[](const Key& key) {
-    is_null_ = false;
-    return map_[key];
-  }
-
-  // Sets the map to empty (even if previously it was null).
-  void SetToEmpty() {
-    is_null_ = false;
-    map_.clear();
-  }
-
-  // Returns a const reference to the std::map managed by this class. If this
-  // object is null, the return value will be an empty map.
-  const std::map<Key, Value>& storage() const { return map_; }
-
-  // Passes the underlying storage and resets this map to null.
-  std::map<Key, Value> PassStorage() {
-    is_null_ = true;
-    return std::move(map_);
-  }
-
-  operator const std::map<Key, Value>&() const { return map_; }
-
-  // Swaps the contents of this Map with another Map of the same type (including
-  // nullness).
-  void Swap(Map<Key, Value>* other) {
-    std::swap(is_null_, other->is_null_);
-    map_.swap(other->map_);
-  }
-
-  // Swaps the contents of this Map with an std::map containing keys and values
-  // of the same type. Since std::map cannot represent the null state, the
-  // std::map will be empty if Map is null. The Map will always be left in a
-  // non-null state.
-  void Swap(std::map<Key, Value>* other) {
-    is_null_ = false;
-    map_.swap(*other);
-  }
-
-  // Removes all contents from the Map and places them into parallel key/value
-  // arrays. Each key will be copied from the source to the destination, and
-  // values will be copied unless their type is designated move-only, in which
-  // case they will be moved. Either way, the Map will be left in a null state.
-  void DecomposeMapTo(mojo::Array<Key>* keys, mojo::Array<Value>* values) {
-    std::vector<Key> key_vector;
-    key_vector.reserve(map_.size());
-    std::vector<Value> value_vector;
-    value_vector.reserve(map_.size());
-
-    for (auto& entry : map_) {
-      key_vector.push_back(entry.first);
-      value_vector.push_back(std::move(entry.second));
-    }
-
-    map_.clear();
-    is_null_ = true;
-
-    keys->Swap(&key_vector);
-    values->Swap(&value_vector);
-  }
-
-  // Returns a new Map that contains a copy of the contents of this map. If the
-  // key/value type defines a Clone() method, it will be used; otherwise copy
-  // constructor/assignment will be used.
-  //
-  // Please note that calling this method will fail compilation if the key/value
-  // type cannot be cloned (which usually means that it is a Mojo handle type or
-  // a type containing Mojo handles).
-  Map Clone() const {
-    Map result;
-    result.is_null_ = is_null_;
-    for (auto it = map_.begin(); it != map_.end(); ++it) {
-      result.map_.insert(std::make_pair(internal::Clone(it->first),
-                                        internal::Clone(it->second)));
-    }
-    return result;
-  }
-
-  // Indicates whether the contents of this map are equal to those of another
-  // Map (including nullness). If the key/value type defines an Equals() method,
-  // it will be used; otherwise == operator will be used.
-  bool Equals(const Map& other) const {
-    if (is_null() != other.is_null())
-      return false;
-    if (size() != other.size())
-      return false;
-    auto i = begin();
-    auto j = other.begin();
-    while (i != end()) {
-      if (!internal::Equals(i->first, j->first))
-        return false;
-      if (!internal::Equals(i->second, j->second))
-        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:
-  // 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);
-    Swap(other);
-  }
-
-  std::map<Key, Value> map_;
-  bool is_null_;
-
-  DISALLOW_COPY_AND_ASSIGN(Map);
-};
-
-// Copies the contents of an std::map to a new Map, optionally changing the
-// types of the keys and values along the way using TypeConverter.
-template <typename MojoKey,
-          typename MojoValue,
-          typename STLKey,
-          typename STLValue>
-struct TypeConverter<Map<MojoKey, MojoValue>, std::map<STLKey, STLValue>> {
-  static Map<MojoKey, MojoValue> Convert(
-      const std::map<STLKey, STLValue>& input) {
-    Map<MojoKey, MojoValue> result;
-    for (auto& pair : input) {
-      result.insert(TypeConverter<MojoKey, STLKey>::Convert(pair.first),
-                    TypeConverter<MojoValue, STLValue>::Convert(pair.second));
-    }
-    return result;
-  }
-};
-
-// Copies the contents of a Map to an std::map, optionally changing the types of
-// the keys and values along the way using TypeConverter.
-template <typename MojoKey,
-          typename MojoValue,
-          typename STLKey,
-          typename STLValue>
-struct TypeConverter<std::map<STLKey, STLValue>, Map<MojoKey, MojoValue>> {
-  static std::map<STLKey, STLValue> Convert(
-      const Map<MojoKey, MojoValue>& input) {
-    std::map<STLKey, STLValue> result;
-    if (!input.is_null()) {
-      for (auto it = input.begin(); it != input.end(); ++it) {
-        result.insert(std::make_pair(
-            TypeConverter<STLKey, MojoKey>::Convert(it->first),
-            TypeConverter<STLValue, MojoValue>::Convert(it->second)));
-      }
-    }
-    return result;
-  }
-};
-
 // TODO(yzshen): These conversion functions should be removed and callsites
 // should be revisited and changed to use the same map type.
 template <typename Key, typename Value>
 std::unordered_map<Key, Value> MapToUnorderedMap(
     const std::map<Key, Value>& input) {
   return std::unordered_map<Key, Value>(input.begin(), input.end());
 }
 
 template <typename Key, typename Value>
 std::unordered_map<Key, Value> MapToUnorderedMap(std::map<Key, Value>&& input) {
   return std::unordered_map<Key, Value>(std::make_move_iterator(input.begin()),
                                         std::make_move_iterator(input.end()));
 }
 
 template <typename Key, typename Value>
 std::map<Key, Value> UnorderedMapToMap(
     const std::unordered_map<Key, Value>& input) {
   return std::map<Key, Value>(input.begin(), input.end());
 }
 
 template <typename Key, typename Value>
 std::map<Key, Value> UnorderedMapToMap(std::unordered_map<Key, Value>&& input) {
   return std::map<Key, Value>(std::make_move_iterator(input.begin()),
                               std::make_move_iterator(input.end()));
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_MAP_H_