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.h> 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 >> {
    class __comparer__ {
    public:
      __comparer__(const xtd::collections::generic::icomparer<type_t>* comparer) : comparer_(comparer) { }
      __comparer__(const __comparer__&) = default;
      __comparer__(__comparer__&&) = default;
      __comparer__& operator=(const __comparer__ & comparer) = default;
      __comparer__& operator=(__comparer__&&) = default;
      
      bool operator()(const type_t& e1, const type_t& e2) const noexcept {return comparer_ && comparer_->compare(e1, e2) < 0;}
      
    private:
      const xtd::collections::generic::icomparer<type_t>* comparer_;
    };
    
    class comparison_comparer {
      template<class comparison_t>
      using comparison = std::function<int32(comparison_t x, comparison_t y)>;
      
    public:
      comparison_comparer() = default;
      comparison_comparer(comparison<const type_t&> c) : comparer(c) {}
      
      comparison_comparer(const comparison_comparer & mc) = default;
      comparison_comparer& operator=(const comparison_comparer & mc) = default;
      
      bool operator()(const type_t& e1, const type_t& e2) const {return comparer(e1, e2) < 0;}
      
    private:
      comparison<const type_t&> comparer;
    };
    
  public:
    
    using value_type = type_t;
    using allocator_type = xtd::collections::generic::helpers::allocator<value_type>;
    using base_type = typename __xtd_raw_array_data__<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_raw_array_data__<value_type>::reverse_iterator;
    using const_reverse_iterator = typename __xtd_raw_array_data__<value_type>::const_reverse_iterator;
    
    
    inline static constexpr size_type npos = xtd::collections::generic::ilist<type_t>::npos;
    
    basic_array(const basic_array & array) { if (array.data_) *data_ = *array.data_;}
    basic_array(basic_array&& array) = default;
    
    
    virtual reference back() {return at(size() - 1);}
    virtual const_reference back() const {return at(size() - 1);}
    
    const_iterator begin() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::begin();}
    iterator begin() noexcept override {return xtd::collections::generic::ienumerable<value_type>::begin();}
    
    const_iterator cbegin() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::cbegin();}
    
    const_iterator cend() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::cend();}
    
    using xtd::collections::generic::extensions::enumerable<xtd::collections::generic::ienumerable<value_type>, value_type>::count;
    size_type count() const noexcept override {return size();}
    
    virtual const_reverse_iterator crbegin() const noexcept {return data_->items.crbegin();}
    
    virtual const_reverse_iterator crend() const noexcept {return data_->items.crend();}
    
    virtual pointer data() noexcept {return (pointer)data_->items.data();}
    virtual const_pointer data() const noexcept {return (pointer)data_->items.data();}
    
    virtual bool empty() const noexcept {return data_->items.empty();}
    
    const_iterator end() const noexcept override {return xtd::collections::generic::ienumerable<value_type>::end();}
    iterator end() noexcept override {return xtd::collections::generic::ienumerable<value_type>::end();}
    
    virtual reference front() {return at(0);}
    virtual const_reference front() const {return at(0);}
    
    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 size();}
    virtual xtd::int64 long_length() {return static_cast<xtd::int64>(size());}
    
    virtual size_type max_size() const noexcept {return data_->items.max_size();}
    
    virtual size_type rank() const noexcept {return 1;}
    
    virtual reverse_iterator rbegin() noexcept {return data_->items.rbegin();}
    virtual const_reverse_iterator rbegin() const noexcept {return data_->items.rbegin();}
    
    virtual reverse_iterator rend() noexcept {return data_->items.rend();}
    virtual const_reverse_iterator rend() const noexcept {return data_->items.rend();}
    
    virtual size_type size() const noexcept {return data_->items.size();}
    
    const xtd::object & sync_root() const noexcept override {return data_->sync_root;}
    
    
    virtual reference at(size_type index) {
      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return (reference)data_->items.at(index);
    }

    virtual const_reference at(size_type index) const {
      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return (reference)data_->items.at(index);
    }
    
    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, size_type index) const override {
      if (array.rank() != 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      if (rank() != 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::rank);
      if (index + length() > array.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      for (auto increment = size_type {0}; increment < length(); ++increment)
      array[index + increment] = at(increment);
    }
    
    void copy_to(xtd::array<type_t>& array, xtd::int64 index) const {copy_to(array, static_cast<xtd::size>(index));}
    
    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_->version == rhs.data_->version && 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 > {
      public:
        explicit basic_array_enumerator(const basic_array & items, size_type version) : items_(items), version_(version) {}
        
        const value_type & current() const override {
          if (version_ != items_.data_->version) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
          if (index_ < items_.count()) return items_[index_];
          static thread_local auto default_value = value_type {};
          return default_value;
        }
        
        bool move_next() override {
          if (version_ != items_.data_->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_->version;
          index_ = basic_array::npos;
        }
        
protected:
        const basic_array& items_;
        size_type index_ = basic_array::npos;
        size_type version_ = 0;
      };
      return {new_ptr < basic_array_enumerator > (*this, data_->version)};
    }
    
    constexpr size_type get_length(size_type dimension) const {return get_upper_bound(dimension) + 1;}
    
    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(*this, value, 0, count());}
    
    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 (new_size > max_size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      ++data_->version;
      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;}
    
    virtual void swap(basic_array & other) noexcept {
      ++data_->version;
      data_->items.swap(other.data_->items);
    }
    
    xtd::string to_string() const noexcept override;
    
    
    static size_type index_of(const basic_array & array, const value_type & value) noexcept {return index_of(array, value, 0, array.length());}
    
    static size_type index_of(const basic_array & array, const value_type & value, size_type index) {return index_of(array, value, index, array.length() - index);}
    
    static size_type index_of(const basic_array & array, const value_type & value, size_type index, size_type count) {
      if (index > array.length() || index + count > array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      
      if (array.size() == 0) return npos;
      for (auto increment = size_type {0}; increment < count; ++increment) {
        if (xtd::collections::generic::helpers::equator < type_t > {}(array[index + increment], value))
          return index + increment;
      }
      return npos;
    }
    
    static void reverse(basic_array & array) noexcept {reverse(array, 0, array.count());}
    static void reverse(basic_array & array, size_type index, size_type count) {
      if (index > array.size() || index + count > array.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if (count == 0) return;
      ++array.data_->version;
      std::reverse(array.data_->items.begin() + index, array.data_->items.begin() + index + count);
    }
    
    basic_array < type_t > & sort() {return sort(xtd::collections::generic::comparer < type_t >::default_comparer);}
    
    basic_array < type_t > & sort(comparison_comparer comparison) {
      ++data_->version;
      std::sort(data_->items.begin(), data_->items.end(), comparison_comparer {comparison});
      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 > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      auto first = data_->items.begin();
      auto last = data_->items.begin();
      std::advance(first, index);
      std::advance(last, index + count);
      ++data_->version;
      std::sort(first, last, __comparer__ {&comparer});
      return self_;
    }

    
    
    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_->version = 0;
      data_->items = items;
      data_->upper_bound[0] = data_->items.size() - 1;
      return *this;
    }
    
    const_reference operator [](size_type index) const override {return at(index);}
    reference operator [](size_type index) override {return 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;
    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;
    }
    
    basic_array(const xtd::collections::generic::ienumerable < type_t > & enumerable) {
      for (const auto& value : enumerable)
        data_->items.push_back(value);
      data_->lower_bound.push_back(0);
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    
    basic_array(const std::vector < type_t > & array) {
      data_->items = array;
      data_->upper_bound[0] = data_->items.size() - 1;
    }
    
    basic_array(std::vector < type_t > && array) {
      data_->items = std::move(array);
      data_->upper_bound[0] = data_->items.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);
    }
    
    template < class input_iterator_t >
    basic_array(input_iterator_t first, input_iterator_t last) {
      data_->items.assign(first, last);
      data_->lower_bound.push_back(0);
      data_->upper_bound.push_back(data_->items.size() - 1);
    }
    
    void add(const type_t& item) override {}
    void clear() override {}
    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 {}
    
    typename __xtd_raw_array_data__ < value_type >::iterator to_base_type_iterator(iterator value) noexcept {
      if (value == begin()) return data_->items.begin();
      if (value == end()) return data_->items.end();
      return data_->items.begin() + (value - begin());
    }
    
    iterator to_iterator(typename __xtd_raw_array_data__ < value_type >::iterator value) noexcept {
      if (value == data_->items.begin()) return begin();
      if (value == data_->items.end()) return end();
      return begin() + (value - data_->items.begin());
    }
    
    struct array_data {
      size_type version = 0;
      __xtd_raw_array_data__ < 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 > ();
  };
}