arranged_element_collection.h

Go to the documentation of this file.

 
#pragma once
 
#include "sorter_none.h"
#include <xtd/argument_out_of_range_exception>
#include <xtd/event_args>
#include <xtd/event_handler>
#include <xtd/event>
#include <xtd/object>
#include <xtd/size_object>
#include <ostream>
#include <vector>
 
namespace xtd {
  namespace forms {
    namespace layout {
      template<typename type_t, typename sorter_t = sorter_none>
      class arranged_element_collection : public object {
      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->inserting_ && !owner->erasing_) owner->on_item_updated(pos, static_cast<type_t&>(const_cast<value_type&>(value)));
            type_t::operator =(value);
            return *this;
          }
          value_type& operator =(value_type&& value) {
            if (value.owner) owner = value.owner;
            if (owner != nullptr && !owner->inserting_ && !owner->erasing_) owner->on_item_updated(pos, static_cast<type_t&>(value));
            type_t::operator =(value);
            return *this;
          }
          operator type_t() {return *this;}
          friend std::ostream& operator <<(std::ostream& os, const value_type& value) {return os << static_cast<const type_t&>(value);}
          
        private:
          friend class arranged_element_collection;
          size_t pos = size_object::max_value;
          arranged_element_collection* owner = nullptr;
        };
        
        
        using allocator_type = std::allocator<value_type>;
        using size_type = std::size_t;
        using difference_type = std::ptrdiff_t;
        using reference = value_type&;
        using const_reference = const value_type&;
        using pointer = typename std::allocator_traits<allocator_type>::pointer;
        using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
        using iterator = typename std::vector<value_type>::iterator;
        using const_iterator = typename std::vector<value_type>::const_iterator;
        using reverse_iterator = typename std::vector<value_type>::reverse_iterator;
        using const_reverse_iterator = typename std::vector<value_type>::const_reverse_iterator;
        
        
        inline static constexpr xtd::size npos = xtd::size_object::max_value;
        
        
        explicit arranged_element_collection(const allocator_type& allocator = allocator_type()) : collection_(allocator) {}
        arranged_element_collection(const std::initializer_list<type_t>& il) {
          for (auto item : il)
            push_back(item);
        }
        
        explicit arranged_element_collection(const std::vector<type_t>& collection) {
          for (auto item : collection)
            push_back(item);
        }
        arranged_element_collection(const arranged_element_collection& collection) {push_back_range(collection);}
        arranged_element_collection& operator =(const arranged_element_collection& collection) {
          clear();
          push_back_range(collection);
          return *this;
        }
        arranged_element_collection(arranged_element_collection&&) = default;
        bool operator ==(const arranged_element_collection& value) const {return collection_ == value.collection_;}
        bool operator !=(const arranged_element_collection& value) const {return !operator ==(value);}
        
        
        allocator_type get_allocator() const noexcept {return collection_.get_allocator();}
        
        reference at(size_type pos) {
          collection_[pos].pos = pos;
          collection_[pos].owner = this;
          return collection_.at(pos);
        }
        const_reference at(size_type pos) const {return collection_.at(pos);}
        
        reference front() {return collection_.front();}
        const_reference front() const {return collection_.front();}
        
        reference back() {return collection_.back();}
        const_reference back() const {return collection_.back();}
        
        pointer data() {return collection_.data();}
        const_pointer data() const {return collection_.data();}
        
        iterator begin() noexcept {return collection_.begin();}
        const_iterator begin() const noexcept {return collection_.begin();}
        const_iterator cbegin() const noexcept {return collection_.cbegin();}
        
        iterator end() noexcept {return collection_.end();}
        const_iterator end() const noexcept {return collection_.end();}
        const_iterator cend() const noexcept {return collection_.cend();}
        
        reverse_iterator rbegin() noexcept {return collection_.rbegin();}
        const_reverse_iterator rbegin() const noexcept {return collection_.rbegin();}
        const_reverse_iterator crbegin() const noexcept {return collection_.crbegin();}
        
        reverse_iterator rend() noexcept {return collection_.rend();}
        const_reverse_iterator rend() const noexcept {return collection_.rend();}
        const_reverse_iterator crend() const noexcept {return collection_.crend();}
        
        bool empty() const noexcept {return collection_.empty();}
        
        size_type size() const noexcept {return collection_.size();}
        
        size_type max_size() const noexcept {return collection_.max_size();}
        
        void reserve(size_type size) {collection_.reserve(size);}
        
        size_type capacity() const noexcept {return collection_.capacity();}
        
        void shrink_to_fit() {collection_.shrink_to_fit();}
        
        virtual bool sorted() const noexcept {return sorted_;}
        virtual void sorted(bool value) {
          if (sorted_ != value) {
            sorted_ = value;
            if (sorted_) sort();
          }
        }
        
        virtual void clear() noexcept {
          iterator it = begin();
          while (it != end())
            it = erase(it);
        }
        
