list.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/allocator.hpp"
#include "helpers/equator.hpp"
#include "comparer.hpp"
#include "ilist.hpp"
#define __XTD_CORE_INTERNAL__
#include "../../internal/__list_definition.hpp"
#undef  __XTD_CORE_INTERNAL__
#include "../object_model/read_only_collection.hpp"
#include "../../action.hpp"
#include "../../argument_exception.hpp"
#include "../../argument_out_of_range_exception.hpp"
#include "../../box_integer.hpp"
#include "../../comparison.hpp"
#include "../../converter.hpp"
#include "../../index_out_of_range_exception.hpp"
#include "../../invalid_operation_exception.hpp"
#include "../../intptr.hpp"
#include "../../is.hpp"
#include "../../literals.hpp"
#include "../../object.hpp"
#include "../../new_ptr.hpp"
#include "../../predicate.hpp"
#include "../../ptr.hpp"
#include "../../string.hpp"
#include <utility>
#include <vector>

namespace xtd {
  namespace collections {
    namespace generic {
      template<class type_t, class allocator_t>
      class list : public xtd::object, public xtd::collections::generic::ilist<type_t>, public xtd::iequatable<xtd::collections::generic::list<type_t, allocator_t>> {
        struct __comparer__ {
          __comparer__(const xtd::collections::generic::icomparer<type_t>& comparer) : comparer_(comparer) {}
          bool operator()(const type_t& e1, const type_t& e2) const {return comparer_.compare(e1, e2) < 0;}
          const xtd::collections::generic::icomparer<type_t>& comparer_;
        };
        
        struct __comparison_comparer__ {
          __comparison_comparer__(xtd::comparison<const type_t&> comparison) : comparison_(comparison) {}
          bool operator()(const type_t& e1, const type_t& e2) const {return comparison_(e1, e2) < 0;}
          xtd::comparison<const type_t&> comparison_;
        };
 
        struct __enumerator__ : public ienumerator<type_t> {
        public:
          explicit __enumerator__(const list& items, xtd::size version) : items_(items), version_(version) {}
          
          const type_t& 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_ = list::npos;
          }
          
        protected:
          const list& items_;
          xtd::size index_ = list::npos;
          xtd::size version_ = 0;
        };
 
      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 = std::vector<typename std::conditional<std::is_same<bool, value_type>::value, xtd::byte, value_type>::type, allocator_type>;
        using const_base_type = const 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 base_type::reverse_iterator;
        using const_reverse_iterator = typename base_type::const_reverse_iterator;
        using read_only_collection = 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<list_data>(alloc)) {}
        list(size_type count, const type_t& value, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<list_data>(count, value, alloc)) {}
        explicit list(size_type count, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<list_data>(count, alloc)) {}
        template<class input_iterator_t>
        list(input_iterator_t first, input_iterator_t last, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<list_data>(first, last, alloc)) {}
        list(const xtd::collections::generic::ienumerable<type_t>& collection, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<list_data>(collection, alloc)) {}
        
        list(const list& list) : data_(xtd::new_ptr<list_data>(list)) {}
        list(const base_type& list) : data_(xtd::new_ptr<list_data>(list)) {}
        list(const list& list, const allocator_type& alloc) : data_(xtd::new_ptr<list_data>(list, alloc)) {}
        list(const base_type& list, const allocator_type& alloc) : data_(xtd::new_ptr<list_data>(list, alloc)) {}
        list(std::initializer_list<type_t> items, const allocator_type& alloc = allocator_type()) : data_(xtd::new_ptr<list_data>(items, alloc)) {}
        
