list.h

Go to the documentation of this file.

 
#pragma once
#include "helpers/allocator.h"
#include "ilist.h"
#include "params.h"
#include "../object_model/read_only_collection.h"
#include "../../argument_exception.h"
#include "../../argument_out_of_range_exception.h"
#include "../../index_out_of_range_exception.h"
#include "../../box_integer.h"
#include "../../invalid_operation_exception.h"
#include "../../intptr.h"
#include "../../is.h"
#include "../../literals.h"
#include "../../object.h"
#include "../../new_ptr.h"
#include "../../ptr.h"
#include "../../string.h"
#include <utility>
#include <vector>
 
namespace xtd {
  namespace collections {
    namespace generic {
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      class list : public xtd::object, public xtd::collections::generic::ilist<type_t>, public xtd::iequatable<xtd::collections::generic::list<type_t, allocator_t>> {
      public:
        
        using value_type = type_t;
        using allocator_type = typename xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, value_type>::value, xtd::byte, value_type>::type>;
        using base_type = typename std::vector<typename std::conditional<std::is_same<bool, value_type>::value, xtd::byte, value_type>::type, allocator_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::ilist<type_t>::iterator;
        using const_iterator = typename xtd::collections::generic::ilist<type_t>::const_iterator;
        using reverse_iterator = typename base_type::reverse_iterator;
        using const_reverse_iterator = typename base_type::const_reverse_iterator;
        using read_only_collection = typename xtd::collections::object_model::read_only_collection<value_type>;
        
        
        inline static constexpr size_type npos = xtd::collections::generic::ilist<type_t>::npos;
        
        
        list() noexcept = default;
        
        explicit list(const allocator_type& alloc) noexcept : data_(xtd::new_ptr<struct data>(alloc)) {}
        list(size_type count, const type_t& value, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<struct data>(count, value, alloc)) {}
        explicit list(size_type count, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<struct data>(count, alloc)) {}
        template<typename input_iterator_t>
        list(input_iterator_t first, input_iterator_t last, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<struct data>(first, last, alloc)) {}
        list(const xtd::collections::generic::ienumerable<type_t>& collection, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<struct data>(collection, alloc)) {}
        
        list(const list& list) : data_(xtd::new_ptr<struct data>(list)) {}
        list(const base_type& list) : data_(xtd::new_ptr<struct data>(list)) {}
        list(const list& list, const allocator_type& alloc) : data_(xtd::new_ptr<struct data>(list, alloc)) {}
        list(const base_type& list, const allocator_type& alloc) : data_(xtd::new_ptr<struct data>(list, alloc)) {}
        list(std::initializer_list<type_t> items, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<struct data>(items, alloc)) {}
        
        list(list&& other) : data_(xtd::new_ptr<struct data>(std::move(other))) {other.data_ = xtd::new_ptr<struct data>();}
        list(base_type&& other) : data_(xtd::new_ptr<struct data>(std::move(other))) {other.clear();}
        list(list&& other, const allocator_type& alloc) : data_(xtd::new_ptr<struct data>(std::move(other)), alloc) {other.data_ = xtd::new_ptr<struct data>();}
        list(base_type&& other, const allocator_type& alloc) : data_(xtd::new_ptr<struct data>(std::move(other), alloc)) {other.items.clear();}
        
        
        virtual reference back() {return at(count() - 1);}
        virtual const_reference back() const {return at(count() - 1);}
        
        const_iterator begin() const noexcept override {return ienumerable<value_type>::begin();}
        iterator begin() noexcept override {return ienumerable<value_type>::begin();}
        
        virtual size_type capacity() const noexcept {return data_->items.capacity();}
        virtual void capacity(size_type value) {
          if (value < count()) throw argument_out_of_range_exception {csf_};
          reserve(value);
        }
        
        const_iterator cbegin() const noexcept override {return ienumerable<value_type>::cbegin();}
        
        const_iterator cend() const noexcept override {return ienumerable<value_type>::cend();}
        
        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 reinterpret_cast<pointer>(data_->items.data());}
        virtual const_pointer data() const noexcept {return reinterpret_cast<const_pointer>(data_->items.data());}
 
        virtual bool empty() const noexcept {return data_->items.empty();}
        
        const_iterator end() const noexcept override {return ienumerable<value_type>::end();}
        iterator end() noexcept override {return 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 false;}
        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 max_size() const noexcept {return data_->items.max_size();}
        
        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;}
        
        
        void add(const type_t& item) override {push_back(item);}
        
