blob: 819b753cbd68b51458512ffcfcc866b443818939 [file] [log] [blame]
// 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_