Simplify mojo::internal::ArrayTraits.

mojo/public/cpp/bindings/array.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_ARRAY_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_
 
 #include <string.h>
 
 #include <algorithm>
 #include <cstddef>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
 
 // Represents a moveable array with contents of type |T|. The array can be null,
 // meaning that no value has been assigned to it. Null is distinct from empty.
 template <typename T>
 class Array {
  public:
-  typedef internal::ArrayTraits<T, internal::IsMoveOnlyType<T>::value> Traits;
-  typedef typename Traits::ConstRefType ConstRefType;
-  typedef typename Traits::RefType RefType;
-  typedef typename Traits::StorageType StorageType;
-  typedef typename Traits::ForwardType ForwardType;
+  using ConstRefType = typename std::vector<T>::const_reference;
+  using RefType = typename std::vector<T>::reference;
+
+  using Traits = internal::ArrayTraits<T, internal::IsMoveOnlyType<T>::value>;
+  using ForwardType = typename Traits::ForwardType;
 
   typedef internal::Array_Data<typename internal::WrapperTraits<T>::DataType>
       Data_;
 
   // Constructs a new array that is null.
   Array() : is_null_(true) {}
 
-  ~Array() { Traits::Finalize(&vec_); }
+  ~Array() {}
 
   // Moves the contents of |other| into this array.
   Array(Array&& other) : is_null_(true) { Take(&other); }
   Array& operator=(Array&& other) {
     Take(&other);
     return *this;
   }
 
   // Creates a non-null array of the specified size. The elements will be
   // value-initialized (meaning that they will be initialized by their default
@@ skipping 11 matching lines @@
   }
 
   // Copies the contents of this array to a new object of type |U|.
   template <typename U>
   U To() const {
     return TypeConverter<U, Array>::Convert(*this);
   }
 
   // Resets the contents of this array back to null.
   void reset() {
-    if (!vec_.empty()) {
-      Traits::Finalize(&vec_);
+    if (!vec_.empty())
       vec_.clear();
-    }
     is_null_ = true;
   }
 
   // Indicates whether the array is null (which is distinct from empty).
   bool is_null() const { return is_null_; }
 
   // Returns a reference to the first element of the array. Calling this on a
   // null or empty array causes undefined behavior.
   ConstRefType front() const { return vec_.front(); }
   RefType front() { return vec_.front(); }
 
   // Returns the size of the array, which will be zero if the array is null.
   size_t size() const { return vec_.size(); }
 
   // Returns a reference to the element at zero-based |offset|. Calling this on
   // an array with size less than |offset|+1 causes undefined behavior.
-  ConstRefType at(size_t offset) const { return Traits::at(&vec_, offset); }
+  ConstRefType at(size_t offset) const { return vec_.at(offset); }
   ConstRefType operator[](size_t offset) const { return at(offset); }
-  RefType at(size_t offset) { return Traits::at(&vec_, offset); }
+  RefType at(size_t offset) { return vec_.at(offset); }
   RefType operator[](size_t offset) { return at(offset); }
 
   // Pushes |value| onto the back of the array. If this array was null, it will
   // become non-null with a size of 1.
   void push_back(ForwardType value) {
     is_null_ = false;
     Traits::PushBack(&vec_, value);
   }
 
   // Resizes the array to |size| and makes it non-null. Otherwise, works just
   // like the resize method of |std::vector|.
   void resize(size_t size) {
     is_null_ = false;
-    Traits::Resize(&vec_, size);
+    vec_.resize(size);
   }
 
   // Returns a const reference to the |std::vector| managed by this class. If
   // the array is null, this will be an empty vector.
-  const std::vector<StorageType>& storage() const { return vec_; }
-  operator const std::vector<StorageType>&() const { return vec_; }
+  const std::vector<T>& storage() const { return vec_; }
+  operator const std::vector<T>&() const { return vec_; }
 
   // Swaps the contents of this array with the |other| array, including
   // nullness.
   void Swap(Array* other) {
     std::swap(is_null_, other->is_null_);
     vec_.swap(other->vec_);
   }
 
   // Swaps the contents of this array with the specified vector, making this
   // array non-null. Since the vector cannot represent null, it will just be
   // made empty if this array is null.
-  void Swap(std::vector<StorageType>* other) {
+  void Swap(std::vector<T>* other) {
     is_null_ = false;
     vec_.swap(*other);
   }
 
   // Returns a copy of the array where each value of the new array has been
   // "cloned" from the corresponding value of this array. If this array contains
   // primitive data types, this is equivalent to simply copying the contents.
   // However, if the array contains objects, then each new element is created by
   // calling the |Clone| method of the source element, which should make a copy
   // of the element.
@@ skipping 88 matching lines @@
 
    private:
     Array<T>* arr_;
     size_t pos_;
   };
 
   Iterator begin() { return Iterator(this, 0); }
   Iterator end() { return Iterator(this, size()); }
 
  private:
-  typedef std::vector<StorageType> Array::*Testable;
+  typedef std::vector<T> Array::*Testable;
 
  public:
   operator Testable() const { return is_null_ ? 0 : &Array::vec_; }
 
  private:
   void Take(Array* other) {
     reset();
     Swap(other);
   }
 
-  std::vector<StorageType> vec_;
+  std::vector<T> vec_;
   bool is_null_;
 
   MOJO_MOVE_ONLY_TYPE(Array);
 };
 
 // A |TypeConverter| that will create an |Array<T>| containing a copy of the
 // contents of an |std::vector<E>|, using |TypeConverter<T, E>| to copy each
 // element. The returned array will always be non-null.
 template <typename T, typename E>
 struct TypeConverter<Array<T>, std::vector<E>> {
@@ skipping 45 matching lines @@
       for (size_t i = 0; i < input.size(); ++i)
         result.insert(TypeConverter<E, T>::Convert(input[i]));
     }
     return result;
   }
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_