        void add_range(const xtd::collections::generic::ienumerable<type_t>& enumerable) {insert_range(count(), enumerable);}
        
        void add_range(std::initializer_list<type_t> il) {insert_range(count(), il);}
 
        template<typename enumerable_t>
        void add_range(const enumerable_t& enumerable) {insert_range(count(), enumerable);}
 
        void assign(size_type count, const type_t& value) {
          ++data_->version;
          data_->items.assign(count, value);
        }
        
        template<typename input_iterator_t>
        void assign(input_iterator_t first, input_iterator_t last) {
          ++data_->version;
          data_->items.assign(first, last);
        }
        
        read_only_collection as_read_only() const noexcept {return read_only_collection {new_ptr<list<value_type>>(*this)};}
        
        virtual void assign(std::initializer_list<type_t> items) {
          clear();
          for (auto item : items)
            push_back(item);
        }
        
        virtual reference at(size_type index) {
          if (index >= count()) throw index_out_of_range_exception {csf_};
          return reinterpret_cast<reference>(data_->items.at(index));
        }
        virtual const_reference at(size_type index) const {
          if (index >= count()) throw index_out_of_range_exception {csf_};
          return reinterpret_cast<const_reference>(data_->items.at(index));
        }
        
        void clear() override {
          ++data_->version;
          data_->items.clear();
        }
        
        bool contains(const type_t& value) const noexcept override {
          for (const type_t& item : data_->items)
            if (item == value) return true;
          return false;
        }
        
        virtual void copy_to(xtd::array<type_t>& array) const {copy_to(0, array, 0, count());}
        
        void copy_to(xtd::array<type_t>& array, size_type array_index) const override {copy_to(0, array, array_index, count());}
        
        virtual void copy_to(size_type index, xtd::array<type_t>& array, size_type array_index, size_type count) const {
          if (index + count > this->count() || array_index + count > array.size()) throw xtd::argument_exception {csf_};
          auto i = size_type {0}, c = size_type {0};
          for (const type_t& item : *this) {
            if (i >= index + count) return;
            if (i >= index) {
              array[array_index + c] = item;
              c += 1;
            }
            i += 1;
          }
        }
        
        template<typename... args_t>
        iterator emplace(const_iterator pos, args_t&&... args) {
          ++data_->version;
          return data_->items.eplace(std::forward<args_t>(args)...);
        }
        
        template<typename... args_t>
        reference emplace_back(args_t&&... args) {
          ++data_->version;
          return data_->items.emplace_back(std::forward<args_t>(args)...);
        }
        
        bool equals(const object& obj) const noexcept override {return is<list<value_type>>(obj) && equals(static_cast<const list<value_type>&>(obj));}
        bool equals(const list& rhs) const noexcept override {return data_->items == rhs.data_->items && data_->version == rhs.data_->version;}
        
        virtual iterator erase(const_iterator pos) {
          ++data_->version;
          return to_iterator(data_->items.erase(to_base_type_iterator(pos)));
        }
        virtual iterator erase(const_iterator first, const_iterator last) {
          ++data_->version;
          return to_iterator(data_->items.erase(to_base_type_iterator(first), to_base_type_iterator(last)));
        }
        
        virtual allocator_type get_allocator() const {return data_->items.get_allocator();}
        
        virtual base_type& get_base_type() noexcept {return data_->items;}
        virtual const base_type& get_base_type() const noexcept {return data_->items;}
 
        enumerator<value_type> get_enumerator() const noexcept override {
          class list_enumerator : public ienumerator<value_type> {
          public:
            explicit list_enumerator(const list& items, size_type version) : items_(items), version_(version) {}
            
            const value_type& current() const override {
              if (version_ != items_.data_->version) throw xtd::invalid_operation_exception {"Collection was modified; enumeration operation may not execute.", csf_};
              return items_.at(index_);
            }
            
            bool move_next() override {
              if (version_ != items_.data_->version) throw xtd::invalid_operation_exception {"Collection was modified; enumeration operation may not execute.", csf_};
              return ++index_ < items_.count();
            }
            
            void reset() override {
              version_ = items_.data_->version;
              index_ = list::npos;
            }
            
          protected:
            const list& items_;
            size_type index_ = list::npos;
            size_type version_ = 0;
          };
          return {new_ptr<list_enumerator>(*this, data_->version)};
        }
        
