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 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 inline void Finalize(std::vector<T>* vec) {
+  }
+  static inline ConstRefType at(const std::vector<T>* vec, size_t offset) {
+    return vec->at(offset);
+  }
+  static inline RefType at(std::vector<T>* vec, size_t offset) {
+    return vec->at(offset);
+  }
+};
+
+template <typename T> struct ArrayTraits<T, true> {
+  struct StorageType {
+    char buf[sizeof(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();

[yzshen1, 2014/05/22 17:13:53]

Is there potential alignment issue here?

One alternative is to wrap move-only objects with something like SharedData<>.
Although there is some some storage overhead, it seems less hacky to me.
Besides, those methods of Array returning "const std::vector<StorageType>&" make
more sense this way.

+  }
+  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 inline ConstRefType at(const std::vector<StorageType>* vec,
+                                size_t offset) {
+    return *reinterpret_cast<const T*>(vec->at(offset).buf);
+  }
+  static inline RefType at(std::vector<StorageType>* vec, size_t offset) {
+    return *reinterpret_cast<T*>(vec->at(offset).buf);
+  }
+};
+
+#if 0
+template <typename E> struct ArrayTraits<Array<E>, true> {
+  typedef S* StorageType;
+  static const T& at(const std::vector<StorageType>& vec, size_t offset) const {
+    const S*& slot = vec.at(offset);
+    return *reinterpret_cast<const T*>(reinterpret_cast<const char**>(&slot);
+  }
+  static T& at(std::vector<StorageType>& vec, size_t offset) {
+    S*& slot = vec.at(offset);
+    return *reinterpret_cast<T*>(reinterpret_cast<char**>(&slot);
+  }
+};
+#endif
+
+#if 0
 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;
   }
@@ skipping 48 matching lines @@
     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));
   }
 };
+#endif
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_