basic_array.hpp

Go to the documentation of this file.

 
#if !defined(__XTD_ARRAY_INTERNAL__)
#error "Do not include this file: Internal use only. Include <xtd/array> or <xtd/array.hpp> instead."
#endif

namespace xtd {
  template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
  class basic_array : public xtd::array_abstract_object, public xtd::collections::generic::ilist<type_t>, public xtd::iequatable<basic_array<type_t, allocator_t >> {
  public:
    
    using value_type = type_t;
    using allocator_type = xtd::collections::generic::helpers::allocator<value_type>;
    using base_type = typename xtd::collections::generic::helpers::raw_array<value_type, allocator_type>::base_type;
    using size_type = xtd::usize;
    using difference_type = xtd::ptrdiff;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using iterator = typename xtd::collections::generic::ienumerable<type_t>::iterator;
    using const_iterator = typename xtd::collections::generic::ienumerable<type_t>::const_iterator;
    using reverse_iterator = typename xtd::collections::generic::helpers::raw_array<value_type>::reverse_iterator;
    using const_reverse_iterator = typename xtd::collections::generic::helpers::raw_array<value_type>::const_reverse_iterator;
    
    basic_array(basic_array&& array) = default;
    basic_array(const basic_array & array) requires std::copy_constructible<type_t> { if (array.data_) *data_ = *array.data_;}
    
    
    using xtd::collections::generic::extensions::enumerable<xtd::collections::generic::ienumerable<value_type>, value_type>::count;
    [[nodiscard]] auto count() const noexcept -> size_type override {return data_->items.size();}
    
    [[nodiscard]] virtual auto data() noexcept -> pointer {return (pointer)data_->items.data();}
    [[nodiscard]] virtual auto data() const noexcept -> const_pointer {return (pointer)data_->items.data();}
    
    [[nodiscard]] auto is_fixed_size() const noexcept -> bool override {return true;}
    
    [[nodiscard]] auto is_read_only() const noexcept -> bool override {return false;}
    
    [[nodiscard]] auto is_synchronized() const noexcept -> bool override {return false;}
    
    [[nodiscard]] virtual auto items() const noexcept -> const base_type& {return data_->items;}
    [[nodiscard]] virtual auto items() noexcept -> base_type& {return data_->items;}
    
    [[nodiscard]] virtual auto length() const noexcept -> size_type {return data_->items.size();}
    [[nodiscard]] virtual auto long_length() -> xtd::int64 {return static_cast<xtd::int64>(length());}
    
    [[nodiscard]] virtual auto max_length() const noexcept -> size_type {return data_->items.max_size();}
    
    [[nodiscard]] virtual auto rank() const noexcept -> size_type {return 1;}
    
    [[nodiscard]] auto sync_root() const noexcept -> const xtd::object& override {return data_->sync_root;}
    
    
    [[nodiscard]] auto contains(const type_t& value) const noexcept -> bool override {
      for (const auto& item : data_->items)
        if (xtd::collections::generic::helpers::equator<type_t> {}(reinterpret_cast<const type_t&>(item), value)) return true;
      return false;
    }
    
    auto copy_to(xtd::array<type_t>& array) const -> void requires std::copy_constructible<type_t> {
      copy_to(0, array, 0);
    }
    
    auto copy_to(xtd::array<type_t>& array, size_type array_index) const -> void override {
      if constexpr (std::copy_constructible<type_t>) copy_to(0, array, array_index);
      else xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "value_type is not copy constructible.");
    }

    auto copy_to(const xtd::array<size_type>& indexes, xtd::array<type_t>& array, size_type array_index) const -> void requires std::copy_constructible<type_t> {
      copy_to(compute_index(self_, indexes), array, array_index);
    }

    auto copy_to(const xtd::array<size_type>& indexes, xtd::array<type_t>& array, size_type array_index, size_type count) const -> void requires std::copy_constructible<type_t> {
      copy_to(compute_index(self_, indexes), array, array_index, count);
    }

