mojom: Add associative arrays to the mojom language.

mojo/public/cpp/bindings/lib/map_internal.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_LIB_MAP_INTERNAL_H_
+#define MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_
+
+#include <map>
+
+#include "mojo/public/cpp/bindings/array.h"
+#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
+
+namespace mojo {
+namespace internal {
+
+template <typename Key, typename Value, bool kValueIsMoveOnlyType>
+struct MapTraits {};
+
+template <typename Key, typename Value>
+struct MapTraits<Key, Value, false> {
+  // Map keys can't be move only types.
+  static_assert(!internal::IsMoveOnlyType<Key>::value,
+                "Map keys can not be move only types.");
+
+  typedef Key KeyStorageType;
+  typedef Key& KeyRefType;
+  typedef const Key& KeyConstRefType;
+  typedef KeyConstRefType KeyForwardType;
+
+  typedef Value ValueStorageType;
+  typedef Value& ValueRefType;
+  typedef const Value& ValueConstRefType;
+  typedef ValueConstRefType ValueForwardType;
+
+  static inline void InitializeFrom(
+      std::map<KeyStorageType, ValueStorageType>* m,
+      mojo::Array<Key> keys,
+      mojo::Array<Value> values) {
+    for (size_t i = 0; i < keys.size(); ++i)
+      Insert(m, keys[i], values[i]);
+  }
+  static inline void Decompose(std::map<KeyStorageType, ValueStorageType>* m,
+                               mojo::Array<Key>* keys,
+                               mojo::Array<Value>* values) {
+    keys->resize(m->size());
+    values->resize(m->size());
+    int i = 0;
+    for (typename std::map<KeyStorageType, ValueStorageType>::iterator
+             it = m->begin();
+         it != m->end();
+         ++it, ++i) {
+      (*keys)[i] = it->first;
+      (*values)[i] = it->second;
+    }
+  }
+  static inline void Finalize(std::map<KeyStorageType, ValueStorageType>* m) {}
+  static inline ValueRefType at(std::map<KeyStorageType, ValueStorageType>* m,
+                                KeyForwardType key) {
+    // We don't have C++11 library support yet, so we have to emulate the crash
+    // on a non-existant key.
+    auto it = m->find(key);
+    MOJO_CHECK(it != m->end());
+    return it->second;
+  }
+  static inline ValueConstRefType at(
+      const std::map<KeyStorageType, ValueStorageType>* m,
+      KeyForwardType key) {
+    // We don't have C++11 library support yet, so we have to emulate the crash
+    // on a non-existant key.
+    auto it = m->find(key);
+    MOJO_CHECK(it != m->end());
+    return it->second;
+  }
+  static inline void Insert(std::map<KeyStorageType, ValueStorageType>* m,
+                            KeyForwardType key,
+                            ValueForwardType value) {
+    m->insert(std::make_pair(key, value));
+  }
+  static inline KeyConstRefType GetKey(
+      const typename std::map<KeyStorageType, ValueStorageType>::const_iterator&
+          it) {
+    return it->first;
+  }
+  static inline ValueConstRefType GetValue(
+      const typename std::map<KeyStorageType, ValueStorageType>::const_iterator&
+          it) {
+    return it->second;
+  }
+  static inline void Clone(
+      const std::map<KeyStorageType, ValueStorageType>& src,
+      std::map<KeyStorageType, ValueStorageType>* dst) {
+    dst->clear();
+    for (auto it = src.begin(); it != src.end(); ++it)
+      dst->insert(*it);
+  }
+};
+
+template <typename Key, typename Value>
+struct MapTraits<Key, Value, true> {
+  // Map keys can't be move only types.
+  static_assert(!internal::IsMoveOnlyType<Key>::value,
+                "Map keys can not be move only types.");
+
+  typedef Key KeyStorageType;
+  typedef Key& KeyRefType;
+  typedef const Key& KeyConstRefType;
+  typedef KeyConstRefType KeyForwardType;
+
+  struct ValueStorageType {
+    // Make 8-byte aligned.
+    char buf[sizeof(Value) + (8 - (sizeof(Value) % 8)) % 8];
+  };
+  typedef Value& ValueRefType;
+  typedef const Value& ValueConstRefType;
+  typedef Value ValueForwardType;
+
+  static inline void InitializeFrom(
+      std::map<KeyStorageType, ValueStorageType>* m,
+      mojo::Array<Key> keys,
+      mojo::Array<Value> values) {
+    for (size_t i = 0; i < keys.size(); ++i)

[yzshen1, 2014/10/08 21:58:33]

If |keys| are not unique, then we will leak values, right?

I think it is probably hard to prevent that at the validation stage, so we
should handle it here. Does it make sense to use the Insert() method to insert
the elements?

+      new ((*m)[keys[i]].buf) Value(values[i].Pass());
+  }
+  static inline void Decompose(std::map<KeyStorageType, ValueStorageType>* m,
+                               mojo::Array<Key>* keys,
+                               mojo::Array<Value>* values) {
+    keys->resize(m->size());
+    values->resize(m->size());
+    int i = 0;
+    for (typename std::map<KeyStorageType, ValueStorageType>::iterator
+             it = m->begin();
+         it != m->end();
+         ++it, ++i) {
+      (*keys)[i] = it->first;
+      (*values)[i] = reinterpret_cast<Value*>(it->second.buf)->Pass();
+    }
+  }
+  static inline void Finalize(std::map<KeyStorageType, ValueStorageType>* m) {
+    for (auto& pair : *m)
+      reinterpret_cast<Value*>(pair.second.buf)->~Value();
+  }
+  static inline ValueRefType at(std::map<KeyStorageType, ValueStorageType>* m,
+                                KeyForwardType key) {
+    // We don't have C++11 library support yet, so we have to emulate the crash
+    // on a non-existant key.
+    auto it = m->find(key);
+    MOJO_CHECK(it != m->end());
+    return *reinterpret_cast<Value*>(it->second.buf);
+  }
+  static inline ValueConstRefType at(
+      const std::map<KeyStorageType, ValueStorageType>* m,
+      KeyForwardType key) {
+    // We don't have C++11 library support yet, so we have to emulate the crash
+    // on a non-existant key.
+    auto it = m->find(key);
+    MOJO_CHECK(it != m->end());
+    return *reinterpret_cast<const Value*>(it->second.buf);
+  }
+  static inline void Insert(std::map<KeyStorageType, ValueStorageType>* m,
+                            KeyForwardType key,
+                            ValueRefType value) {
+    // STL insert() doesn't insert |value| if |key| is already part of |m|. We
+    // have to use operator[] to initialize into the storage buffer, but we
+    // have to do a manual check so that we don't overwrite an existing object.
+    auto it = m->find(key);
+    if (it == m->end())
+      new ((*m)[key].buf) Value(value.Pass());
+  }
+  static inline KeyConstRefType GetKey(
+      const typename std::map<KeyStorageType, ValueStorageType>::const_iterator&
+          it) {
+    return it->first;
+  }
+  static inline ValueConstRefType GetValue(

[yzshen1, 2014/10/08 21:58:33]

optional: If we also have a non-const GetValue() version, then we can replace
most reinterpert_cast<...>(it->second.buf) with GetValue().

+      const typename std::map<KeyStorageType, ValueStorageType>::const_iterator&
+          it) {
+    return *reinterpret_cast<const Value*>(it->second.buf);
+  }
+  static inline void Clone(
+      const std::map<KeyStorageType, ValueStorageType>& src,
+      std::map<KeyStorageType, ValueStorageType>* dst) {
+    Finalize(dst);
+    dst->clear();
+    for (auto it = src.begin(); it != src.end(); ++it)
+      new ((*dst)[it->first].buf) Value(GetValue(it).Clone().Pass());

[yzshen1, 2014/10/08 21:58:32]

nit:Pass() is not needed in this case.

+  }
+};
+
+}  // namespace internal
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_