array_.hpp

Go to the documentation of this file.

#pragma once
 
#if !defined(__XTD_ARRAY_INTERNAL__)
#error "Do not include this file: Internal use only. Include <xtd/array> or <xtd/array.hpp> instead."
#endif
 
#include "index.hpp"
#include "string.hpp"
#include "collections/object_model/read_only_collection.hpp"
#include <numeric>

namespace xtd {
  // Deduction guides for xtd::array
  // {
  template<typename type_t, xtd::usize length>
  array(const type_t(&)[length]) -> array<type_t, 1>;
  
  template<typename type_t>
  array(const type_t*, xtd::usize) -> array<type_t, 1>;
  
  template<typename type_t>
  array(const xtd::collections::generic::ienumerable<type_t>&) -> array<type_t, 1>;
  
  template<typename type_t>
  array(const xtd::collections::generic::ilist<type_t>&) -> array<type_t, 1>;
  
  template<typename input_iterator_t>
  array(input_iterator_t, input_iterator_t) -> array<std::iter_value_t<input_iterator_t>, 1>;
  
  template<typename type_t>
  array(const std::vector<type_t>&) -> array<type_t, 1>;
  
  template<typename type_t>
  array(std::vector<type_t>&&) -> array<type_t, 1>;
  
  template<typename type_t>
  array(std::vector<std::vector<type_t>>) -> array<type_t, 2>;
  
  template<typename type_t>
  array(std::vector<std::vector<std::vector<type_t>>>) -> array<type_t, 3>;
  
  template<typename type_t>
  array(std::initializer_list<type_t>) -> array<type_t, 1>;
  
  template<typename type_t>
  array(std::initializer_list<std::initializer_list<type_t>>) -> array<type_t, 2>;
  
  template<typename type_t>
  array(std::initializer_list<std::initializer_list<std::initializer_list<type_t>>>) -> array<type_t, 3>;
  // }
}
 
template<typename type_t, typename allocator_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::get_value(const xtd::array<xtd::usize>& indexes) const {
  return operator()(indexes);
}
 
template<typename type_t, typename allocator_t>
xtd::array<xtd::usize, 1> xtd::basic_array<type_t, allocator_t>::get_lengths() const {
  auto result = xtd::array<xtd::usize, 1>(rank());
  for (auto r = xtd::usize {}; r < rank(); ++r)
    result[r] = get_length(r);
  return result;
}
 
