Mojo: Add resize and push_back to Array.

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>
 
@@ skipping 262 matching lines @@
 
 // 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;
+  typedef ConstRefType SinkType;
   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);
   }
+  static inline void Resize(std::vector<T>* vec, size_t size) {
+    vec->resize(size);
+  }
+  static inline void PushBack(std::vector<T>* vec, SinkType value) {

[darin (slow to review), 2014/06/10 22:33:13]

I don't quite understand the use of the term "Sink" here. In the callback code
we use the term ForwardType.

[Sam McNally, 2014/06/10 23:55:17]

Done.

+    vec->push_back(value);
+  }
 };
 
 template <typename T> struct ArrayTraits<T, true> {
   struct StorageType {
     char buf[sizeof(T) + (8 - (sizeof(T) % 8)) % 8];  // Make 8-byte aligned.
   };
   typedef T& RefType;
   typedef const T& ConstRefType;
+  typedef T SinkType;
   static inline void Initialize(std::vector<StorageType>* vec) {
     for (size_t i = 0; i < vec->size(); ++i)
       new (vec->at(i).buf) T();
   }
   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);
   }
+  static inline void Resize(std::vector<StorageType>* vec, size_t size) {
+    size_t old_size = vec->size();
+    for (size_t i = size; i < old_size; i++)
+      reinterpret_cast<T*>(vec->at(i).buf)->~T();
+    ResizeStorage(vec, size);
+    for (size_t i = old_size; i < vec->size(); i++)
+      new (vec->at(i).buf) T();
+  }
+  static inline void PushBack(std::vector<StorageType>* vec, RefType value) {
+    size_t old_size = vec->size();
+    ResizeStorage(vec, old_size + 1);
+    new (vec->at(old_size).buf) T(value.Pass());
+  }
+  static inline void ResizeStorage(std::vector<StorageType>* vec, size_t size) {
+    if (size <= vec->capacity()) {
+      vec->resize(size);
+      return;
+    }
+    std::vector<StorageType> new_storage(size);
+    for (size_t i = 0; i < vec->size(); i++)
+      new (new_storage.at(i).buf) T(at(vec, i).Pass());
+    vec->swap(new_storage);
+    Finalize(&new_storage);
+  }
 };
 
 template <> struct WrapperTraits<String, false> {
   typedef String_Data* DataType;
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_