        list get_range(size_type index, size_type count) {
          if (index + count > this->count()) throw xtd::argument_exception {csf_};
          
          return list<type_t> {begin() + index, begin() + index + count};
        }
 
        size_type index_of(const type_t& value) const noexcept override {
          if (count() == 0)  return npos;
          return index_of(value, 0, count());
        }
        
        virtual size_type index_of(const type_t& value, size_type index) const {return index_of(value, index, count() - index);}
        
        virtual size_type index_of(const type_t& value, size_type index, size_type count) const {
          if (index >= this->count()) throw xtd::argument_out_of_range_exception {csf_};
          if (index + count > this->count()) throw xtd::argument_out_of_range_exception {csf_};
          
          for (auto i = index; i < index + count; ++i)
            if (at(i) == value) return i;
          return npos;
        }
        
        virtual iterator insert(const_iterator pos, const type_t& value) {
          ++data_->version;
          return to_iterator(data_->items.insert(to_base_type_iterator(pos), value));
        }
        virtual iterator insert(const_iterator pos, const type_t&& value) {
          ++data_->version;
          return to_iterator(data_->items.insert(to_base_type_iterator(pos), value));
        }
        virtual iterator insert(const_iterator pos, size_type count, const type_t& value) {
          ++data_->version;
          return to_iterator(data_->items.insert(to_base_type_iterator(pos), count, value));
        }
        template<typename input_iterator_t>
        iterator insert(const_iterator pos, input_iterator_t first, input_iterator_t last) {
          ++data_->version;
          return to_iterator(data_->items.insert(to_base_type_iterator(pos), first, last));
        }
        virtual iterator insert(const_iterator pos, const std::initializer_list<type_t>& items) {
          ++data_->version;
          return to_iterator(data_->items.insert(to_base_type_iterator(pos), items.begin(), items.end()));
        }
        
        void insert(size_type index, const type_t& value) override {
          if (index > count()) throw xtd::argument_out_of_range_exception {csf_};
          insert(begin() + index, value);
        }
        
        virtual void insert_range(size_type index, const xtd::collections::generic::ienumerable<type_t>& enumerable) {
          if (index > count()) throw xtd::argument_out_of_range_exception {csf_};
 
          // If the collection is this instance, it must be copied to avoid an infinite loop.
          if (reinterpret_cast<xtd::intptr>(&enumerable) == reinterpret_cast<xtd::intptr>(this)) {
            auto items = list<type_t>(enumerable.begin(), enumerable.end());
            insert(begin() + index, items.begin(), items.end());
            return;
          }
          
          insert(begin() + index, enumerable.begin(), enumerable.end());
        }
        
        virtual void insert_range(size_type index, const std::initializer_list<type_t>& items) {
          if (index > count()) throw xtd::argument_out_of_range_exception {csf_};
          insert(begin() + index, items);
        }
 
        template<typename ienumerable_t>
        void insert_range(size_type index, const ienumerable_t& enumerable) {
          if (index > count()) throw xtd::argument_out_of_range_exception {csf_};
          
          // If the collection is this instance, it must be copied to avoid an infinite loop.
          if (reinterpret_cast<xtd::intptr>(&enumerable) == reinterpret_cast<xtd::intptr>(this)) {
            auto items = list<type_t>(enumerable.begin(), enumerable.end());
            insert(begin() + index, items.begin(), items.end());
            return;
          }
          
          insert(begin() + index, enumerable.begin(), enumerable.end());
        }
 
        virtual void pop_back() {
          ++data_->version;
          data_->items.pop_back();
        }
        
        virtual void push_back(const type_t& value) {
          ++data_->version;
          data_->items.push_back(value);
        }
        virtual void push_back(type_t&& value) {
          ++data_->version;
          data_->items.push_back(value);
        }
        
        bool remove(const type_t& item) override {
          if (count() == 0)  return false;
          for (auto index = size_type {0}; index < count(); ++index) {
            if (at(index) != item) continue;
            remove_at(index);
            return true;
          }
          return false;
        }
        
        void remove_at(size_type index) override {
          if (index >= count()) throw xtd::argument_out_of_range_exception {csf_};
 
          if (index == count() - 1) pop_back();
          else erase(begin() + index);
        }
 
