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<class type_t, class 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::size;
    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) { if (array.data_) *data_ = *array.data_;}
    
    
    using xtd::collections::generic::extensions::enumerable<xtd::collections::generic::ienumerable<value_type>, value_type>::count;
    size_type count() const noexcept override {return data_->items.size();}
    
    virtual pointer data() noexcept {return (pointer)data_->items.data();}
    virtual const_pointer data() const noexcept {return (pointer)data_->items.data();}
    
    bool is_fixed_size() const noexcept override {return true;}
    
    bool is_read_only() const noexcept override {return false;}
    
    bool is_synchronized() const noexcept override {return false;}
    
    virtual const base_type& items() const noexcept {return data_->items;}
    virtual base_type& items() noexcept {return data_->items;}
    
    virtual size_type length() const noexcept {return data_->items.size();}
    virtual xtd::int64 long_length() {return static_cast<xtd::int64>(length());}
    
    virtual size_type max_length() const noexcept {return data_->items.max_size();}
    
    virtual size_type rank() const noexcept {return 1;}
    
    const xtd::object& sync_root() const noexcept override {return data_->sync_root;}
    
    
    bool contains(const type_t& value) const noexcept 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;
    }
    
    void copy_to(xtd::array<type_t>& array) const {
      copy_to(0, array, 0);
    }
    
    void copy_to(xtd::array<type_t>& array, size_type array_index) const override {
      return copy_to(0, array, array_index);
    }
    
    void copy_to(const xtd::array<size_type>& indexes, xtd::array<type_t>& array, size_type array_index) const {
      return copy_to(compute_index(self_, indexes), array, array_index);
    }
    
    void copy_to(const xtd::array<size_type>& indexes, xtd::array<type_t>& array, size_type array_index, size_type count) const {
      return copy_to(compute_index(self_, indexes), array, array_index, count);
    }
    
    void copy_to(const size_type index, xtd::array<type_t>& array, size_type array_index) const {
      return copy_to(index, array, array_index, length() - index);
    }
    
    void copy_to(const size_type index, xtd::array<type_t>& array, size_type array_index, size_type count) const {
      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];
    }
    
    bool equals(const object & obj) const noexcept override {return dynamic_cast<const basic_array<value_type>*>(&obj) && equals(static_cast<const basic_array<value_type>&>(obj));}
    bool equals(const basic_array & rhs) const noexcept 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 void fill(const value_type & value) noexcept {
      for (auto& item : data_->items)
        item = value;
    }
    
    xtd::collections::generic::enumerator<value_type> get_enumerator() const noexcept 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) {}
        
        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())};
    }
    
    constexpr size_type get_length(size_type dimension) const {return get_upper_bound(dimension) - get_lower_bound(dimension) + 1;}
    
    xtd::array<size_type, 1> get_lengths() const;
    
    constexpr xtd::int64 get_long_length(size_type dimension) const {return static_cast < xtd::int64 > (get_upper_bound(dimension) + 1);}
    
    constexpr size_type get_lower_bound(size_type dimension) const {
      if (dimension >= rank()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return data_->lower_bound[dimension];
    }
    
    constexpr size_type get_upper_bound(size_type dimension) const {
      if (dimension >= rank()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      return data_->upper_bound[dimension];
    }
    
    const value_type& get_value(const xtd::array < size_type >& indexes) const;
    
    size_type index_of(const type_t& value) const noexcept override  {return index_of(value, 0, length());}
    size_type index_of(const type_t& value, size_type index) const {return index_of(value, index, length() - index);}
    size_type index_of(const type_t& value, size_type index, size_type count) const {
      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;
    }
    
    void resize(size_type new_size) {resize(new_size, value_type {});}
    
    void resize(size_type new_size, value_type value) {
      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;
    }
    
    void set_value(const type_t& value, const xtd::array < size_type >& indexes) {operator()(indexes) = value;}
    
    basic_array < type_t >& sort() {return sort(dynamic_cast<const xtd::collections::generic::icomparer<type_t>&>(xtd::collections::generic::comparer < type_t >::default_comparer));}
    
    template<class comparison_t>
    basic_array < type_t >& sort(comparison_t&& comparison) {
      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_;
    }
    
    basic_array < type_t >& sort(const xtd::collections::generic::icomparer < type_t >& comparer) {
      return sort(0, count(), comparer);
    }
    
    basic_array < type_t >& sort(xtd::size index, xtd::size count, const xtd::collections::generic::icomparer < type_t >& comparer) {
      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_;
    }
    
    xtd::string to_string() const noexcept override;
    
    
    basic_array& operator =(const basic_array & other) {
      *data_ = *other.data_;
      return *this;
    }

    basic_array& operator =(basic_array&& other) noexcept = default;
    basic_array& operator =(std::initializer_list < type_t >& items) {
      data_->items = items;
      data_->upper_bound[0] = data_->items.size() - 1;
      return *this;
    }
    
    const_reference operator [](size_type index) const 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);
    }

    reference operator [](size_type index) 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);
    }
    
    operator const base_type& () const noexcept {return data_->items;}
    operator base_type& () noexcept {return data_->items;}
    
    type_t& operator()(const xtd::array < size_type >& indexes);
    
    const type_t& operator()(const xtd::array < size_type >& indexes) const;
    
  private:
    template < class type_array_t, size_type rank_array_t, class 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) {
      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) {
      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) {
      data_->items.reserve(items.count());
      for (const auto& value : items)
        data_->items.push_back(value);
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    
    template < class input_iterator_t >
    basic_array(input_iterator_t first, input_iterator_t last) {
      data_->items.assign(first, last);
      data_->upper_bound.push_back(data_->items.size() - 1);
    }
    
    basic_array(const std::vector < type_t >& items) {
      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)  {
      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)  {
      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) {
      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)  {
      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)  {
      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);
    }
    
    void add(const type_t& item) override {}
    
    void clear() override {fill(value_type {});}
    
    template<class value_t>
    static xtd::size compute_index(const xtd::basic_array<value_t>& items, const xtd::array<size_type>& indexes);
    template<class value_t>
    static xtd::size compute_index(const xtd::basic_array<value_t>& items, xtd::size rank, xtd::size index);
    
    void insert(size_type index, const type_t& value) override {}
    
    bool remove(const type_t& item) override {return false;}
    
    void remove_at(size_type index) override {}
    
    void reverse(size_type index, size_type count) {
      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<class value_t>
    static xtd::string to_string(const xtd::basic_array<value_t>& items, xtd::size rank, xtd::size base_index);
    
    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 > ();
  };
}