Index: mojo/public/cpp/bindings/array.h |
diff --git a/mojo/public/cpp/bindings/array.h b/mojo/public/cpp/bindings/array.h |
deleted file mode 100644 |
index 819b753cbd68b51458512ffcfcc866b443818939..0000000000000000000000000000000000000000 |
--- a/mojo/public/cpp/bindings/array.h |
+++ /dev/null |
@@ -1,315 +0,0 @@ |
-// 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 <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: |
- 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) {} |
- |
- // Makes null arrays implicitly constructible from |nullptr|. |
- Array(std::nullptr_t) : is_null_(true) {} |
- |
- ~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 |
- // constructor, if any, or else zero-initialized). |
- static Array New(size_t size) { |
- Array ret; |
- ret.resize(size); |
- return ret; |
- } |
- |
- // 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); |
- } |
- |
- // Resets the contents of this array back to null. |
- void reset() { |
- vec_.clear(); |
- is_null_ = true; |
- } |
- |
- // Tests as true if non-null, false if null. |
- explicit operator bool() const { return !is_null_; } |
- |
- // 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(); } |
- |
- // For non-null arrays of non-bool types, returns a pointer to the first |
- // element, if any. (If the array is empty, the semantics are the same as for |
- // |std::vector<T>::data()|. The behavior is undefined if the array is null.) |
- const T* data() const { return vec_.data(); } |
- T* data() { return vec_.data(); } |
- |
- // 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(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; |
- 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<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<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. |
- // |
- // 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 contains Mojo handles). |
- Array Clone() const { |
- Array result; |
- result.is_null_ = is_null_; |
- Traits::Clone(vec_, &result.vec_); |
- return result; |
- } |
- |
- // Indicates whether the contents of this array are equal to |other|. A null |
- // array is only equal to another null array. Elements are compared using the |
- // |ValueTraits::Equals| method, which in most cases calls the |Equals| method |
- // of the element. |
- bool Equals(const Array& other) const { |
- if (is_null() != other.is_null()) |
- return false; |
- if (size() != other.size()) |
- return false; |
- for (size_t i = 0; i < size(); ++i) { |
- if (!internal::ValueTraits<T>::Equals(at(i), other.at(i))) |
- return false; |
- } |
- return true; |
- } |
- |
- public: |
- // Array<>::Iterator satisfies the RandomAccessIterator concept: |
- // http://en.cppreference.com/w/cpp/concept/RandomAccessIterator. |
- class Iterator { |
- public: |
- using difference_type = std::ptrdiff_t; |
- |
- // The following satisfy BidirectionalIterator: |
- Iterator() : arr_(nullptr), pos_(0u) {} |
- Iterator(Array<T>* arr, size_t pos) : arr_(arr), pos_(pos) {} |
- Iterator& operator++() { |
- ++pos_; |
- return *this; |
- } |
- Iterator operator++(int) { |
- Iterator original = *this; |
- ++pos_; |
- return original; |
- } |
- Iterator& operator--() { |
- --pos_; |
- return *this; |
- } |
- Iterator operator--(int) { |
- Iterator original = *this; |
- --pos_; |
- return original; |
- } |
- bool operator==(const Iterator& o) const { |
- return o.arr_ == arr_ && o.pos_ == pos_; |
- } |
- bool operator!=(const Iterator& o) const { return !(*this == o); } |
- RefType operator*() const { return arr_->at(pos_); } |
- T* operator->() const { return &arr_->at(pos_); } |
- |
- // The following satisfy RandomAccessIterator: |
- Iterator& operator+=(difference_type dist) { |
- pos_ += dist; |
- return *this; |
- } |
- Iterator& operator-=(difference_type dist) { |
- pos_ -= dist; |
- return *this; |
- } |
- friend Iterator operator+(difference_type dist, const Iterator& o_it) { |
- return Iterator(o_it.arr_, dist + o_it.pos_); |
- } |
- Iterator operator+(difference_type dist) const { |
- return Iterator(arr_, pos_ + dist); |
- } |
- Iterator operator-(difference_type dist) const { |
- return Iterator(arr_, pos_ - dist); |
- } |
- difference_type operator-(const Iterator& o_it) const { |
- return pos_ - o_it.pos_; |
- } |
- bool operator<(const Iterator& o_it) const { return pos_ < o_it.pos_; } |
- bool operator>(const Iterator& o_it) const { return pos_ > o_it.pos_; } |
- bool operator<=(const Iterator& o_it) const { return pos_ <= o_it.pos_; } |
- bool operator>=(const Iterator& o_it) const { return pos_ >= o_it.pos_; } |
- RefType operator[](difference_type dist) { return arr_->at(pos_ + dist); } |
- |
- private: |
- Array<T>* arr_; |
- size_t pos_; |
- }; |
- |
- Iterator begin() { return Iterator(this, 0); } |
- Iterator end() { return Iterator(this, size()); } |
- |
- private: |
- void Take(Array* other) { |
- reset(); |
- Swap(other); |
- } |
- |
- 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>> { |
- static Array<T> Convert(const std::vector<E>& input) { |
- auto result = Array<T>::New(input.size()); |
- for (size_t i = 0; i < input.size(); ++i) |
- result[i] = TypeConverter<T, E>::Convert(input[i]); |
- return 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 = Array<T>::New(0u); |
- for (auto i : input) |
- result.push_back(TypeConverter<T, E>::Convert(i)); |
- return 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; |
- } |
-}; |
- |
-} // namespace mojo |
- |
-#endif // MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_ |