arranged_element_collection.h

Go to the documentation of this file.

 
#pragma once
#include <limits>
#include <ostream>
#include <vector>
#include <xtd/argument_out_of_range_exception.h>
#include <xtd/event_args.h>
#include <xtd/event_handler.h>
#include <xtd/event.h>
#include "sorter_none.h"
 
namespace xtd {
  namespace forms {
    namespace layout {
      template<typename type_t, typename sorter_t = sorter_none>
      class arranged_element_collection {
      public:
        class value_type : public type_t {
        public:
          value_type() {};
          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->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->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 = std::numeric_limits<size_t>::max();
          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;
        
        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);
        }
 
        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);}
        
        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_erased;
        
        allocator_type get_allocator() const {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();}
        
        reference operator[](size_type pos) {
          collection_[pos].pos = pos;
          collection_[pos].owner = this;
          return collection_[pos];
        }
        const_reference operator[](size_type pos) const {return collection_[pos];}
        
        iterator begin() {return collection_.begin();}
        const_iterator begin() const {return collection_.begin();}
        const_iterator cbegin() const {return collection_.cbegin();}
        
        iterator end() {return collection_.end();}
        const_iterator end() const {return collection_.end();}
        const_iterator cend() const {return collection_.cend();}
        
        reverse_iterator rbegin() {return collection_.rbegin();}
        const_reverse_iterator rbegin() const {return collection_.rbegin();}
        const_reverse_iterator crbegin() const {return collection_.crbegin();}
 
        reverse_iterator rend() {return collection_.rend();}
        const_reverse_iterator rend() const {return collection_.rend();}
        const_reverse_iterator crend() const {return collection_.crend();}
        
        bool empty() const {return collection_.empty();}
        
        size_type size() const {return collection_.size();}
        
        size_type max_size() const {return collection_.max_size();}
        
        void reserve(size_type size) {collection_.reserve(size);}
        
        size_type capacity() const {return collection_.capacity();}
        
        void shrink_to_fit() {collection_.shrink_to_fit();}
        
        bool sorted() const {return sorted_;}
        void sorted(bool value) {
          if (sorted_ != value) {
            sorted_ = value;
            if (sorted_) sort();
          }
        }
        
        void clear() {
          iterator it = begin();
          while (it != end())
            it = erase(it);
        }
 
        iterator insert(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;
          item_added(index, collection_[index]);
          if (sorted_) sort();
          return result;
        }
        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;
          item_added(index, collection_[index]);
          if (sorted_) sort();
          return result;
        }
        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;
          item_added(index, collection_[index]);
          if (sorted_) sort();
          return result;
        }
 
        void insert_at(size_t index, const value_type& value) {
          if (index > size()) throw argument_out_of_range_exception(current_stack_frame_);
          insert(begin() + index, value);
        }
 
        iterator erase(iterator pos) {
          item_erased(pos - begin(), *pos);
          erasing_ = true;
          iterator result = collection_.erase(pos);
          erasing_ = false;
          return result;
        }
         iterator erase(const_iterator pos) {
          item_erased(pos - begin(), *pos);
          erasing_ = true;
          iterator result = collection_.erase(pos);
          erasing_ = false;
          return result;
        }
        
        iterator erase(iterator first, iterator last) {
          iterator result = end();
          for (iterator it = first; it <= last; it++)
            result = erase(it);
          return result;
        }
        iterator erase(const_iterator first, const_iterator last) {
          iterator result = this->bend();
          for (const_iterator it = first; it <= last; it++)
            result = erase(it);
          return result;
        }
        
        void erase_at(size_t index) {
          if (index > size()) throw argument_out_of_range_exception(current_stack_frame_);
          erase(begin() + index);
        }
 
        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;
          item_added(index, collection_[index]);
          if (sorted_) sort();
        }
        void push_back(value_type&& item) {
          collection_.push_back(item);
          size_t index = collection_.size() - 1;
          (*this)[index].owner = this;
          (*this)[index].pos = index;
          item_added(index, collection_[index]);
          if (sorted_) sort();
        }
        
        void push_back_range(const arranged_element_collection& collection) {
          for(value_type item : collection)
            push_back(item);
        }
        void push_back_range(const std::vector<value_type>& collection) {
          for(value_type item : collection)
            push_back(item);
        }
        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(const auto& item : collection)
            push_back(value_type(item));
        }
 
        void sort() {
          sorter_t sorter;
          sorter(begin(), end());
        }
 
        std::vector<type_t> to_array() const {
          std::vector<type_t> array;
          for (auto item : collection_)
            array.push_back(item);
          return array;
        }
        
        std::vector<type_t> to_vector() const {return to_array();}
 
        static const size_type npos = std::numeric_limits<size_type>::max();
 
      private:
        std::vector<value_type, allocator_type> collection_;
        bool inserting_ = false;
        bool erasing_ = false;
        bool sorted_ = false;
      };
    }
  }
}