Revert "libmojo: Uprev the library to r456626 from Chromium"
This reverts commit 8ac9103e05b66812c25348943383f9365d1ce3e0.
Reason for revert: Broke the mac_sdk
Exempt-From-Owner-Approval: Fixing mac_sdk
Change-Id: I0b74d1abaa66933a93fd6f82ff018e8948c1204e
diff --git a/mojo/public/cpp/bindings/array.h b/mojo/public/cpp/bindings/array.h
new file mode 100644
index 0000000..a253da1
--- /dev/null
+++ b/mojo/public/cpp/bindings/array.h
@@ -0,0 +1,279 @@
+// 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 <stddef.h>
+#include <string.h>
+#include <algorithm>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/macros.h"
+#include "mojo/public/cpp/bindings/lib/array_internal.h"
+#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
+#include "mojo/public/cpp/bindings/lib/clone_equals_util.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:
+ using ConstRefType = typename std::vector<T>::const_reference;
+ using RefType = typename std::vector<T>::reference;
+
+ using Element = T;
+
+ using iterator = typename std::vector<T>::iterator;
+ using const_iterator = typename std::vector<T>::const_iterator;
+
+ // Constructs an empty array.
+ Array() : is_null_(false) {}
+ // Constructs a null array.
+ Array(std::nullptr_t null_pointer) : is_null_(true) {}
+
+ // Constructs a new non-null array of the specified size. The elements will
+ // be value-initialized (meaning that they will be initialized by their
+ // default constructor, if any, or else zero-initialized).
+ explicit Array(size_t size) : vec_(size), is_null_(false) {}
+ ~Array() {}
+
+ // Copies the contents of |other| into this array.
+ Array(const std::vector<T>& other) : vec_(other), is_null_(false) {}
+
+ // Moves the contents of |other| into this array.
+ Array(std::vector<T>&& other) : vec_(std::move(other)), is_null_(false) {}
+ Array(Array&& other) : is_null_(true) { Take(&other); }
+
+ Array& operator=(std::vector<T>&& other) {
+ vec_ = std::move(other);
+ is_null_ = false;
+ return *this;
+ }
+ Array& operator=(Array&& other) {
+ Take(&other);
+ return *this;
+ }
+
+ Array& operator=(std::nullptr_t null_pointer) {
+ is_null_ = true;
+ vec_.clear();
+ 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
+ // constructor, if any, or else zero-initialized).
+ static Array New(size_t size) { return Array(size); }
+
+ // Creates a new array with a copy of the contents of |other|.
+ template <typename U>
+ static Array From(const U& other) {
+ return TypeConverter<Array, U>::Convert(other);
+ }
+
+ // 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);
+ }
+
+ // Indicates whether the array is null (which is distinct from empty).
+ bool is_null() const { return is_null_; }
+
+ // Indicates whether the array is empty (which is distinct from null).
+ bool empty() const { return vec_.empty() && !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(); }
+
+ iterator begin() { return vec_.begin(); }
+ const_iterator begin() const { return vec_.begin(); }
+ iterator end() { return vec_.end(); }
+ const_iterator end() const { return vec_.end(); }
+
+ // 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 vec_.at(offset); }
+ ConstRefType operator[](size_t offset) const { return at(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(const T& value) {
+ is_null_ = false;
+ vec_.push_back(value);
+ }
+ void push_back(T&& value) {
+ is_null_ = false;
+ vec_.push_back(std::move(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;
+ vec_.resize(size);
+ }
+
+ // Sets the array to empty (even if previously it was null.)
+ void SetToEmpty() { resize(0); }
+
+ // 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<T>& storage() const { return vec_; }
+
+ // Passes the underlying storage and resets this array to null.
+ std::vector<T> PassStorage() {
+ is_null_ = true;
+ return std::move(vec_);
+ }
+
+ operator const std::vector<T>&() const { return vec_; }
+
+ 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<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 the element type
+ // defines a Clone() method, it will be used; otherwise copy
+ // constructor/assignment will be used.
+ //
+ // Please note that calling this method will fail compilation if the element
+ // type cannot be cloned (which usually means that it is a Mojo handle type or
+ // a type containing Mojo handles).
+ Array Clone() const {
+ Array result;
+ result.is_null_ = is_null_;
+ result.vec_ = internal::Clone(vec_);
+ return result;
+ }
+
+ // Indicates whether the contents of this array are equal to |other|. A null
+ // array is only equal to another null array. If the element type defines an
+ // Equals() method, it will be used; otherwise == operator will be used.
+ bool Equals(const Array& other) const {
+ if (is_null() != other.is_null())
+ return false;
+ return internal::Equals(vec_, other.vec_);
+ }
+
+ private:
+ typedef std::vector<T> Array::*Testable;
+
+ public:
+ operator Testable() const { return is_null_ ? 0 : &Array::vec_; }
+
+ private:
+ // Forbid the == and != operators explicitly, otherwise Array will be
+ // converted to Testable to do == or != comparison.
+ template <typename U>
+ bool operator==(const Array<U>& other) const = delete;
+ template <typename U>
+ bool operator!=(const Array<U>& other) const = delete;
+
+ void Take(Array* other) {
+ operator=(nullptr);
+ Swap(other);
+ }
+
+ std::vector<T> vec_;
+ bool is_null_;
+
+ DISALLOW_COPY_AND_ASSIGN(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>> {
+ static Array<T> Convert(const std::vector<E>& input) {
+ Array<T> result(input.size());
+ for (size_t i = 0; i < input.size(); ++i)
+ result[i] = TypeConverter<T, E>::Convert(input[i]);
+ return std::move(result);
+ }
+};
+
+// A |TypeConverter| that will create an |std::vector<E>| containing a copy of
+// the contents of an |Array<T>|, using |TypeConverter<E, T>| to copy each
+// element. If the input array is null, the output vector will be empty.
+template <typename E, typename T>
+struct TypeConverter<std::vector<E>, Array<T>> {
+ static std::vector<E> Convert(const Array<T>& input) {
+ std::vector<E> result;
+ if (!input.is_null()) {
+ result.resize(input.size());
+ for (size_t i = 0; i < input.size(); ++i)
+ result[i] = TypeConverter<E, T>::Convert(input[i]);
+ }
+ return result;
+ }
+};
+
+// A |TypeConverter| that will create an |Array<T>| containing a copy of the
+// contents of an |std::set<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::set<E>> {
+ static Array<T> Convert(const std::set<E>& input) {
+ Array<T> result;
+ for (auto i : input)
+ result.push_back(TypeConverter<T, E>::Convert(i));
+ return std::move(result);
+ }
+};
+
+// A |TypeConverter| that will create an |std::set<E>| containing a copy of
+// the contents of an |Array<T>|, using |TypeConverter<E, T>| to copy each
+// element. If the input array is null, the output set will be empty.
+template <typename E, typename T>
+struct TypeConverter<std::set<E>, Array<T>> {
+ static std::set<E> Convert(const Array<T>& input) {
+ std::set<E> result;
+ if (!input.is_null()) {
+ for (size_t i = 0; i < input.size(); ++i)
+ result.insert(TypeConverter<E, T>::Convert(input[i]));
+ }
+ return result;
+ }
+};
+
+// Less than operator to allow Arrays as keys in std maps and sets.
+template <typename T>
+inline bool operator<(const Array<T>& a, const Array<T>& b) {
+ if (a.is_null())
+ return !b.is_null();
+ if (b.is_null())
+ return false;
+ return a.storage() < b.storage();
+}
+
+} // namespace mojo
+
+#endif // MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_