        list(list&& other) : data_(xtd::new_ptr<list_data>(std::move(other))) {other.data_ = xtd::new_ptr<list_data>();}
        list(base_type&& other) : data_(xtd::new_ptr<list_data>(std::move(other))) {other.clear();}
        list(list&& other, const allocator_type& alloc) : data_(xtd::new_ptr<list_data>(std::move(other)), alloc) {other.data_ = xtd::new_ptr<list_data>();}
        list(base_type&& other, const allocator_type& alloc) : data_(xtd::new_ptr<list_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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          if (value == capacity()) return;
          if (value < capacity()) shrink_to_fit();
          reserve(value);
        }
        virtual void capacity(size_type 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(type_t&& item) {push_back(std::move(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<class enumerable_t>
        void add_range(const enumerable_t& enumerable) {insert_range(count(), enumerable);}
        
        read_only_collection as_read_only() const noexcept {return read_only_collection {new_ptr<list<value_type>>(*this)};}

        void assign(size_type count, const type_t& value) {
          ++data_->version;
          data_->items.assign(count, value);
        }
        void assign(size_type count, const type_t& value) {…}
        
        template<class input_iterator_t>
        void assign(input_iterator_t first, input_iterator_t last) {
          ++data_->version;
          data_->items.assign(first, last);
        }
        void assign(input_iterator_t first, input_iterator_t last) {…}
        
        virtual void assign(std::initializer_list<type_t> items) {
          ++data_->version;
          data_->items.assign(items.begin(), items.end());
        }
        virtual void assign(std::initializer_list<type_t> items) {…}
        
        virtual reference at(size_type index) {
          if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
          return reinterpret_cast<reference>(data_->items.at(index));
        }
        virtual reference at(size_type 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 reinterpret_cast<const_reference>(data_->items.at(index));
        }
        virtual const_reference at(size_type index) const  {…}

        xtd::size binary_search(const type_t& item) const {return binary_search(0, count(), item, xtd::collections::generic::comparer<type_t>::default_comparer);}
        
        xtd::size binary_search(const type_t& item, const xtd::collections::generic::icomparer<type_t>& comparer) const {return binary_search(0, count(), item, comparer);}
        
        xtd::size binary_search(xtd::size index, xtd::size count, const type_t& item, const xtd::collections::generic::icomparer<type_t>& comparer) const {
          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);
          auto position = std::lower_bound(first, last, item, __comparer__{comparer});
          
          if (position != data_->items.end() && !comparer.compare(item, *position))
            return std::distance(data_->items.begin(), position);
          return ~std::distance(data_->items.begin(), position);
        }
        xtd::size binary_search(xtd::size index, xtd::size count, const type_t& item, const xtd::collections::generic::icomparer<type_t>& comparer) const  {…}

        void clear() override {
          ++data_->version;
          data_->items.clear();
        }
        void clear() override  {…}
        
        bool contains(const type_t& value) const noexcept override {
          for (const auto& item : data_->items)
            if (helpers::equator<type_t> {}(reinterpret_cast<const type_t&>(item), value)) return true;
          return false;
        }
        bool contains(const type_t& value) const noexcept override {…}

        template<class output_t>
        list<output_t> convert_all(xtd::converter<output_t, const type_t&> converter) const {
          auto result = list<output_t> {};
          for (const auto& item : *this)
            result.add(converter(item));
          return result;
        }
        list<output_t> convert_all(xtd::converter<output_t, const type_t&> converter) const  {…}
        
        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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
          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;
          }
        }
        virtual void copy_to(size_type index, xtd::array<type_t>& array, size_type array_index, size_type count) const  {…}
        
        template<class ...args_t>
        iterator emplace(const_iterator pos, args_t&&... args) {
          ++data_->version;
          return to_type_iterator(data_->items.emplace(to_base_type_iterator(pos), std::forward<args_t>(args)...));
        }
        iterator emplace(const_iterator pos, args_t&&... args) {…}
        
        template<class ...args_t>
        reference emplace_back(args_t&&... args) {
          ++data_->version;
          return data_->items.emplace_back(std::forward<args_t>(args)...);
        }
        reference emplace_back(args_t&&... args) {…}
        
        xtd::size ensure_capacity(xtd::size capacity) {
          data_->items.reserve(capacity);
          return this->capacity();
        }
        xtd::size ensure_capacity(xtd::size capacity) {…}
        
        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 {
          if (count() != rhs.count()) return false;
          for (size_type i = 0; i < count(); i++)
            if (!helpers::equator<type_t> {}(at(i), rhs.at(i))) return false;
          return data_->version == rhs.data_->version;
        }
        
        virtual iterator erase(const_iterator pos) {
          ++data_->version;
          return to_type_iterator(data_->items.erase(to_base_type_iterator(pos)));
        }
        virtual iterator erase(const_iterator first, const_iterator last) {
          ++data_->version;
          return to_type_iterator(data_->items.erase(to_base_type_iterator(first), to_base_type_iterator(last)));
        }
        
        bool exists(xtd::predicate<const type_t&> match) const {
          for (const auto& item : *this)
            if (match(item)) return true;
          return false;
        }

        type_t find(xtd::predicate<const type_t&> match) const {
          for (const auto& item : *this)
            if (match(item)) return item;
          return type_t {};
        }
        
        list<type_t> find_all(xtd::predicate<const type_t&> match) const {
          auto result = list<type_t> {};
          for (const auto& item : *this)
            if (match(item)) result.add(item);
          return result;
        }
        
        xtd::size find_index(xtd::predicate<const type_t&> match) const {return find_index(0, size(), match);}
        xtd::size find_index(xtd::size start_index, xtd::predicate<const type_t&> match) const {return find_index(start_index, size() - start_index, match);}
        xtd::size find_index(xtd::size start_index, xtd::size count, xtd::predicate<const type_t&> match) const {
          if (start_index > size() || start_index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          for (auto index = start_index; index < start_index + count; ++index)
            if (match((*this)[index])) return index;
          return npos;
        }
        
        type_t find_last(xtd::predicate<const type_t&> match) const {
          for (auto iterator = rbegin(); iterator != rend(); ++iterator)
            if (match(*iterator)) return *iterator;
          return type_t {};
        }
        
        xtd::size find_last_index(xtd::predicate<const type_t&> match) const {return find_last_index(size() - 1, size(), match);}
        xtd::size find_last_index(xtd::size start_index, xtd::predicate<const type_t&> match) const {return find_last_index(start_index, start_index + 1, match);}
        xtd::size find_last_index(xtd::size start_index, xtd::size count, xtd::predicate<const type_t&> match) const {
          if (count > size() || start_index - count + 1 > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
          auto end_index = start_index - count;
          for (auto index = start_index; index > end_index; --index)
            if (match((*this)[index])) return index;
          return npos;
        }
        
        void for_each(xtd::action<const type_t&> action) {
          for (const auto& item : *this)
            action(item);
        }
        
        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 {
          return {new_ptr<__enumerator__>(*this, data_->version)};
        }
        
        list get_range(size_type index, size_type count) {
          if (index + count > this->count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
          
          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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          if (index + count > this->count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          
          for (auto i = index; i < index + count; ++i)
            if (helpers::equator<type_t> {}(at(i), value)) return i;
          return npos;
        }
        virtual size_type index_of(const type_t& value, size_type index, size_type count) const  {…}
        
        virtual iterator insert(const_iterator pos, const type_t& value) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_base_type_iterator(pos), value));
        }
        virtual iterator insert(const_iterator pos, const type_t& value) {…}

        virtual iterator insert(const_iterator pos, const type_t&& value) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_base_type_iterator(pos), std::move(value)));
        }
        virtual iterator insert(const_iterator pos, const type_t&& value) {…}

