arranged_element_collection.hpp

Go to the documentation of this file.

#pragma once
 
//#include "items_added_event_handler.hpp"
#include "sorter_none.hpp"
#include <xtd/collections/generic/helpers/equator>
#include <xtd/collections/generic/list>
#include <xtd/helpers/throw_helper.hpp>
#include <xtd/array>
#include <xtd/argument_out_of_range_exception>
#include <xtd/event_args>
#include <xtd/event_handler>
#include <xtd/event>
#include <xtd/index>
#include <xtd/object>
#include <xtd/new_ptr>
#include <xtd/range>
#include <xtd/read_only_span>
#include <xtd/span>
#include <xtd/usize_object>

namespace xtd {
  namespace forms {
    namespace layout {
      template<typename type_t, typename sorter_t = sorter_none>
      class arranged_element_collection : public object, public xtd::collections::generic::icollection<type_t> {
      public:
        class value_type : public type_t {
        public:
          value_type() = default;
          value_type(const value_type&) = default;
          value_type(value_type&&) = default;
          template<typename ...args_t>
          value_type(args_t&& ...args) : type_t(args...) {}
          value_type& operator =(const value_type& value) {
            if (value.owner) owner = value.owner;
            if (owner != nullptr && !owner->data_->inserting && !owner->data_->erasing) owner->on_item_updated(pos, static_cast<type_t&>(const_cast<value_type&>(value)));
            type_t::operator =(value);
            return self_;
          }
          value_type& operator =(value_type&& value) {
            if (value.owner) owner = value.owner;
            if (owner != nullptr && !owner->data_->inserting && !owner->data_->erasing) owner->on_item_updated(pos, static_cast<type_t&>(value));
            type_t::operator =(value);
            return self_;
          }
          operator type_t() {return self_;}
          friend std::ostream& operator <<(std::ostream& os, const arranged_element_collection::value_type& value) {return os << static_cast<const type_t&>(value);}
          
        private:
          friend class arranged_element_collection;
          xtd::usize pos = usize_object::max_value;
          arranged_element_collection* owner = nullptr;
        };
        
        
        using base_type = typename xtd::collections::generic::list<value_type>::base_type;
        using const_base_type = const base_type;
        using size_type = xtd::usize;
        using reference = type_t&;
        using const_reference = const type_t&;
        using pointer = value_type*;
        using const_pointer = const value_type*;
        using read_only_collection = xtd::collections::object_model::read_only_collection<value_type>;
        
        
        inline static constexpr xtd::usize npos = xtd::npos;
        
        
        arranged_element_collection() = default;
        explicit arranged_element_collection(size_type capacity) {self_.capacity(capacity);}
        arranged_element_collection(const xtd::collections::generic::ienumerable<type_t>& collection) {add_range(collection);}
        
        arranged_element_collection(const arranged_element_collection& collection) {*data_ = *collection.data_;}
        arranged_element_collection(arranged_element_collection&& collection) {
          data_ = std::move(collection.data_);
          collection.data_ = new_ptr<data_collection>();
        }

        arranged_element_collection(const base_type& collection) {data_->items = collection;}
        arranged_element_collection(base_type&& collection) {data_->items = std::move(collection);}
        arranged_element_collection(std::initializer_list<type_t> items) {add_range(items);}
        template <std::input_iterator input_iterator_t>
        arranged_element_collection(input_iterator_t first, input_iterator_t last) {
          for (auto iterator = first; iterator != last; ++iterator)
            add(*iterator);
        }

        
        
        [[nodiscard]] auto capacity() const noexcept -> size_type {return data_->items.capacity();}
        auto capacity(size_type value) -> void {data_->items.capacity(value);}
        
        [[nodiscard]] auto count() const noexcept -> size_type override {return data_->items.count();}
        
        [[nodiscard]] auto data() -> pointer {return data_->items.data();}
        [[nodiscard]] auto data() const -> const_pointer {return data_->items.data();}
        
