Mojo C++ bindings

mojo/public/bindings/lib/bindings.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_BINDINGS_LIB_BINDINGS_H_
+#define MOJO_PUBLIC_BINDINGS_LIB_BINDINGS_H_
+
+#include <stddef.h>
+#include <string.h>
+
+#include <new>
+
+#include "mojo/public/bindings/lib/bindings_internal.h"
+#include "mojo/public/bindings/lib/buffer.h"
+#include "mojo/public/system/core.h"
+
+namespace mojo {
+
+template <typename T>
+class Array {
+ public:
+  static Array<T>* New(Buffer* buf, size_t num_elements) {
+    size_t num_bytes = sizeof(Array<T>) + sizeof(StorageType) * num_elements;

[dmichael (off chromium), 2013/10/14 22:41:19]

Do you want to require here that num_bytes is a multiple of 8 bytes? Do you want
each element to be on an 8 byte boundary, or is it OK in your design to have
4-byte aligned types land on 4-byte boundaries?

I think you're OK, but I wanted to make sure you'd thought about it whether you
need to stick an Align() somewhere in the calculation of num_bytes.

+    return new (buf->Allocate(num_bytes)) Array<T>(num_bytes, num_elements);
+  }
+
+  template <typename U>
+  static Array<T>* NewCopyOf(Buffer* buf, const U& u) {
+    Array<T>* result = Array<T>::New(buf, u.size());
+    memcpy(result->storage(), u.data(), u.size() * sizeof(T));
+    return result;
+  }
+
+  size_t size() const { return header_.num_elements; }
+
+  T& at(size_t offset) {
+    return internal::ArrayTraits<T>::ToRef(storage()[offset]);
+  }
+
+  const T& at(size_t offset) const {
+    return internal::ArrayTraits<T>::ToConstRef(storage()[offset]);
+  }
+
+  T& operator[](size_t offset) {
+    return at(offset);
+  }
+
+  const T& operator[](size_t offset) const {
+    return at(offset);
+  }
+
+  template <typename U>
+  U To() const {
+    return U(storage(), storage() + size());
+  }
+
+ private:
+  friend class internal::ObjectTraits<Array<T> >;
+
+  typedef typename internal::ArrayTraits<T>::StorageType StorageType;
+
+  StorageType* storage() {
+    return reinterpret_cast<StorageType*>(this + 1);

[dmichael (off chromium), 2013/10/14 22:41:19]

Maybe you've already thought about this, but my understanding was that the
result of this conversion is unspecified. (See C++11 standard, 5.2.10p7). I
suspect it works in practice right now.

But note that your header is 4-byte aligned and 8-bytes wide. If T is a type
that has to be 8-byte aligned, then it probably works in practice right now. But
I think if your header changed to e.g. a 12-byte wide, 4-byte-aligned struct, I
think this would do the wrong thing. I.e., storage()[0] would not be aligned to
the 8-byte requirements of T. You might be able to mitigate that with a static
assert that the header size is a multiple of 8.

It also seems like doing it this way might obfuscate your code enough that the
optimizer won't do as well for at/operator[] as if you simply had the header and
an array as members. I think what you might really want is a zero-length array
after header_:
http://gcc.gnu.org/onlinedocs/gcc-4.0.4/gcc/Zero-Length.html
I think that solves a bunch of my above concerns. Alignment should be right, and
storage(), at(), and friends can be implemented more naturally.

+  }
+  const StorageType* storage() const {
+    return reinterpret_cast<const StorageType*>(this + 1);
+  }
+
+  Array(size_t num_bytes, size_t num_elements) {
+    header_.num_bytes = static_cast<uint32_t>(num_bytes);
+    header_.num_elements = static_cast<uint32_t>(num_elements);
+  }
+  ~Array() {}
+
+  internal::ArrayHeader header_;
+
+  // Elements of type internal::ArrayTraits<T>::StorageType follow.
+};
+
+// UTF-8 encoded
+typedef Array<char> String;
+
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_BINDINGS_LIB_BINDINGS_H_