Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(551)

Unified Diff: mojo/public/cpp/bindings/map.h

Issue 611633002: mojom: Add associative arrays to the mojom language. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Moved test classes to their own shared file. Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « mojo/public/cpp/bindings/lib/validation_errors.cc ('k') | mojo/public/cpp/bindings/string.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: mojo/public/cpp/bindings/map.h
diff --git a/mojo/public/cpp/bindings/map.h b/mojo/public/cpp/bindings/map.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ee66fb46b8f9ce8b550b6bb2a452a580a4e9034
--- /dev/null
+++ b/mojo/public/cpp/bindings/map.h
@@ -0,0 +1,207 @@
+// 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 <map>
+
+#include "mojo/public/cpp/bindings/lib/map_internal.h"
+
+namespace mojo {
+
+template <typename Key, typename Value>
+class Map {
+ MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(Map, RValue)
+ public:
+ // Map keys can not be move only classes.
+ static_assert(!internal::IsMoveOnlyType<Key>::value,
+ "Map keys can not be move only types.");
+
+ typedef internal::MapTraits<Key,
+ Value,
+ internal::IsMoveOnlyType<Value>::value> Traits;
+ typedef typename Traits::KeyStorageType KeyStorageType;
+ typedef typename Traits::KeyRefType KeyRefType;
+ typedef typename Traits::KeyConstRefType KeyConstRefType;
+ typedef typename Traits::KeyForwardType KeyForwardType;
+
+ typedef typename Traits::ValueStorageType ValueStorageType;
+ typedef typename Traits::ValueRefType ValueRefType;
+ typedef typename Traits::ValueConstRefType ValueConstRefType;
+ typedef typename Traits::ValueForwardType ValueForwardType;
+
+ typedef internal::Map_Data<typename internal::WrapperTraits<Key>::DataType,
+ typename internal::WrapperTraits<Value>::DataType>
+ Data_;
+
+ Map() : is_null_(true) {}
+
+ Map(mojo::Array<Key> keys, mojo::Array<Value> values) : is_null_(false) {
+ MOJO_DCHECK(keys.size() == values.size());
+ Traits::InitializeFrom(&map_, keys.Pass(), values.Pass());
+ }
+
+ ~Map() { Traits::Finalize(&map_); }
+
+ Map(RValue other) : is_null_(true) { Take(other.object); }
+ Map& operator=(RValue other) {
+ Take(other.object);
+ return *this;
+ }
+
+ template <typename U>
+ static Map From(const U& other) {
+ return TypeConverter<Map, U>::Convert(other);
+ }
+
+ template <typename U>
+ U To() const {
+ return TypeConverter<U, Map>::Convert(*this);
+ }
+
+ void reset() {
+ if (!map_.empty()) {
+ Traits::Finalize(&map_);
+ map_.clear();
+ }
+ is_null_ = true;
+ }
+
+ bool is_null() const { return is_null_; }
+
+ size_t size() const { return map_.size(); }
+
+ // Used to mark an empty map as non-null for serialization purposes.
+ void mark_non_null() { is_null_ = false; }
+
+ // 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(KeyForwardType key, ValueForwardType value) {
+ is_null_ = false;
+ Traits::Insert(&map_, key, value);
+ }
+
+ ValueRefType at(KeyForwardType key) { return Traits::at(&map_, key); }
+ ValueConstRefType at(KeyForwardType key) const {
+ return Traits::at(&map_, key);
+ }
+
+ void Swap(Map<Key, Value>* other) {
+ std::swap(is_null_, other->is_null_);
+ map_.swap(other->map_);
+ }
+ void Swap(std::map<Key, Value>* other) {
+ is_null_ = false;
+ map_.swap(*other);
+ }
+
+ // This moves all values in the map to a set of parallel arrays. This action
+ // is destructive because we can have move-only objects as values; therefore
+ // we can't have copy semantics here.
+ void DecomposeMapTo(mojo::Array<Key>* keys, mojo::Array<Value>* values) {
+ Traits::Decompose(&map_, keys, values);
+ Traits::Finalize(&map_);
+ map_.clear();
+ is_null_ = true;
+ }
+
+ // Please note that calling this method will fail compilation if the value
+ // type cannot be cloned (which usually means that it is a Mojo handle type or
+ // a type contains Mojo handles).
+ Map Clone() const {
+ Map result;
+ result.is_null_ = is_null_;
+ Traits::Clone(map_, &result.map_);
+ return result.Pass();
+ }
+
+ class ConstMapIterator {
+ public:
+ ConstMapIterator(
+ const typename std::map<KeyStorageType,
+ ValueStorageType>::const_iterator& it)
+ : it_(it) {}
+
+ KeyConstRefType GetKey() { return Traits::GetKey(it_); }
+ ValueConstRefType GetValue() { return Traits::GetValue(it_); }
+
+ ConstMapIterator& operator++() {
+ it_++;
+ return *this;
+ }
+ bool operator!=(const ConstMapIterator& rhs) const {
+ return it_ != rhs.it_;
+ }
+ bool operator==(const ConstMapIterator& rhs) const {
+ return it_ == rhs.it_;
+ }
+
+ private:
+ typename std::map<KeyStorageType, ValueStorageType>::const_iterator it_;
+ };
+
+ // Provide read-only iteration over map members.
+ ConstMapIterator begin() const { return ConstMapIterator(map_.begin()); }
+ ConstMapIterator end() const { return ConstMapIterator(map_.end()); }
+
+ ConstMapIterator find(KeyForwardType key) const {
+ return ConstMapIterator(map_.find(key));
+ }
+
+ private:
+ typedef std::map<KeyStorageType, ValueStorageType> Map::*Testable;
+
+ public:
+ operator Testable() const { return is_null_ ? 0 : &Map::map_; }
+
+ private:
+ void Take(Map* other) {
+ reset();
+ Swap(other);
+ }
+
+ std::map<KeyStorageType, ValueStorageType> map_;
+ bool is_null_;
+};
+
+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;
+ result.mark_non_null();
+ for (auto& pair : input) {
+ result.insert(TypeConverter<MojoKey, STLKey>::Convert(pair.first),
+ TypeConverter<MojoValue, STLValue>::Convert(pair.second));
+ }
+ return result.Pass();
+ }
+};
+
+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.GetKey()),
+ TypeConverter<STLValue, MojoValue>::Convert(it.GetValue())));
+ }
+ }
+ return result;
+ }
+};
+
+} // namespace mojo
+
+#endif // MOJO_PUBLIC_CPP_BINDINGS_MAP_H_
« no previous file with comments | « mojo/public/cpp/bindings/lib/validation_errors.cc ('k') | mojo/public/cpp/bindings/string.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698