        [[nodiscard]] const auto& items() const {return data_->items.items();}
        [[nodiscard]] auto& items() {return data_->items.items();}
        
        [[nodiscard]] virtual auto sorted() const noexcept -> bool {return data_->sorted;}
        virtual auto sorted(bool value) -> arranged_element_collection& {
          if (data_->sorted == value) return self_;
          data_->sorted = value;
          if (data_->sorted) sort();
          return self_;
        }

        
        
        auto add(const type_t& item) -> void override {
          data_->items.add(item);
          xtd::usize index = data_->items.count() - 1;
          static_cast<value_type&>(self_[index]).owner = this;
          static_cast<value_type&>(self_[index]).pos = index;
          on_item_added(index, data_->items[index]);
          if (data_->sorted) sort();
        }

        virtual auto add(type_t&& item) -> void {
          data_->items.add(item);
          xtd::usize index = data_->items.count() - 1;
          static_cast<value_type&>(self_[index]).owner = this;
          static_cast<value_type&>(self_[index]).pos = index;
          on_item_added(index, data_->items[index]);
          if (data_->sorted) sort();
        }
        
        virtual auto add_range(const arranged_element_collection& collection) -> void {
          for (const auto& item : collection)
            add(item);
        }

        virtual auto add_range(const std::vector<type_t>& collection) -> void {
          for (const auto& item : collection)
            add(item);
        }

        virtual auto add_range(const std::initializer_list<type_t>& collection) -> void {
          for (const auto& item : collection)
            add(item);
        }

        template<typename collection_t>
        auto add_range(collection_t&& collection) -> void {
          for (auto& item : collection)
            add(value_type(item));
        }

        template<typename collection_t>
        auto add_range(const collection_t& collection) -> void {
          for (const auto& item : collection)
            add(item);
        }
        
        auto clear() -> void override {
          while (count())
            remove_at(0);
        }
        
        [[nodiscard]] auto contains(const type_t& item) const noexcept -> bool override {
          return data_->items.contains(item);
        }
        
        auto copy_to(xtd::array<type_t>& array, xtd::usize array_index) const -> void override {
          if (array_index + count() > array.length()) helpers::throw_helper::throws(helpers::exception_case::argument_out_of_range);
          auto i = size_type {0};
          for (const type_t& item : self_) {
            if (i >= count()) return;
            array[array_index + i++] = item;
          }
        }
        