        virtual void remove_range(size_type index, size_type count) {
          if (index + count >= this->count()) throw xtd::argument_out_of_range_exception {csf_};
          
          erase(begin() + index, begin() + index + count);
        }
        
        virtual void reserve(size_type new_cap) {data_->items.reserve(new_cap);}
 
        virtual void resize(size_type count)  {resize(count, value_type {});}
        virtual void resize(size_type count, const value_type& value) {
          if (count > max_size()) throw xtd::argument_out_of_range_exception {csf_};
          if (count == size()) return;
          ++data_->version;
          data_->items.resize(count, value);
        }
        
        virtual void shrink_to_fit() {data_->items.shrink_to_fit();}
        
        virtual void swap(list& other) noexcept {
          ++data_->version;
          data_->items.swap(other.data_->items);
        }
        
        virtual xtd::array<value_type> to_array() const noexcept {return xtd::array<value_type>(begin(), end());}
        
        string to_string() const noexcept override {return xtd::string::format("[{}]", xtd::string::join(", ", *this));}
                
        virtual void trim_excess() {shrink_to_fit();}
        
        
        list& operator =(const list& other) = default;
        list& operator =(list&& other) noexcept {
          data_->version = std::move(other.data_->version);
          data_->items = std::move(other.data_->items);
          return *this;
        }
        list& operator =(std::initializer_list<type_t>& items) {
          data_->version = 0;
          data_->items = items;
          return *this;
        }
        
        const_reference operator [](size_type index) const override {return at(index);}
        reference operator [](size_type index) override {return at(index);}
        
        virtual operator const base_type&() const noexcept {return data_->items;}
        virtual operator base_type&() noexcept {return data_->items;}
        
      private:
        typename base_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 base_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 data {
          data() = default;
          explicit data(const allocator_type& alloc) noexcept : items(alloc) {}
          data(size_type count, const type_t& value, const allocator_type& alloc = allocator_type()) : items(count, value, alloc) {}
          explicit data(size_type count, const allocator_type& alloc = allocator_type()) : items(count, alloc) {}
          template<typename input_iterator_t>
          data(input_iterator_t first, input_iterator_t last, const allocator_type& alloc = allocator_type()) : items(first, last, alloc) {}
          data(const xtd::collections::generic::ienumerable<type_t>& collection, const allocator_type& alloc = allocator_type()) : items(collection.begin(), collection.end(), alloc) {}
          data(const list& list) : items(list.data_->items), version(list.data_->version) {}
          data(const base_type& list) : items(list) {}
          data(const list& list, const allocator_type& alloc) : items(list.data_->items, alloc), version(list.data_->version) {}
          data(const base_type& list, const allocator_type& alloc) : items(list, alloc) {}
          data(std::initializer_list<type_t> items, const allocator_type& alloc = allocator_type()) : items(items.begin(), items.end(), alloc) {}
          data(list&& other) : items(std::move(other.data_->items)), version(std::move(other.data_->version)) {other.data_->items.clear(); other.data_->version = 0;}
          data(base_type&& other) : items(std::move(other)) {other.clear();}
          data(list&& other, const allocator_type& alloc) : items(other.data_->items, alloc), version{std::move(other.data_->version)} {other.data_->items.clear(); other.data_->version = 0;}
          data(base_type&& other, const allocator_type& alloc) : items(std::move(other), alloc) {}
 
          data(const data&) = default;
          data& operator =(const data&) = default;
 
          base_type items;
          size_type version = 0;
          xtd::object sync_root;
        };
        
        xtd::ptr<struct data> data_ = xtd::new_ptr<struct data>();
      };
      
      // C++17 deduction
      // {
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      list(std::initializer_list<type_t>) -> list<type_t, allocator_t>;
      
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      list(const xtd::collections::generic::ienumerable<type_t>&) -> list<type_t, allocator_t>;
      
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      list(const xtd::collections::generic::ilist<type_t>&) -> list<type_t, allocator_t>;
      
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      list(const std::vector<type_t>&) -> list<type_t, allocator_t>;
      
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      list(const list<type_t, allocator_t>&) -> list<type_t, allocator_t>;
      
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      list(std::vector<type_t>&&) -> list<type_t, allocator_t>;
      
      template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<typename std::conditional<std::is_same<bool, type_t>::value, char, type_t>::type>>
      list(list<type_t, allocator_t>&&) -> list<type_t, allocator_t>;
      // }
    }
  }
}