mojom: Add associative arrays to the mojom language.

mojo/public/cpp/bindings/lib/array_internal.h

 // Copyright 2013 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_ARRAY_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_
 
 #include <new>
 #include <vector>
 
 #include "mojo/public/c/system/macros.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_serialization.h"
 #include "mojo/public/cpp/bindings/lib/bounds_checker.h"
 #include "mojo/public/cpp/bindings/lib/buffer.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/lib/validate_params.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/environment/logging.h"
 
 namespace mojo {
 template <typename T>
 class Array;
 class String;
 
 namespace internal {
 
@@ skipping 107 matching lines @@
     return sizeof(ArrayHeader) + ((num_elements + 7) / 8);
   }
   static BitRef ToRef(StorageType* storage, size_t offset) {
     return BitRef(&storage[offset / 8], 1 << (offset % 8));
   }
   static bool ToConstRef(const StorageType* storage, size_t offset) {
     return (storage[offset / 8] & (1 << (offset % 8))) != 0;
   }
 };
 
-// Array type information needed for valdiation.
-template <uint32_t in_expected_num_elements,
-          bool in_element_is_nullable,
-          typename InElementValidateParams>
-class ArrayValidateParams {
- public:
-  // Validation information for elements. It is either another specialization of
-  // ArrayValidateParams (if elements are arrays) or NoValidateParams.
-  typedef InElementValidateParams ElementValidateParams;
-
-  // If |expected_num_elements| is not 0, the array is expected to have exactly
-  // that number of elements.
-  static const uint32_t expected_num_elements = in_expected_num_elements;
-  // Whether the elements are nullable.
-  static const bool element_is_nullable = in_element_is_nullable;
-};
-
-// NoValidateParams is used to indicate the end of an ArrayValidateParams chain.
-class NoValidateParams {};
-
 // What follows is code to support the serialization of Array_Data<T>. There
 // are two interesting cases: arrays of primitives and arrays of objects.
 // Arrays of objects are represented as arrays of pointers to objects.
 
 template <typename T, bool is_handle>
 struct ArraySerializationHelper;
 
 template <typename T>
 struct ArraySerializationHelper<T, false> {
   typedef typename ArrayDataTraits<T>::StorageType ElementType;
@@ skipping 132 matching lines @@
   template <typename T, typename Params>
   struct ValidateCaller {
     static bool Run(const void* data, BoundsChecker* bounds_checker) {
       static_assert((IsSame<Params, NoValidateParams>::value),
                     "Struct type should not have array validate params");
 
       return T::Validate(data, bounds_checker);
     }
   };
 
+  template <typename Key, typename Value, typename Params>
+  struct ValidateCaller<Map_Data<Key, Value>, Params> {
+    static bool Run(const void* data, BoundsChecker* bounds_checker) {
+      return Map_Data<Key, Value>::template Validate<Params>(data,
+                                                             bounds_checker);
+    }
+  };
+
   template <typename T, typename Params>
   struct ValidateCaller<Array_Data<T>, Params> {
     static bool Run(const void* data, BoundsChecker* bounds_checker) {
       return Array_Data<T>::template Validate<Params>(data, bounds_checker);
     }
   };
 };
 
 template <typename T>
 class Array_Data {
@@ skipping 50 matching lines @@
 
     const Array_Data<T>* object = static_cast<const Array_Data<T>*>(data);
     return Helper::template ValidateElements<
         Params::element_is_nullable,
         typename Params::ElementValidateParams>(
         &object->header_, object->storage(), bounds_checker);
   }
 
   size_t size() const { return header_.num_elements; }
 
+  const internal::ArrayHeader& header() { return header_; }
+
   Ref at(size_t offset) {
     MOJO_DCHECK(offset < static_cast<size_t>(header_.num_elements));
     return Traits::ToRef(storage(), offset);
   }
 
   ConstRef at(size_t offset) const {
     MOJO_DCHECK(offset < static_cast<size_t>(header_.num_elements));
     return Traits::ToConstRef(storage(), offset);
   }
 
@@ skipping 117 matching lines @@
 
 template <>
 struct WrapperTraits<String, false> {
   typedef String_Data* DataType;
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_