        virtual iterator insert(const_iterator pos, size_type count, const type_t& value) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_base_type_iterator(pos), count, value));
        }
        virtual iterator insert(const_iterator pos, size_type count, const type_t& value) {…}

        virtual iterator insert(const_iterator pos, size_type count, type_t&& value) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_base_type_iterator(pos), count, std::move(value)));
        }
        virtual iterator insert(const_iterator pos, size_type count, type_t&& value) {…}

        template<class input_iterator_t>
        iterator insert(const_iterator pos, input_iterator_t first, input_iterator_t last) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_base_type_iterator(pos), first, last));
        }
        iterator insert(const_iterator pos, input_iterator_t first, input_iterator_t last) {…}

        virtual iterator insert(const_iterator pos, const std::initializer_list<type_t>& items) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_base_type_iterator(pos), items.begin(), items.end()));
        }
        virtual iterator insert(const_iterator pos, const std::initializer_list<type_t>& items) {…}
        
        void insert(size_type index, const type_t& value) override {
          if (index > count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          insert(begin() + index, value);
        }
        void insert(size_type index, const type_t& value) override  {…}

        void insert(size_type index, type_t&& value) {
          if (index > count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          insert(begin() + index, std::move(value));
        }
        void insert(size_type index, type_t&& value) {…}

        virtual void insert_range(size_type index, const xtd::collections::generic::ienumerable<type_t>& enumerable) {
          if (index > count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
 
          // 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 xtd::collections::generic::ienumerable<type_t>& enumerable) {…}
        
        virtual void insert_range(size_type index, const std::initializer_list<type_t>& items) {
          if (index > count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          insert(begin() + index, items);
        }
        virtual void insert_range(size_type index, const std::initializer_list<type_t>& items) {…}

        template<class ienumerable_t>
        void insert_range(size_type index, const ienumerable_t& enumerable) {
          if (index > count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          
          // 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());
        }

        size_type last_index_of(const type_t& value) const {
          if (size() == 0) return npos;
          return last_index_of(value, size() - 1, size());
        }
        size_type last_index_of(const type_t& value) const  {…}
        
        size_type last_index_of(const type_t& value, size_type index) const {
          return last_index_of(value, index, index + 1);
        }
        size_type last_index_of(const type_t& value, size_type index, size_type count) const {
          if (count < size() || index >= size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          if (index - count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
 
          for (auto i = index; i >= index - (count - 1); --i)
            if (value == data_->items[i])  return i;
          
          return npos;
        }

        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(std::move(value));
        }
        
        bool remove(const type_t& item) override {
          if (count() == 0)  return false;
          for (auto index = size_type {0}; index < count(); ++index) {
            if (!helpers::equator<type_t> {}(at(index), item)) continue;
            remove_at(index);
            return true;
          }
          return false;
        }

        xtd::size remove_all(const xtd::predicate<const type_t&>& match) {
          auto count = xtd::size {0};
          auto iterator = data_->items.begin();
          while (iterator != data_->items.end())
            if (!match(*iterator)) iterator++;
            else {
              iterator = data_->items.erase(iterator);
              ++count;
            }
          
          if (count) ++data_->version;
          return count;
        }

        void remove_at(size_type index) override {
          if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
 
          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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          
          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()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          if (count == size()) return;
          ++data_->version;
          data_->items.resize(count, value);
        }
        
        void reverse() {reverse(0, count());}
        void reverse(size_type index, size_type count) {
          if (index + count > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
          
          ++data_->version;
          auto poitions1 = index;
          auto position2 = (index + count) - 1;
          auto iterator1 = data_->items.begin() + poitions1;
          auto iterator2 = data_->items.begin() + position2;
          
          while (poitions1++ < position2--)
            std::iter_swap(iterator1++, iterator2--);
        }
        
        virtual void shrink_to_fit() {data_->items.shrink_to_fit();}

        list<type_t> slice(size_type start, size_type length) const {
          if (start + length > size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
          return list<type_t> {data_->items.begin() + start, data_->items.begin() + start + length};
        }
        
        void sort() {sort(xtd::collections::generic::comparer<type_t>::default_comparer);}
        
        void sort(xtd::comparison<const type_t&> comparison) {
          ++data_->version;
          std::sort(data_->items.begin(), data_->items.end(), __comparison_comparer__ {comparison});
        }
        
        void sort(const xtd::collections::generic::icomparer<type_t>& comparer) {
          sort(0, count(), comparer);
        }
        
        void 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});
        }

        virtual void swap(list& other) noexcept {
          ++data_->version;
          data_->items.swap(other.data_->items);
        }
        
        virtual xtd::array<value_type> to_array() const noexcept {return size() ? xtd::array<value_type>(data(), size()) : xtd::array<value_type> {};}
        
        string to_string() const noexcept override {return xtd::string::format("[{}]", xtd::string::join(", ", *this));}
                
        virtual void trim_excess() {shrink_to_fit();}

        bool true_for_all(xtd::predicate<const type_t&> match) const {
          for (const auto& item : *this)
            if (!match(item)) return false;
          return true;
        }
        
        
        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);}
        
        operator const base_type&() const noexcept {return data_->items;}
        operator base_type&() noexcept {return data_->items;}
        
      private:
        typename base_type::const_iterator to_base_type_iterator(const_iterator value) const noexcept {
          return ilist<type_t>::to_iterator(value, *this, data_->items);
        }
        
        typename base_type::iterator to_base_type_iterator(iterator value) noexcept {
          return ilist<type_t>::to_iterator(value, *this, data_->items);
        }
        
        const_iterator to_type_iterator(typename base_type::const_iterator value) const noexcept {
          return ilist<type_t>::to_iterator(value, data_->items, *this);
        }
        
        iterator to_type_iterator(typename base_type::iterator value) noexcept {
          return ilist<type_t>::to_iterator(value, data_->items, *this);
        }
 
        struct list_data {
          list_data() = default;
          explicit list_data(const allocator_type& alloc) noexcept : items(alloc) {}
          list_data(size_type count, const type_t& value, const allocator_type& alloc = allocator_type()) : items(count, value, alloc) {}
          explicit list_data(size_type count, const allocator_type& alloc = allocator_type()) : items(count, alloc) {}
          template<class input_iterator_t>
          list_data(input_iterator_t first, input_iterator_t last, const allocator_type& alloc = allocator_type()) : items(first, last, alloc) {}
          list_data(const xtd::collections::generic::ienumerable<type_t>& collection, const allocator_type& alloc = allocator_type()) : items(collection.begin(), collection.end(), alloc) {}
          list_data(const list& list) : items(list.data_->items), version(list.data_->version) {}
          list_data(const base_type& list) : items(list) {}
          list_data(const list& list, const allocator_type& alloc) : items(list.data_->items, alloc), version(list.data_->version) {}
          list_data(const base_type& list, const allocator_type& alloc) : items(list, alloc) {}
          list_data(std::initializer_list<type_t> items, const allocator_type& alloc = allocator_type()) : items(items.begin(), items.end(), alloc) {}
          list_data(list&& other) : items(std::move(other.data_->items)), version(std::move(other.data_->version)) {other.data_->items.clear(); other.data_->version = 0;}
          list_data(base_type&& other) : items(std::move(other)) {other.clear();}
          list_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;}
          list_data(base_type&& other, const allocator_type& alloc) : items(std::move(other), alloc) {}
 
          list_data(const list_data&) = default;
          list_data& operator =(const list_data&) = default;
 
          base_type items;
          size_type version = 0;
          xtd::object sync_root;
        };
        
        xtd::ptr<list_data> data_ = xtd::new_ptr<list_data>();
      };
      class list : public xtd::object, public xtd::collections::generic::ilist<type_t>, public xtd::iequatable<xtd::collections::generic::list<type_t, allocator_t>> {…};
      
      // C++17 deduction guides for xtd::collections::generic::list
      // {
      template<class type_t>
      list(std::initializer_list<type_t>) -> list<type_t, helpers::allocator<type_to_list_t<type_t>>>;
      
      template<class type_t>
      list(const ienumerable<type_t>&) -> list<type_t, helpers::allocator<type_to_list_t<type_t>>>;
      
      template<class type_t>
      list(const ilist<type_t>&) -> list<type_t, helpers::allocator<type_to_list_t<type_t>>>;
      
      template<class type_t>
      list(const std::vector<type_t>&) -> list<type_t, helpers::allocator<type_to_list_t<type_t>>>;
      
      template<class type_t, class allocator_t = helpers::allocator<type_to_list_t<type_t>>>
      list(const list<type_t, allocator_t>&) -> list<type_t, allocator_t>;
      
      template<class type_t>
      list(std::vector<type_t>&&) -> list<type_t, helpers::allocator<type_to_list_t<type_t>>>;
      
      template<class type_t, class allocator_t = helpers::allocator<type_to_list_t<type_t>>>
      list(list<type_t, allocator_t>&&) -> list<type_t, allocator_t>;
      // }
    }
  }
}

namespace xtd::collections::generic::extensions {
  template <class enumerable_t, class source_t>
  inline const xtd::collections::generic::list<source_t>& enumerable<enumerable_t, source_t>::to_list() const noexcept {
    return xtd::linq::enumerable::to_list(base());
  }
}
 
namespace xtd::linq {
  template <class source_t>
  inline const xtd::collections::generic::list<source_t>& enumerable::to_list(const xtd::collections::generic::ienumerable<source_t>& source) noexcept {
    static thread_local auto result = xtd::collections::generic::list<source_t> {};
    result = xtd::collections::generic::list<source_t> {source};
    return result;
  }
}