    auto copy_to(const size_type index, xtd::array<type_t>& array, size_type array_index) const -> void requires std::copy_constructible<type_t> {
      copy_to(index, array, array_index, length() - index);
    }

    auto copy_to(const size_type index, xtd::array<type_t>& array, size_type array_index, size_type count) const -> void requires std::copy_constructible<type_t> {
      if (array.rank() != 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      if (index + count > self_.length() || array_index + count > array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      for (auto i = index; i < (index + count); ++i)
        array[array_index++] = self_[i];
    }
    
    [[nodiscard]] auto equals(const object & obj) const noexcept -> bool override {return dynamic_cast<const basic_array<value_type>*>(&obj) && equals(static_cast<const basic_array<value_type>&>(obj));}
    [[nodiscard]] auto equals(const basic_array & rhs) const noexcept -> bool override {
      if (count() != rhs.count()) return false;
      for (size_type i = 0; i < count(); i++)
        if (!xtd::collections::generic::helpers::equator<type_t> {}(data_->items.at(i), rhs.data_->items.at(i))) return false;
      return data_->lower_bound == rhs.data_->lower_bound && data_->upper_bound == rhs.data_->upper_bound;
    }
    
    virtual auto fill(const value_type & value) noexcept -> void {
      if constexpr (std::copy_constructible<value_type>)
        for (auto& item : data_->items)
          item = value;
      else xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "value_type is not copy constructible.");
    }
    
    [[nodiscard]] auto get_enumerator() const noexcept -> xtd::collections::generic::enumerator<value_type> override {
      struct basic_array_enumerator : public xtd::collections::generic::ienumerator<value_type> {
        explicit basic_array_enumerator(const basic_array & items, size_type version) : items_(items), version_(version) {}
        
        [[nodiscard]] const value_type& current() const override {
          if (index_ >= items_.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
          if (version_ != items_.data_->items.version()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
          return items_[index_];
        }
        
        bool move_next() override {
          if (version_ != items_.data_->items.version()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
          return ++index_ < items_.count();
        }
        
        void reset() override {
          version_ = items_.data_->items.version();
          index_ = basic_array::npos;
        }
        
      private:
        size_type index_ = basic_array::npos;
        const basic_array& items_;
        size_type version_ = 0;
      };
      return {new_ptr<basic_array_enumerator>(*this, data_->items.version())};
    }
    
    [[nodiscard]] constexpr auto get_length(size_type dimension) const -> size_type {return get_upper_bound(dimension) - get_lower_bound(dimension) + 1;}
    
    [[nodiscard]] auto get_lengths() const -> xtd::array<size_type, 1>;
    
    [[nodiscard]] constexpr auto get_long_length(size_type dimension) const -> xtd::int64 {return static_cast<xtd::int64>(get_upper_bound(dimension) - get_lower_bound(dimension) + 1);}
    
    [[nodiscard]] constexpr auto get_lower_bound(size_type dimension) const -> size_type {
      if (dimension >= rank()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return data_->lower_bound[dimension];
    }
    
    [[nodiscard]] constexpr auto get_upper_bound(size_type dimension) const -> size_type {
      if (dimension >= rank()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return data_->upper_bound[dimension];
    }
    
    [[nodiscard]] auto get_value(const xtd::array<size_type>& indexes) const -> const value_type&;
    
    [[nodiscard]] auto index_of(const type_t& value) const noexcept -> size_type override {return index_of(value, 0, length());}
    [[nodiscard]] auto index_of(const type_t& value, size_type index) const -> size_type {return index_of(value, index, length() - index);}
    [[nodiscard]] auto index_of(const type_t& value, size_type index, size_type count) const -> size_type {
      if (index > length() || index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      for (auto increment = index; increment < (index + count); ++increment)
        if (xtd::collections::generic::helpers::equator<type_t> {}(data_->items[increment], value)) return increment;
      return xtd::npos;
    }
    
    auto resize(size_type new_size) -> void {resize(new_size, value_type {});}
    
    auto resize(size_type new_size, value_type value) -> void {
      if (new_size == length()) return;
      if (rank() != 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      if (new_size > max_length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::out_of_memory);
      data_->items.resize(new_size, value);
      data_->upper_bound[0] = new_size - 1;
    }
    
    auto set_value(const type_t& value, const xtd::array<size_type>& indexes) -> void {operator()(indexes) = value;}
    
    auto sort() -> basic_array<type_t>& {return sort(dynamic_cast<const xtd::collections::generic::icomparer<type_t>&>(xtd::collections::generic::comparer<type_t>::default_comparer));}
    
    template<typename comparison_t>
    auto sort(comparison_t&& comparison) -> basic_array<type_t>& {
      data_->items.increment_version();
      std::sort(data_->items.begin(), data_->items.end(), [&](const type_t& x, const type_t& y) {return comparison(x, y) < 0;});
      return self_;
    }
    
    auto sort(const xtd::collections::generic::icomparer<type_t>& comparer) -> basic_array<type_t>& {
      return sort(0, count(), comparer);
    }
    
    auto sort(xtd::usize index, xtd::usize count, const xtd::collections::generic::icomparer<type_t>& comparer) -> basic_array<type_t>& {
      if (index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      data_->items.increment_version();
      std::sort(data_->items.begin(), data_->items.end(), xtd::collections::generic::helpers::lesser<type_t> {comparer});
      return self_;
    }
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    
    
    auto operator =(const basic_array & other) -> basic_array& {
      *data_ = *other.data_;
      return *this;
    }

    auto operator =(basic_array&& other) noexcept -> basic_array& = default;
    auto operator =(std::initializer_list<type_t>& items) -> basic_array& {
      data_->items = items;
      data_->upper_bound[0] = data_->items.size() - 1;
      return *this;
    }
    
    [[nodiscard]] auto operator [](size_type index) const -> const_reference override {
      if ((index >= count() && index <= ~count() - 1) || index == npos) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return data_->items.at(index);
    }

    [[nodiscard]] auto operator [](size_type index) -> reference override {
      if ((index >= count() && index <= ~count() - 1) || index == npos) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return data_->items.at(index);
    }
    
    [[nodiscard]] operator const base_type&() const noexcept {return data_->items;}
    [[nodiscard]] operator base_type&() noexcept {return data_->items;}
    
    [[nodiscard]] auto operator()(const xtd::array<size_type>& indexes) -> type_t&;
    
    [[nodiscard]] auto operator()(const xtd::array<size_type>& indexes) const -> const type_t&;

    [[nodiscard]] auto operator[](const xtd::array<size_type>& indexes) -> type_t&;
    
    [[nodiscard]] auto operator[](const xtd::array<size_type>& indexes) const -> const type_t&;
    
  private:
    template<typename type_array_t, size_type rank_array_t, typename allocator_array_t>
    friend class array;
    
    basic_array() = default;
    explicit basic_array(const array<size_type, 1>& lengths);
    basic_array(const array<size_type, 1>& lengths, const value_type & value);
    basic_array(const_pointer array, size_type length) requires std::copy_constructible<type_t> {
      if (array == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
      data_->items = base_type {array, array + length};
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    explicit basic_array(const xtd::collections::generic::ienumerable<type_t>& enumerable) requires std::copy_constructible<type_t> {
      for (const auto& value : enumerable)
        data_->items.push_back(value);
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    explicit basic_array(const xtd::collections::generic::ilist<type_t>& items) requires std::copy_constructible<type_t> {
      data_->items.reserve(items.count());
      for (const auto& value : items)
        data_->items.push_back(value);
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    
    template<typename input_iterator_t>
    basic_array(input_iterator_t first, input_iterator_t last) requires std::copy_constructible<type_t> {
      data_->items.assign(first, last);
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    
    basic_array(const std::vector<type_t>& items) requires std::copy_constructible<type_t> {
      data_->items.assign(items.begin(), items.end());
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    
    basic_array(const std::vector<std::vector<type_t>>& items) requires std::copy_constructible<type_t>  {
      for (const std::vector<type_t>& items1 : items)
        data_->items.insert(data_->items.end(), items1.begin(), items1.end());
      data_->upper_bound[0] = items.size() - 1;
      data_->lower_bound.push_back(0);
      data_->upper_bound.push_back((*items.begin()).size() - 1);
    }
    
    basic_array(const std::vector<std::vector<std::vector<type_t>>>& items) requires std::copy_constructible<type_t>  {
      for (const std::vector<std::vector<type_t>>& items1 : items)
        for (const std::vector<type_t>& items2 : items1)
          data_->items.insert(data_->items.end(), items2.begin(), items2.end());
      data_->upper_bound[0] = items.size() - 1;
      data_->lower_bound.push_back(0);
      data_->upper_bound.push_back((*items.begin()).size() - 1);
      data_->lower_bound.push_back(0);
      data_->upper_bound.push_back((*(*items.begin()).begin()).size() - 1);
    }
    
    basic_array(std::initializer_list<type_t> il) requires std::copy_constructible<type_t> {
      data_->items.assign(il.begin(), il.end());
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    
    basic_array(std::initializer_list<std::initializer_list<type_t>> il) requires std::copy_constructible<type_t> {
      for (const std::initializer_list<type_t>& il1 : il)
        data_->items.insert(data_->items.end(), il1.begin(), il1.end());
      data_->upper_bound[0] = il.size() - 1;
      data_->lower_bound.push_back(0);
      data_->upper_bound.push_back((*il.begin()).size() - 1);
    }
    
    basic_array(std::initializer_list<std::initializer_list<std::initializer_list<type_t>>> il) requires std::copy_constructible<type_t> {
      for (const std::initializer_list<std::initializer_list<type_t>>& il1 : il)
        for (const std::initializer_list<type_t>& il2 : il1)
          data_->items.insert(data_->items.end(), il2.begin(), il2.end());
      data_->upper_bound[0] = il.size() - 1;
      data_->lower_bound.push_back(0);
      data_->upper_bound.push_back((*il.begin()).size() - 1);
      data_->lower_bound.push_back(0);
      data_->upper_bound.push_back((*(*il.begin()).begin()).size() - 1);
    }
    
    auto add(const type_t& item) -> void override {}
    
    auto clear() -> void override {fill(value_type {});}
    
    template<typename value_t>
    [[nodiscard]] static auto compute_index(const xtd::basic_array<value_t>& items, const xtd::array<size_type>& indexes) -> xtd::usize;
    template<typename value_t>
    [[nodiscard]] static auto compute_index(const xtd::basic_array<value_t>& items, xtd::usize rank, xtd::usize index) -> xtd::usize;
    
    auto insert(size_type index, const type_t& value) -> void override {}
    
    auto remove(const type_t& item) -> bool override {return false;}
    
    auto remove_at(size_type index) -> void override {}
    
    auto reverse(size_type index, size_type count) -> void {
      if (index > length() || index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if (count == 0) return;
      data_->items.increment_version();
      std::reverse(data_->items.begin() + index, data_->items.begin() + index + count);
    }
    
    template<typename value_t>
    [[nodiscard]] static auto to_string(const xtd::basic_array<value_t>& items, xtd::usize rank, xtd::usize base_index) -> xtd::string;
    
    struct array_data {
      xtd::collections::generic::helpers::raw_array<value_type> items;
      std::vector<size_type> lower_bound {0};
      std::vector<size_type> upper_bound {std::numeric_limits<size_type>::max()};
      object sync_root;
    };
    
    xtd::ptr<array_data> data_ = xtd::new_ptr<array_data> ();
  };
}