        virtual iterator insert(const_iterator pos, const value_type& value) {
          size_t index = pos - begin();
          inserting_ = true;
          iterator result = collection_.insert(pos, value);
          inserting_ = false;
          (*this)[index].owner = this;
          (*this)[index].pos = index;
          on_item_added(index, collection_[index]);
          if (sorted_) sort();
          return result;
        }
        virtual iterator insert(const_iterator pos, value_type&& value) {
          size_t index = pos - begin();
          inserting_ = true;
          iterator result = collection_.insert(pos, value);
          inserting_ = false;
          (*this)[index].owner = this;
          (*this)[index].pos = index;
          on_item_added(index, collection_[index]);
          if (sorted_) sort();
          return result;
        }
        
        virtual void insert_at(size_t index, const value_type& value) {
          if (index > size()) throw argument_out_of_range_exception {};
          insert(begin() + index, value);
        }
        
        template<typename ...args_t>
        void emplace(const_iterator pos, args_t&& ... args) {
          size_t index = pos - begin();
          inserting_ = true;
          iterator result = collection_.insert(pos, args...);
          inserting_ = false;
          (*this)[index].owner = this;
          (*this)[index].pos = index;
          on_item_added(index, collection_[index]);
          if (sorted_) sort();
          return result;
        }
        
        template<typename ...args_t>
        void emplace_back(args_t&& ... args) {
          collection_.push_back(args...);
          size_t index = collection_.size() - 1;
          (*this)[index].owner = this;
          (*this)[index].pos = index;
          on_item_added(index, collection_[index]);
          if (sorted_) sort();
        }
        
        virtual iterator erase(iterator pos) {
          on_item_removed(pos - begin(), *pos);
          erasing_ = true;
          iterator result = collection_.erase(pos);
          erasing_ = false;
          return result;
        }
        virtual iterator erase(const_iterator pos) {
          on_item_removed(pos - begin(), *reinterpret_cast<iterator&>(pos));
          erasing_ = true;
          iterator result = collection_.erase(pos);
          erasing_ = false;
          return result;
        }
        
        virtual iterator erase(iterator first, iterator last) {
          iterator result = end();
          for (iterator it = first; it <= last; ++it)
            result = erase(it);
          return result;
        }
        virtual iterator erase(const_iterator first, const_iterator last) {
          iterator result = end();
          for (const_iterator it = first; it <= last; ++it)
            result = erase(it);
          return result;
        }
        
        virtual void erase_at(size_t index) {
          if (index > size()) throw argument_out_of_range_exception {};
          erase(begin() + index);
        }
        
        virtual void pop_back() {
          if (size() != 0) erase_at(size() - 1);
        }
        
        virtual void push_back(const value_type& item) {
          collection_.push_back(item);
          size_t index = collection_.size() - 1;
          (*this)[index].owner = this;
          (*this)[index].pos = index;
          on_item_added(index, collection_[index]);
          if (sorted_) sort();
        }
        virtual void push_back(value_type&& item) {
          collection_.push_back(item);
          size_t index = collection_.size() - 1;
          (*this)[index].owner = this;
          (*this)[index].pos = index;
          on_item_added(index, collection_[index]);
          if (sorted_) sort();
        }
        
        virtual void push_back_range(const arranged_element_collection& collection) {
          for (value_type item : collection)
            push_back(item);
        }
        virtual void push_back_range(const std::vector<value_type>& collection) {
          for (value_type item : collection)
            push_back(item);
        }
        virtual void push_back_range(const std::initializer_list<value_type>& collection) {
          for (value_type item : collection)
            push_back(item);
        }
        template<typename collection_t>
        void push_back_range(collection_t&& collection) {
          for (auto& item : collection)
            push_back(value_type(item));
        }
        template<typename iterator_t>
        void push_back_range(iterator_t begin, iterator_t end) {
          for (auto it = begin; it != end; ++it)
            push_back(value_type(*it));
        }
        
        virtual void sort() {
          sorter_t sorter;
          sorter(begin(), end());
        }
        
        std::vector<type_t> to_array() const noexcept {
          std::vector<type_t> array;
          std::for_each(collection_.begin(), collection_.end(), [&](auto item) {array.push_back(item);});
          return array;
        }
        
        std::vector<type_t> to_vector() const noexcept {return to_array();}
        
        
        reference operator [](size_type pos) {
          collection_[pos].pos = pos;
          collection_[pos].owner = this;
          return collection_[pos];
        }
        const_reference operator [](size_type pos) const {
          collection_[pos].pos = pos;
          collection_[pos].owner = const_cast<arranged_element_collection*>(this);
          return collection_[pos];
        }
        
        
        event<arranged_element_collection, delegate<void(size_t, type_t& item)>> item_added;
        
        event<arranged_element_collection, delegate<void(size_t, type_t& item)>> item_updated;
        
        event<arranged_element_collection, delegate<void(size_t, type_t& item)>> item_removed;
        
        
        virtual void on_item_added(size_t index, type_t& item) {
          item_added(index, item);
        }
 
        virtual void on_item_updated(size_t index, type_t& item) {
          item_updated(index, item);
        }
 
        virtual void on_item_removed(size_t index, type_t& item) {
          item_removed(index, item);
        }
 
      private:
        mutable std::vector<value_type, allocator_type> collection_;
        bool inserting_ = false;
        bool erasing_ = false;
        bool sorted_ = false;
      };
    }
  }
}