        [[nodiscard]] auto get_enumerator() const noexcept -> xtd::collections::generic::enumerator<type_t> override {
          struct arranged_element_collection_enumerator : public xtd::collections::generic::ienumerator<type_t> {
            explicit arranged_element_collection_enumerator(const arranged_element_collection& items, xtd::usize version) : items_(items), version_(version) {}
            
            const type_t& current() const override {
              if (index_ >= items_.count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
              if (version_ != items_.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_.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_.items().version();
              index_ = arranged_element_collection::npos;
            }
            
          private:
            size_type index_ = arranged_element_collection::npos;
            const arranged_element_collection& items_;
            size_type version_ = 0;
          };
          
          return {new_ptr<arranged_element_collection_enumerator>(self_, items().version())};
        }
        
        virtual auto insert(xtd::usize index, const type_t& value) -> void {
          if (index > count()) helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          data_->inserting = true;
          items().insert(items().begin() + index, value);
          data_->inserting = false;
          static_cast<value_type&>(self_[index]).owner = this;
          static_cast<value_type&>(self_[index]).pos = index;
          on_item_added(index, data_->items[index]);
          if (data_->sorted) sort();
        }
        
        virtual auto sort() -> arranged_element_collection& {
          sorter_t sorter;
          sorter(items().begin(), items().end());
          return self_;
        }
        
        auto remove(const type_t& item) -> bool override {
          if (count() == 0)  return false;
          for (auto index = size_type {0}; index < count(); ++index) {
            if (!xtd::collections::generic::helpers::equator<type_t> {}(self_[index], item)) continue;
            remove_at(index);
            return true;
          }
          return false;
        }
        
        virtual auto remove_at(xtd::usize index) -> void {
          if (index > count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          on_item_removed(index, const_cast<value_type&>(data_->items[index]));
          data_->erasing = true;
          items().erase(items().begin() + index);
          data_->erasing = false;
        }
        
        auto reverse() -> arranged_element_collection& {return reverse(0, count());}
        auto reverse(size_type index, size_type count) -> arranged_element_collection& {
          data_->items.reverse(index, count);
          return self_;
        }
 
        
        [[nodiscard]] auto to_array() const noexcept -> xtd::array<type_t> {
          return data_->items.count() ? xtd::array<type_t>(data_->items.begin(), data_->items.end()) : xtd::array<type_t> {};
        }

        
        
        auto operator =(const arranged_element_collection& other) -> arranged_element_collection& {
          clear();
          add_range(other);
          return self_;
        }

        auto operator =(arranged_element_collection&& other) noexcept -> arranged_element_collection& {
          clear();
          add_range(std::move(other.data_->items));
          return self_;
        }

        auto operator =(const std::initializer_list<type_t>& items) -> arranged_element_collection& {
          clear();
          add_range(items);
          return self_;
        }
        
        [[nodiscard]] auto operator [](size_type index) -> value_type& {
          if ((index >= count() && index <= ~count() - 1) || index == npos) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
          data_->items[index].pos = index > npos / 2 ? count() - (npos - index) : index;
          data_->items[index].owner = this;
          return data_->items[index];
        }

        [[nodiscard]] auto operator [](size_type index) const -> const value_type& {
          if ((index >= count() && index <= ~count() - 1) || index == npos) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
          data_->items[index].pos = index > npos / 2 ? count() - (npos - index) : index;
          data_->items[index].owner = const_cast<arranged_element_collection*>(this);
          return data_->items[index];
        }

        [[nodiscard]] auto operator [](const xtd::index& index) -> value_type& {
          return operator [](index.get_offset(count()));
        }

        [[nodiscard]] auto operator [](const xtd::index& index) const -> const value_type& {
          return operator [](index.get_offset(count()));
        }

        auto operator [](const xtd::range& range) const -> xtd::read_only_span<value_type> {
          return xtd::read_only_span<value_type> {*this, range};
        }

        auto operator [](const xtd::range& range) -> xtd::span<value_type> {
          return xtd::span<value_type> {*this, range};
        }

        [[nodiscard]] auto operator ()(size_type index) -> value_type& {
          return operator [](index);
        }

        [[nodiscard]] auto operator ()(size_type index) const -> const value_type& {
          return operator [](index);
        }

        [[nodiscard]] auto operator ()(const xtd::index& index) -> value_type& {
          return operator [](index);
        }

        [[nodiscard]] auto operator ()(const xtd::index& index) const -> const value_type& {
          return operator [](index);
        }

        auto operator ()(const xtd::range& range) const -> xtd::read_only_span<value_type> {
          return operator[](range);
        }

        auto operator ()(const xtd::range& range) -> xtd::span<value_type> {
          return operator[](range);
        }

        [[nodiscard]] operator const_base_type& () const noexcept {return items();}
        [[nodiscard]] operator base_type& () noexcept {return items();}
        
        [[nodiscard]] auto operator ==(const arranged_element_collection& value) const -> bool {return data_->items == value.data_->items;}
        [[nodiscard]] auto operator !=(const arranged_element_collection& value) const -> bool {return !operator ==(value);}
        
        
        event<arranged_element_collection, delegate<void(xtd::usize, type_t& item)>> item_added;
        
        event<arranged_element_collection, delegate<void(xtd::usize, type_t& item)>> item_updated;
        
        event<arranged_element_collection, delegate<void(xtd::usize, type_t& item)>> item_removed;
        
        
        using reverse_iterator [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items::reverse_iterator - Will be removed in version 1.2.0.")]] = typename xtd::collections::generic::list<value_type>::base_type::reverse_iterator;
        using const_reverse_iterator [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items::const_reverse_iterator - Will be removed in version 1.2.0.")]] = typename xtd::collections::generic::list<value_type>::base_type::const_reverse_iterator;
        
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().max_size - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto max_size() const noexcept -> size_type {return data_->items.max_size();}
        
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::operator [] - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto at(size_type pos) -> reference {
          data_->items[pos].pos = pos;
          data_->items[pos].owner = this;
          return data_->items.at(pos);
        }

        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::operator [] - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto at(size_type pos) const -> const_reference {return data_->items.at(pos);}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::operator [~1_i] - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto back() -> reference {return data_->items.back();}
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::operator [~1_i] - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto back() const -> const_reference {return data_->items.back();}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().crbegin - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto crbegin() const noexcept -> const_reverse_iterator {return data_->items.crbegin();}
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().crend - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto crend() const noexcept -> const_reverse_iterator {return data_->items.crend();}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::operator [0] - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto front() -> reference {return data_->items.front();}
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::operator [0] - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto front() const -> const_reference {return data_->items.front();}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().get_allocator - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto get_allocator() const noexcept {return data_->items.get_allocator();}
        
        template<typename ...args_t>
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::insert - Will be removed in version 1.2.0.")]]
        auto emplace(xtd::collections::generic::list<value_type>::const_iterator pos, args_t&& ... args) -> void {
          auto index = pos - items().begin();
          data_->inserting = true;
          auto result = data_->items.insert(pos, args...);
          data_->inserting = false;
          self_[index].owner = this;
          self_[index].pos = index;
          on_item_added(index, data_->items[index]);
          if (data_->sorted) sort();
          return result;
        }
        
        template<typename ...args_t>
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add - Will be removed in version 1.2.0.")]]
        auto emplace_back(args_t&& ... args) -> void {
          data_->items.emplace_back(args...);
          xtd::usize index = data_->items.count() - 1;
          self_[index].owner = this;
          self_[index].pos = index;
          on_item_added(index, data_->items[index]);
          if (data_->sorted) sort();
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::remove_at - Will be removed in version 1.2.0.")]]
        auto erase(xtd::collections::generic::list<value_type>::iterator pos) {
          on_item_removed(pos - items().begin(), *pos);
          data_->erasing = true;
          auto result = items().erase(pos);
          data_->erasing = false;
          return result;
        }

        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::remove_at - Will be removed in version 1.2.0.")]]
        auto erase(xtd::collections::generic::list<value_type>::const_iterator pos) {
          on_item_removed(pos - items().begin(), const_cast<value_type&>(*pos));
          data_->erasing = true;
          auto result = items().erase(pos);
          data_->erasing = false;
          return result;
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::remove_at - Will be removed in version 1.2.0.")]]
        auto erase(xtd::collections::generic::list<value_type>::iterator first, xtd::collections::generic::list<value_type>::iterator last) {
          auto result = items().end();
          auto index = first - items().begin();
          for (auto it = first; it <= last; ++it)
            remove_at(index++);
          return result;
        }

        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::remove_at - Will be removed in version 1.2.0.")]]
        auto erase(xtd::collections::generic::list<value_type>::const_iterator first, xtd::collections::generic::list<value_type>::const_iterator last) {
          auto result = items().end();
          auto index = first - items().begin();
          for (auto it = first; it <= last; ++it)
            remove_at(index++);
          return result;
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::remove_at - Will be removed in version 1.2.0.")]]
        auto erase_at(xtd::usize index) -> void {
          remove_at(index);
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::insert - Will be removed in version 1.2.0.")]]
        auto insert(xtd::collections::generic::list<value_type>::const_iterator pos, const type_t& value) {
          auto index = pos - items().begin();
          data_->inserting = true;
          auto result = items().insert(pos, value);
          data_->inserting = false;
          self_[index].owner = this;
          self_[index].pos = index;
          on_item_added(index, data_->items[index]);
          if (data_->sorted) sort();
          return result;
        }

        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::insert - Will be removed in version 1.2.0.")]]
        auto insert(xtd::collections::generic::list<value_type>::const_iterator pos, type_t&& value) {
          auto index = pos - items().begin();
          data_->inserting = true;
          auto result = items().insert(pos, value);
          data_->inserting = false;
          self_[index].owner = this;
          self_[index].pos = index;
          on_item_added(index, data_->items[index]);
          if (data_->sorted) sort();
          return result;
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::insert - Will be removed in version 1.2.0.")]]
        auto insert_at(xtd::usize index, const type_t& value) -> void {
          insert(index, value);
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::remove(count() - 1) - Will be removed in version 1.2.0.")]]
        auto pop_back() -> void {
          if (count() != 0) remove_at(count() - 1);
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add - Will be removed in version 1.2.0.")]]
        auto push_back(const type_t& item) -> void {
          add(item);
        }

        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add - Will be removed in version 1.2.0.")]]
        auto push_back(type_t&& item) -> void {
          add(std::move(item));
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add_range - Will be removed in version 1.2.0.")]]
        auto push_back_range(const arranged_element_collection& collection) -> void {
          add_range(collection);
        }

        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add_range - Will be removed in version 1.2.0.")]]
        auto push_back_range(const std::vector<type_t>& collection) -> void {
          add_range(collection);
        }

        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add_range - Will be removed in version 1.2.0.")]]
        auto push_back_range(const std::initializer_list<type_t>& collection) -> void {
          add_range(collection);
        }

        template<typename collection_t>
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add_range - Will be removed in version 1.2.0.")]]
        auto push_back_range(collection_t&& collection) -> void {
          add_range(collection);
        }

        template<typename iterator_t>
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::add_range - Will be removed in version 1.2.0.")]]
        auto push_back_range(iterator_t begin, iterator_t end) -> void {
          add_range(begin, end);
        }
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::to_array - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto to_vector() const noexcept -> std::vector<type_t> {return to_array();}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().rbegin - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto rbegin() noexcept {return data_->items.rbegin();}
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().rbegin - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto rbegin() const noexcept {return data_->items.rbegin();}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().rend - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto rend() noexcept {return data_->items.rend();}
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().rend - Will be removed in version 1.2.0.")]]
        [[nodiscard]] auto rend() const noexcept {return data_->items.rend();}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().reserve - Will be removed in version 1.2.0.")]]
        auto reserve(size_type size) -> void {data_->items.reserve(size);}
        
        [[deprecated("Replaced by xtd::forms::layout::arranged_element_collection::items().shrink_to_fit - Will be removed in version 1.2.0.")]]
        auto shrink_to_fit() -> void {data_->items.shrink_to_fit();}
        
      protected:
        
        virtual auto on_item_added(xtd::usize index, type_t& item) -> void {item_added(index, item);}
        
        virtual auto on_item_updated(xtd::usize index, type_t& item) -> void {item_updated(index, item);}
        
        virtual auto on_item_removed(xtd::usize index, type_t& item) -> void {item_removed(index, item);}
        
      private:
        [[nodiscard]] auto is_read_only() const noexcept -> bool override {return false;}
        [[nodiscard]] auto is_synchronized() const noexcept -> bool override {return false;}
        [[nodiscard]] auto sync_root() const noexcept -> const xtd::object& override {return data_->sync_root;}
        
        struct data_collection {
          mutable xtd::collections::generic::list < value_type > items;
          bool inserting = false;
          bool erasing = false;
          bool sorted = false;
          xtd::object sync_root;
        };
        ptr < data_collection > data_ = new_ptr < data_collection > ();
      };
    }
  }
}