/* Static Size Container Array * * Wrapper class to a c-array of Tp_[n_] * * @tparam Tp_ -> element type * @tparam n_ -> size of array */ template class Array { /* EnableCMem * check for the ability to * use `memcpy` and `memmove` * from a type Vp_ to a type Tp_ */ template using EnableCMem = meta::BoolConstant< sizeof(Vp_) == sizeof(Tp_) && std::is_pod::value && std::is_pod::value >; /* Store size of data array in type * for zero overhead */ using DataSize = meta::SizeConstant; /* Raw Data */ Tp_ _data[n_]; public: //============================================ // ** Initialisation ** //============================================ /* Maintain default initialisation * from compilier * * default: * ~ Default Ctor * ~ Copy Ctor * ~ Move Ctor * ~ Destructor * ~ Copy Assignment Operator * ~ Move Assignment Operator */ Array(void) = default; Array(const Array &) = default; Array(Array &&) = default; ~Array(void) = default; Array & operator = (const Array &) = default; Array & operator = (Array &&) = default; /* Values Constructor * * move a variadic list of values into the raw data * * enabled when exactly n_ many values are provided * * @tparam Tps_ -> parameter pack of arguments to move assign * * ASSERT: Every Tps_ is move assignable */ template == n_ >> Array(Tps_ && ... values) : _data{ std::move(values) ... } {} //============================================ // ** Data Access ** //============================================ /* Subcript Operator * * access an individual element in the array * * @param index -> element in the array */ Tp_ & operator[] (const Size & index) { return Array::_data[index]; } const Tp_ & operator[] (const Size & index) const { return Array::_data[index]; } /* Iterators * * access [begin, end) pointers of the array */ Tp_ * begin(void) { return Array::_data; } Tp_ * end(void) { return Array::_data + n_; } const Tp_ * begin(void) const { return Array::_data; } const Tp_ * end(void) const { return Array::_data + n_; } /* First and Last * * access the first and last element in array */ Tp_ & front(void) { return *Array::_data; } Tp_ & back(void) { return *(Array::_data + n_ - 1); } const Tp_ & front(void) const { return *Array::_data; } const Tp_ & back(void) const { return *(Array::_data + n_ - 1); } /* Raw Data * * access a pointer to the raw data */ Tp_ * data(void) { return Array::_data; } const Tp_ * data(void) const { return Array::_data; } //============================================ // ** Utilities ** //============================================ /* Array size * * static size of array -> n_ */ static constexpr Size size(void) { return n_; } /* Array Fill * * copy value to every element in array * * @param value -> value to copy assign * * ASSERT: copy assignable from const Vp_ to Tp_ */ template void fill(const Vp_ & value) { static_assert(meta::CopyAssignable_v, "Array::fill(const Vp_ &) ~ Invalid Vp_, requires copy assignability from const Vp_ to Tp_ \n"); std::fill(Array::begin(), Array::end(), value); } /* Array Copy * * copy data from rhs array to lhs * * enable if c-styled copy available between types * * @param array -> the rhs Array of any type */ template meta::EnableIf_t::value> copy(const Array & array) { memcpy(Array::_data, array.begin(), DataSize::value); } /* Array Copy * * iterate copy from rhs array to lhs * * enable if c-styled copy is NOT available between types * * @param array -> the rhs Array of any type * * ASSERT: copy assignable from const Vp_ to Tp_ */ template meta::EnableIf_t::value> copy(const Array & array) { static_assert(meta::CopyAssignable_v, "Array::copy(const Array &) ~ Invalid Vp_, requires copy assignability from const Vp_ to Tp_ \n"); std::copy(array.begin(), array.end(), Array::begin()); } /* Array Move * * move data from rhs array to lhs * * enable if c-styled move available between types * * @param array -> rhs Array of any type */ template meta::EnableIf_t::value> move(Array && array) { memmove(Array::_data, array.begin(), DataSize::value); } /* Array Move * * iterate move from rhs array to lhs * * enable if c-styled move NOT available between types * * @param array -> rhs Array of any type * * ASSERT: move assignable from Vp_ to Tp_ */ template meta::EnableIf_t::value> move(Array && array) { static_assert(meta::MoveAssignable_v, "Array::move(Array &&) ~ Invalid Vp_, requires move assignability from Vp_ to Tp_ \n"); std::move(array.begin(), array.end(), Array::begin()); } /* Array Swap * * swap data betwen rhs array and lhs array * * @param array -> rhs Array to swap */ template void swap(Array & array) { auto array_temp = std::move(array); array = std::move(*this); *this = std::move(array_temp); } //============================================ // ** Operators ** //============================================ /* Function Operator * * call `function` for every element * * @param function -> function to call * * ASSERT: function is callable as * function(Tp_ &, const Size &) */ void operator() (auto function) { static_assert(meta::Callable_v, "Array::operator()(auto function) ~ Invalid function, requires signature function(Tp_ &, const Size &) \n"); for (Size i = 0; i != n_; ++i) function(Array::_data[i], i); } /* Array Cast * * creates an implicit conversion from * this Array to an Array * * copies data from this to lhs */ template operator Array (void) { Array conversion; conversion.copy(*this); return conversion; } /* Equality * * validate if every element in rhs array is * equal to every element in lhs array * * @param array -> rhs Array of any type * * ASSERT: equatability between Tp_ and const Vp_ */ template auto operator == (const Array & array) { static_assert(meta::Equatable_v, "Array::operator==(const Array &) ~ Invalid Vp_, requires equatability between Tp_ and const Vp_ \n"); return std::equal(array.begin(), array.end(), Array::begin()); } /* Scalar Equality * * validate if value is equal to * every element in lhs array * * @param value -> value of any type * * ASSERT: equatability between Tp_ and const Vp_ */ template auto operator == (const Vp_ & value) { static_assert(meta::Equatable_v, "Array::operator==(const Vp_ &) ~ Invalid Vp_, requires equatability between Tp_ and const Vp_ \n"); return std::equal(Array::begin(), Array::end(), value); } /* Inequality * * return the inverse of equality */ template auto operator != (const Array & array) { return !(*this == array); } /* Scalar Inequality * * return the inverse of scalar inequality */ template auto operator != (const Vp_ & value) { return !(*this == value); } /* Addition * * assign the addition of every element * in rhs array and every element in lhs * array to a new instance and return * * @param array -> rhs Array of any type * * ASSERT: addability between Tp_ and const Vp_ */ template auto operator + (const Array & array) { static_assert(meta::Addable_v, "Array::operator+(const Array &) ~ Invalid Vp_, requires addability between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] + array[index]; }); return result; } /* Scalar Addition * * assign the addition of rhs value and * every element in lhs array to * a new instance and return * * @param value -> rhs value of any type * * ASSERT: addability between Tp_ and const Vp_ */ template auto operator + (const Vp_ & value) { static_assert(meta::Addable_v, "Array::operator+(const Vp_ &) ~ Invalid Vp_, requires addability between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] + value; }); return result; } /* Negation * * assign the negation of every element * in rhs array to new instance and return * * ASSERT: negatability of a const Tp_ */ auto operator - (void) { static_assert(meta::Negatable_v, "Array::operator-(void) ~ Invalid Tp_, requires negatability on a Tp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = -(this->_data[index]); }); return result; } /* Subtraction * * assign the subtraction of every element * in rhs array and every element in the lhs * array to a new instance and return * * @param array -> rhs Array of any type * * ASSERT: subtractability between Tp_ and const Vp_ */ template auto operator - (const Array & array) { static_assert(meta::Subtractable_v, "Array::operator-(const Array &) ~ Invalid Vp_, requires subtractability between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] - array[index]; }); return result; } /* Scalar Subtraction * * assign the subtraction of rhs value and * every element in lhs array to * a new instance and return * * @param value -> rhs value of any type * * ASSERT: subtractability between Tp_ and const Vp_ */ template auto operator - (const Vp_ & value) { static_assert(meta::Subtractable_v, "Array::operator-(const Vp_ &) ~ Invalid Vp_, requires subtractability between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] - value; }); return result; } /* Product * * assign the product of every element * in rhs array and every element in the lhs * array to a new instance and return * * @param array -> rhs Array of any type * * ASSERT: multiplicativity between Tp_ and const Vp_ */ template auto operator * (const Array & array) { static_assert(meta::Multiplicative_v, "Array::operator*(const Array &) ~ Invalid Vp_, requires multiplicativity between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] * array[index]; }); return result; } /* Scalar Product * * assign the product of rhs value and * every element in lhs array to * a new instance and return * * @param value -> rhs value of any type * * ASSERT: multiplicativity between Tp_ and const Vp_ */ template auto operator * (const Vp_ & value) { static_assert(meta::Multiplicative_v, "Array::operator*(const Vp_ &) ~ Invalid Vp_, requires multiplicativity between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] * value; }); return result; } /* Quotient * * assign the quotient of every element * in rhs array and every element in the lhs * array to a new instance and return * * @param array -> rhs Array of any type * * ASSERT: divisibility between Tp_ and const Vp_ */ template auto operator / (const Array & array) { static_assert(meta::Divisible_v, "Array::operator/(const Array &) ~ Invalid Vp_, requires divisbility between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] / array[index]; }); return result; } /* Scalar Quotient * * assign the quotient of rhs value and * every element in lhs array to * a new instance and return * * @param value -> rhs value of any type * * ASSERT: divisibility between Tp_ and const Vp_ */ template auto operator / (const Vp_ & value) { static_assert(meta::Divisible_v, "Array::operator/(const Vp_ &) ~ Invalid Vp_, requires divisbility between Tp_ and const Vp_ \n"); Array, n_> result; result([&, this](auto & elem, const auto & index) { elem = this->_data[index] / value; }); return result; } };