template<typename type_t, typename allocator_t>
inline xtd::string xtd::basic_array<type_t, allocator_t>::to_string() const noexcept {
  return xtd::string::format("[{}]", xtd::string::join(", ", *this));
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator [](const xtd::array<index_t>& indexes) {
  return data_->items[compute_index(self_, indexes)];
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator [](const xtd::array<index_t>& indexes) const {
  return data_->items[compute_index(self_, indexes)];
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator [](const std::initializer_list<index_t>& indexes) {
  return data_->items[compute_index(self_, xtd::array<index_t> {indexes})];
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator [](const std::initializer_list<index_t>& indexes) const {
  return data_->items[compute_index(self_, xtd::array<index_t> {indexes})];
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator()(const xtd::array<index_t>& indexes) {
  return operator [](indexes);
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator()(const xtd::array<index_t>& indexes) const {
  return operator [](indexes);
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator ()(const std::initializer_list<index_t>& indexes) {
  return data_->items[compute_index(self_, xtd::array<index_t> {indexes})];
}
 
template<typename type_t, typename allocator_t>
template<xtd::integer index_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator ()(const std::initializer_list<index_t>& indexes) const {
  return data_->items[compute_index(self_, xtd::array<index_t> {indexes})];
}
 
template<typename type_t, typename allocator_t>
inline xtd::basic_array<type_t, allocator_t>::basic_array(const array<size_type, 1>& lengths) {
  data_->items = base_type(lengths.aggregate([&](const size_type & accumulator, const size_type & value) {return accumulator * value;}));
  data_->lower_bound.clear();
  data_->upper_bound.clear();
  for (auto length : lengths) {
    data_->lower_bound.push_back(0);
    data_->upper_bound.push_back(length - 1);
  }
}
 
template<typename type_t, typename allocator_t>
inline xtd::basic_array<type_t, allocator_t>::basic_array(const array<size_type, 1>& lengths, const value_type& value) {
  data_->items = base_type(lengths.aggregate([&](const size_type & accumulator, const size_type & value) {return accumulator * value;}), value);
  data_->lower_bound.clear();
  data_->upper_bound.clear();
  for (auto length : lengths) {
    data_->lower_bound.push_back(0);
    data_->upper_bound.push_back(length - 1);
  }
}
 
template<typename type_t, typename allocator_t>
template<typename value_t, xtd::integer index_t>
xtd::usize xtd::basic_array<type_t, allocator_t>::compute_index(const xtd::basic_array<value_t>& items, const xtd::array <index_t>& indexes) {
  auto position = xtd::usize {0};
  for (auto index1 = xtd::usize {0}; index1 < indexes.length(); ++index1) {
    if (static_cast<size_type>(indexes[index1]) >= items.get_length(index1)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
    auto multiplier = xtd::usize {1};
    for (auto index2 = index1 + 1; index2 < indexes.length(); ++index2)
      multiplier *= items.get_length(index2);
    position += static_cast<size_type>(indexes[index1]) * multiplier;
  }
  if (position >= items.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
  return position;
}
 
template<typename type_t, typename allocator_t>
template<typename value_t, xtd::integer index_t>
xtd::usize xtd::basic_array<type_t, allocator_t>::compute_index(const xtd::basic_array<value_t>& items, index_t rank, index_t index) {
  auto relative = index - items.get_lower_bound(rank);
  auto multiplier = xtd::usize {1};
  for (auto r = rank + 1; r < items.rank(); ++r)
    multiplier *= items.get_length(r);
  if (relative * multiplier >= items.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
  return relative * multiplier;
}
 
template<typename type_t, typename allocator_t>
template<typename value_t>
xtd::string xtd::basic_array<type_t, allocator_t>::to_string(const xtd::basic_array<value_t>& items, xtd::usize rank, xtd::usize base_index) {
  if (!items.size()) return "[]";
  auto result = xtd::string {"["};
  for (auto index = items.get_lower_bound(rank); index <= items.get_upper_bound(rank); ++index) {
    if (index != items.get_lower_bound(rank)) result += ", ";
    auto offset = base_index + compute_index(items, rank, index);
    if (rank + 1 < items.rank()) result += to_string(items, rank + 1, offset);
    else result += xtd::string::format("{}", items[offset]);
  }
  result += "]";
  return result;
}
 
template<typename type_t, typename allocator_t>
inline xtd::collections::object_model::read_only_collection<type_t> xtd::array<>::as_read_only(const xtd::array<type_t, 1, allocator_t>& array) {
  return xtd::collections::object_model::read_only_collection<type_t> {array};
}
 
template<typename type_t, xtd::usize rank_, typename allocator_t>
inline xtd::string xtd::array<type_t, rank_, allocator_t>::to_string() const noexcept {
  return xtd::basic_array<type_t, allocator_t>::to_string(self_, 0, 0);
}
 
template<typename type_t, typename allocator_t>
inline xtd::string xtd::array<type_t, 1, allocator_t>::to_string() const noexcept {
  return xtd::basic_array<type_t, allocator_t>::to_string(self_, 0, 0);
}
 
template<typename type_t, typename allocator_t>
inline xtd::string xtd::array<type_t, 2, allocator_t>::to_string() const noexcept {
  return xtd::basic_array<type_t, allocator_t>::to_string(self_, 0, 0);
}
 
template<typename type_t, typename allocator_t>
inline xtd::string xtd::array<type_t, 3, allocator_t>::to_string() const noexcept {
  return xtd::basic_array<type_t, allocator_t>::to_string(self_, 0, 0);
}
 
template<typename type_t, typename allocator_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator [](const xtd::array<xtd::index>& indexes) {
  return data_->items[compute_index(self_, indexes)];
}
 
template<typename type_t, typename allocator_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator [](const xtd::array<xtd::index>& indexes) const {
  return data_->items[compute_index(self_, indexes)];
}
 
template<typename type_t, typename allocator_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator [](const std::initializer_list<xtd::index>& indexes) {
  return data_->items[compute_index(self_, xtd::array<xtd::index> {indexes})];
}
 
template<typename type_t, typename allocator_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator [](const std::initializer_list<xtd::index>& indexes) const {
  return data_->items[compute_index(self_, xtd::array<xtd::index> {indexes})];
}
 
template<typename type_t, typename allocator_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator ()(const xtd::array<xtd::index>& indexes) {
  return data_->items[compute_index(self_, indexes)];
}
 
template<typename type_t, typename allocator_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator ()(const xtd::array<xtd::index>& indexes) const {
  return data_->items[compute_index(self_, indexes)];
}
 
template<typename type_t, typename allocator_t>
inline type_t& xtd::basic_array<type_t, allocator_t>::operator ()(const std::initializer_list<xtd::index>& indexes) {
  return data_->items[compute_index(self_, xtd::array<xtd::index> {indexes})];
}
 
template<typename type_t, typename allocator_t>
inline const type_t& xtd::basic_array<type_t, allocator_t>::operator ()(const std::initializer_list<xtd::index>& indexes) const {
  return data_->items[compute_index(self_, xtd::array<xtd::index> {indexes})];
}
 
template<typename type_t, typename allocator_t>
template<typename value_t>
xtd::usize xtd::basic_array<type_t, allocator_t>::compute_index(const xtd::basic_array<value_t>& items, const xtd::array <xtd::index>& indexes) {
  auto size_type_indexes = xtd::array <size_type>(indexes.length());
  for (auto index = size_type {0}; index < indexes.length(); ++index)
    size_type_indexes[index] = indexes[index].get_offset(items.get_length(index));
  return compute_index(items, size_type_indexes);
}
 
#if __cpp_multidimensional_subscript
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 2, allocator_t>::operator[](const xtd::index& index1, const xtd::index& index2) -> value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2});
}
 
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 2, allocator_t>::operator[](const xtd::index& index1, const xtd::index& index2) const -> const value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2});
}
 
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 3, allocator_t>::operator[](const xtd::index& index1, const xtd::index& index2, const xtd::index& index3) -> value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2, index3});
}
 
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 3, allocator_t>::operator[](const xtd::index& index1, const xtd::index& index2, const xtd::index& index3) const -> const value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2, index3});
}
#endif
 
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 2, allocator_t>::operator()(const xtd::index& index1, const xtd::index& index2) -> value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2});
}
 
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 2, allocator_t>::operator()(const xtd::index& index1, const xtd::index& index2) const -> const value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2});
}
 
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 3, allocator_t>::operator()(const xtd::index& index1, const xtd::index& index2, const xtd::index& index3) -> value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2, index3});
}
 
template<typename type_t, typename allocator_t>
auto xtd::array<type_t, 3, allocator_t>::operator()(const xtd::index& index1, const xtd::index& index2, const xtd::index& index3) const -> const value_type& {
  return xtd::basic_array<type_t, allocator_t>::operator[]({index1, index2, index3});
}