Mojo: more idiomatic C++ bindings

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/cpp/bindings/buffer.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_serialization.h"
 #include "mojo/public/cpp/bindings/passable.h"
 
 namespace mojo {
 template <typename T> class Array;
 
 namespace internal {
@@ skipping 311 matching lines @@
 
   internal::ArrayHeader header_;
 
   // Elements of type internal::ArrayDataTraits<T>::StorageType follow.
 };
 MOJO_COMPILE_ASSERT(sizeof(Array_Data<char>) == 8, bad_sizeof_Array_Data);
 
 // UTF-8 encoded
 typedef Array_Data<char> String_Data;
 
-template <typename T, bool kIsObject, bool kIsHandle> struct ArrayTraits {};
+// ----
 
-// When T is an object type:
-template <typename T> struct ArrayTraits<T, true, false> {
-  typedef Array_Data<typename T::Data*> DataType;
-  typedef const T& ConstRef;
-  typedef T& Ref;
-  static Buffer::Destructor GetDestructor() {
-    return NULL;
+template <typename T, bool kIsMoveOnlyType> struct ArrayTraits {};
+
+template <typename T> struct ArrayTraits<T, false> {
+  typedef T StorageType;
+  typedef typename std::vector<T>::reference RefType;
+  typedef typename std::vector<T>::const_reference ConstRefType;
+  static inline void Initialize(std::vector<T>* vec) {
   }
-  static typename T::Data* ToArrayElement(const T& value) {
-    return Unwrap(value);
+  static inline void Finalize(std::vector<T>* vec) {
   }
-  // Something sketchy is indeed happening here...
-  static Ref ToRef(typename T::Data*& data) {
-    return *reinterpret_cast<T*>(&data);
+  static inline ConstRefType at(const std::vector<T>* vec, size_t offset) {
+    return vec->at(offset);
   }
-  static ConstRef ToConstRef(typename T::Data* const& data) {
-    return *reinterpret_cast<const T*>(&data);
+  static inline RefType at(std::vector<T>* vec, size_t offset) {
+    return vec->at(offset);
   }
 };
 
-// When T is a primitive (non-bool) type:
-template <typename T> struct ArrayTraits<T, false, false> {
-  typedef Array_Data<T> DataType;
-  typedef const T& ConstRef;
-  typedef T& Ref;
-  static Buffer::Destructor GetDestructor() {
-    return NULL;
+template <typename T> struct ArrayTraits<T, true> {
+  struct StorageType {
+    char buf[sizeof(T) + (8 - (sizeof(T) % 8)) % 8];  // Make 8-byte aligned.

[yzshen1, 2014/05/23 17:45:05]

What I was trying to ask is that with |vec| of type std::vector<StorageType>,
whether it is guaranteed that |vec[0].buf| is aligned properly for type T. (If
that is true, I think sizeof(StorgeType) == sizeof(T) is sufficient to make
|vec[x].buf| aligned properly.)

After some thoughts, I think it should be safe: because we use the default
allocator for std::vector, the memory is dynamic allocated so |vec[0].buf|
should be 
aligned for any T. :)

+  };
+  typedef T& RefType;
+  typedef const T& ConstRefType;
+  static inline void Initialize(std::vector<StorageType>* vec) {
+    for (size_t i = 0; i < vec->size(); ++i)
+      new (vec->at(i).buf) T();
   }
-  static T ToArrayElement(const T& value) {
-    return value;
+  static inline void Finalize(std::vector<StorageType>* vec) {
+    for (size_t i = 0; i < vec->size(); ++i)
+      reinterpret_cast<T*>(vec->at(i).buf)->~T();
   }
-  static Ref ToRef(T& data) { return data; }
-  static ConstRef ToConstRef(const T& data) { return data; }
-};
-
-// When T is a bool type:
-template <> struct ArrayTraits<bool, false, false> {
-  typedef Array_Data<bool> DataType;
-  typedef bool ConstRef;
-  typedef ArrayDataTraits<bool>::Ref Ref;
-  static Buffer::Destructor GetDestructor() {
-    return NULL;
+  static inline ConstRefType at(const std::vector<StorageType>* vec,
+                                size_t offset) {
+    return *reinterpret_cast<const T*>(vec->at(offset).buf);
   }
-  static bool ToArrayElement(const bool& value) {
-    return value;
-  }
-  static Ref ToRef(const Ref& data) { return data; }
-  static ConstRef ToConstRef(ConstRef data) { return data; }
-};
-
-// When T is a handle type:
-template <typename H> struct ArrayTraits<H, false, true> {
-  typedef Array_Data<H> DataType;
-  typedef Passable<H> ConstRef;
-  typedef AssignableAndPassable<H> Ref;
-  static Buffer::Destructor GetDestructor() {
-    return &DataType::Destructor;
-  }
-  static H ToArrayElement(const H& value) {
-    return value;
-  }
-  static Ref ToRef(H& data) { return Ref(&data); }
-  static ConstRef ToConstRef(const H& data) {
-    return ConstRef(const_cast<H*>(&data));
+  static inline RefType at(std::vector<StorageType>* vec, size_t offset) {
+    return *reinterpret_cast<T*>(vec->at(offset).buf);
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_