dictionary.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/allocator.hpp"
#include "helpers/equator.hpp"
#include "helpers/hasher.hpp"
#include "helpers/iterator.hpp"
#include "idictionary.hpp"
#include "key_not_found_exception.hpp"
#include "../../argument_out_of_range_exception.hpp"
#include "../../new_ptr.hpp"
#include "../../ptr.hpp"
#include <cmath>
#include <unordered_map>

namespace xtd {
  namespace collections {
    namespace generic {
      template<class key_t, class value_t, class hasher_t = helpers::hasher<key_t>, class equator_t = helpers::equator<key_t>, class allocator_t = helpers::allocator<std::pair<const key_t, value_t >>>
      class dictionary : public xtd::object, public xtd::collections::generic::idictionary<key_t, value_t> {
      public:
        
        struct hasher {
          
          using argument_type = key_t;
          using result_type = xtd::size;
          
          
          size_t operator()(const key_t& key) const {
            if (comparer) return comparer->get_hash_code(key);
            return hasher_t {}(key);
          }

          
private:
          friend class dictionary;
          hasher() = default;
          explicit hasher(const iequality_comparer<key_t>* comparer) : comparer {comparer} {}
          const iequality_comparer<key_t>* comparer = nullptr;
        };
        
        struct equator {
          
          using first_argument_type = key_t;
          using second_argument_type = key_t;
          using result_type = bool;
          
          
          bool operator()(const key_t & a, const key_t & b) const {
            if (&a == &b) return true;
            if (comparer) return comparer->equals(a, b);
            return equator_t {}(a, b);
          }

          
private:
          friend class dictionary;
          equator() = default;
          explicit equator(const iequality_comparer < key_t > * comparer) : comparer {comparer} {}
          const iequality_comparer < key_t > * comparer = nullptr;
        };

        
        
        using key_type = typename xtd::collections::generic::idictionary < key_t, value_t >::key_type;
        using mapped_type = typename xtd::collections::generic::idictionary < key_t, value_t >::mapped_type;
        using value_type = typename xtd::collections::generic::idictionary < key_type, mapped_type >::value_type;
        using size_type = xtd::size;
        using difference_type = xtd::ptrdiff;
        using key_equal = equator;
        using allocator_type = allocator_t;
        using base_value_type = std::pair < const key_t, value_t >;
        using base_type = std::unordered_map < key_type, mapped_type, hasher, key_equal, allocator_type >;
        using reference = value_type&;
        using const_reference = const value_type&;
        using pointer = typename std::allocator_traits < allocator_t >::pointer;
        using const_pointer = typename std::allocator_traits < allocator_t >::const_pointer;
        using iterator = typename xtd::collections::generic::idictionary < key_type, mapped_type >::iterator;
        using const_iterator = typename xtd::collections::generic::idictionary < key_type, mapped_type >::const_iterator;
        using local_iterator = typename base_type::local_iterator;
        using const_local_iterator = typename base_type::const_local_iterator;
        using node_type = typename base_type::node_type;
        using insert_return_type = typename base_type::insert_return_type;
        using key_collection = typename xtd::collections::generic::idictionary < key_type, mapped_type >::key_collection;
        using value_collection = typename xtd::collections::generic::idictionary < key_type, mapped_type >::value_collection;
        
        
        dictionary() noexcept = default;
        
        dictionary(const idictionary < key_t, value_t > & dictionary) {
          ensure_capacity(dictionary.count());
          for (const auto& item : dictionary)
            add(item);
        }
        
        dictionary(const ienumerable < value_type > & collection) {
          for (const auto& item : collection)
            add(item);
        }
        
        template < class equality_comparer_t >
        dictionary(const equality_comparer_t& comparer) : data_(xtd::new_ptr < data > (new_ptr < equality_comparer_t > (comparer))) {}
        
        explicit dictionary(size_type bucket_count, const hasher_t& hash = hasher_t {}, const equator_t& equal = equator_t {}, const allocator_type& alloc = allocator_type {}) noexcept : data_(xtd::new_ptr < data > (bucket_count)) {}
        
        /* Confict with dictionary(size_t capacity, const equality_comparer_t& comparer) constructor
        dictionary(size_type bucket_count, const allocator_type& alloc) noexcept : data_(xtd::new_ptr<data>(bucket_count)) {}
         */
        
        dictionary(size_type bucket_count, const hasher_t& hash, const allocator_type & alloc) noexcept : data_(xtd::new_ptr < data > (bucket_count)) {}
        
        template < class equality_comparer_t >
        dictionary(const idictionary < key_t, value_t > & dictionary, const equality_comparer_t& comparer) : data_(xtd::new_ptr < data>(new_ptr < equality_comparer_t > (comparer))) {
          ensure_capacity(dictionary.count());
          for (const auto& item : dictionary)
            add(item);
        }
        
        template < class equality_comparer_t >
        dictionary(const ienumerable < value_type > & collection, const equality_comparer_t& comparer) : data_(xtd::new_ptr < data>(new_ptr < equality_comparer_t > (comparer))) {
          for (const auto& item : collection)
            add(item);
        }
        
        template < class equality_comparer_t >
        dictionary(size_t capacity, const equality_comparer_t& comparer) : data_(xtd::new_ptr < data > (new_ptr < equality_comparer_t > (comparer))) {
          ensure_capacity(capacity);
        }
        
        /* Conflict with dictionary(const equality_comparer_t& comparer) constructor.
        explicit dictionary(const allocator_t& alloc) noexcept {}
        */
        
        template < class input_iterator_t >
        explicit dictionary(input_iterator_t first, input_iterator_t last, size_type bucket_count = 0, const hasher_t& hash = hasher_t {}, const equator_t& equal = equator_t {}, const allocator_type& alloc = allocator_type {}) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (auto iterator = first; iterator != last; ++iterator) {
            const auto& [key, value] = *iterator;
            add(key, value);
          }
        }

        template < class input_iterator_t >
        explicit dictionary(input_iterator_t first, input_iterator_t last, size_type bucket_count, const allocator_type & alloc) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (auto iterator = first; iterator != last; ++iterator) {
            const auto& [key, value] = *iterator;
            add(key, value);
          }
        }

        template < class input_iterator_t >
        explicit dictionary(input_iterator_t first, input_iterator_t last, size_type bucket_count, const hasher_t& hash, const allocator_type & alloc) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (auto iterator = first; iterator != last; ++iterator) {
            const auto& [key, value] = *iterator;
            add(key, value);
          }
        }

        dictionary(const dictionary & other) noexcept : data_(xtd::new_ptr < data > (other.data_->comparer, other.data_->items, other.data_->version)) {}
        
        /* Conflict with dictionary(const idictionary<key_t, value_t>& dictionary, const equality_comparer_t& comparer) constructor.
        dictionary(const dictionary& other, const allocator_type& alloc) noexcept : data_(xtd::new_ptr<data>(other.data_->comparer, other.data_->items, other.data_->version)) {}
         */
        
        dictionary(const std::unordered_map < key_t, value_t > & other) {
          for (auto iterator = other.begin(); iterator != other.end(); ++iterator) {
            const auto& [key, value] = *iterator;
            add(key, value);
          }
        }

        dictionary(const std::unordered_map < key_t, value_t > & other, const allocator_type & alloc) {
          for (auto iterator = other.begin(); iterator != other.end(); ++iterator) {
            const auto& [key, value] = *iterator;
            add(key, value);
          }
        }

        dictionary(dictionary&& other) noexcept = default;
        dictionary(dictionary&& other, const allocator_type & alloc) noexcept : data_(xtd::new_ptr < data > (std::move(other.data_->items), other.data_->version)) {}
        dictionary(std::unordered_map < key_t, value_t > && other) noexcept : data_(xtd::new_ptr < data>(std::move(other.data_->items))) {}
        dictionary(std::unordered_map < key_t, value_t > && other, const allocator_type & alloc) noexcept : data_(xtd::new_ptr < data>(std::move(other.data_->items))) {}
        explicit dictionary(std::initializer_list < base_value_type > init, size_type bucket_count = 0, const hasher_t& hash = hasher_t {}, const equator_t& equal = equator_t {}, const allocator_type& alloc = allocator_type {}) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
            (*this)[key] = value;
          }
        }

        dictionary(std::initializer_list < base_value_type > init, size_type bucket_count, const allocator_type & alloc) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
            (*this)[key] = value;
          }
        }

        dictionary(std::initializer_list < base_value_type > init, size_type bucket_count, const hasher_t& hash, const allocator_type & alloc) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
            (*this)[key] = value;
          }
        }

        template < class init_key_t, class init_value_t >
        explicit dictionary(std::initializer_list < key_value_pair < init_key_t, init_value_t>> init, size_type bucket_count = 0, const hasher_t& hash = hasher_t {}, const equator_t& equal = equator_t {}, const allocator_type& alloc = allocator_type {}) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
            (*this)[key] = value;
          }
        }

        template < class init_key_t, class init_value_t >
        dictionary(std::initializer_list < key_value_pair < init_key_t, init_value_t>> init, size_type bucket_count, const allocator_type & alloc) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
            (*this)[key] = value;
          }
        }

        template < class init_key_t, class init_value_t >
        dictionary(std::initializer_list < key_value_pair < init_key_t, init_value_t>> init, size_type bucket_count, const hasher_t& hash, const allocator_type & alloc) : data_(xtd::new_ptr < data > (bucket_count)) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
            (*this)[key] = value;
          }
        }

        
        
        const_iterator begin() const noexcept override {return ienumerable < value_type >::begin();}
        iterator begin() noexcept override {return ienumerable < value_type >::begin();}
        
        size_type bucket_count() const noexcept {return data_->items.bucket_count();}
        
        size_type capacity() const noexcept {return bucket_count();}
        
        const_iterator cbegin() const noexcept override {return ienumerable < value_type >::cbegin();}
        
        const_iterator cend() const noexcept override {return ienumerable < value_type >::cend();}
        
        const iequality_comparer < key_t > & comparer() const noexcept {
          if (data_->comparer) return *data_->comparer;
          return equality_comparer < key_t >::default_equality_comparer();
        }
        
        size_type count() const noexcept override {return data_->items.size();}
        
        bool empty() const noexcept {return data_->items.empty();}
        
        const_iterator end() const noexcept override {return ienumerable < value_type >::cend();}
        
        iterator end() noexcept override {return ienumerable < value_type >::end();}
        
        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;}
        
        key_collection keys() const noexcept override {
          auto keys = key_collection {};
          for (const auto& [key, value] : data_->items)
            keys.add(key);
          return keys;
        }
        
        float load_factor() const {return data_->items.load_factor();}
        
        size_type max_bucket_count() const noexcept {return data_->items.max_bucket_count();}
        
        float max_load_factor() const {return data_->items.max_load_factor();}
        void max_load_factor(float value) const {data_->items.max_load_factor(value);}
        
        size_type max_size() const noexcept {return data_->items.max_size();}
        
        size_type size() const noexcept {return data_->items.size();}
        
        const xtd::object & sync_root() const noexcept override {return data_->sync_root;}
        
        value_collection values() const noexcept override {
          auto values = value_collection {};
          for (const auto& [key, value] : data_->items)
            values.add(value);
          return values;
        }

        
        
        void add(const key_t & key, const value_t value) override {
          if (!try_add(key, value)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
        }
        
        void add(const value_type & item) override {
          add(item.key(), item.value());
        }
        
        
        const value_t& at(const key_t & key) const {
          auto iterator = data_->items.find(key);
          if (iterator == data_->items.end()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::key_not_found);
          return iterator->second;
        }
        
        value_t& at(const key_t & key) {
          auto iterator = data_->items.find(key);
          if (iterator == data_->items.end()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::key_not_found);
          return iterator->second;
        }
        
        local_iterator begin(size_type n) {
          return data_->items.begin(n);
        }
        
        const_local_iterator begin(size_type n) const {
          return data_->items.begin(n);
        }
        
        size_type bucket(const key_t & key) const {return data_->items.bucket(key);}
        
        size_type bucket_size(size_type n) const noexcept {return data_->items.bucket_size(n);}
        
        const_local_iterator cbegin(size_type n) const {
          return data_->items.begin(n);
        }
        
        const_local_iterator cend(size_type n) const {
          return data_->items.end(n);
        }
        
        void clear() noexcept override {
          data_->items.clear();
          ++data_->version;
        }
        
        bool contains(const key_t & key) const noexcept {
          return data_->items.find(key) != data_->items.end();
        }
        
        template < class contains_key_t >
        bool contains(const contains_key_t& x) const {
          return data_->items.find(x) != data_->items.end();
        }
        
        bool contains(const value_type & item) const noexcept override {
          auto iterator = find(item.key());
          if (iterator == end()) return false;
          return iterator->value() == item.value();
        }
        
        bool contains_key(const key_t & key) const noexcept override {
          return contains(key);
        }
        
        bool contains_value(const value_t& value) const noexcept {
          for (const auto& [item_key, item_value] : *this)
            if (item_value == value) return true;
          return false;
        }
        
        void copy_to(xtd::array < value_type > & array, xtd::size array_index) const override {
          if (array_index + count() > array.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);;
          auto index = size_type {0};
          for (const auto& item : *this)
            array[array_index + index++] = item;
        }
        
        template < class ...args_t >
        key_value_pair < iterator, bool > emplace(args_t&& ...args) {
          const auto& [iterator, succeeded] = data_->items.emplace(std::forward < args_t > (args)...);
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }
        
        template < class ...args_t >
        iterator emplace_hint(iterator hint, args_t&& ...args) {
          ++data_->version;
          return to_type_iterator(data_->items.emplace_hint(to_base_type_iterator(hint), std::forward < args_t > (args)...));
        }
        
        local_iterator end(size_type n) {
          return data_->items.end(n);
        }
        
        const_local_iterator end(size_type n) const {
          return data_->items.end(n);
        }
        
        xtd::size ensure_capacity(xtd::size capacity) noexcept {
          data_->items.reserve(capacity);
          return this->capacity();
        }
        
        key_value_pair < iterator, iterator > equal_range(const key_t & key) {
          const auto& [first, last] = data_->items.equal_range(key);
          return {to_type_iterator(first), to_type_iterator(last)};
        }
        
        template < class equal_range_key_t >
        key_value_pair < const_iterator, const_iterator > equal_range(const equal_range_key_t& key) const {
          const auto& [first, last] = data_->items.equal_range(key);
          return {to_const_type_iterator(first), to_const_type_iterator(last)};
        }
        
        template < class equal_range_key_t >
        key_value_pair < iterator, iterator > equal_range(const equal_range_key_t& x) {
          const auto& [first, last] = data_->items.equal_range(x);
          return {to_type_iterator(first), to_type_iterator(last)};
        }
        
        key_value_pair < const_iterator, const_iterator > equal_range(const key_t & x) const {
          const auto& [first, last] = data_->items.equal_range(x);
          return {to_const_type_iterator(first), to_const_type_iterator(last)};
        }
        
        iterator erase(const_iterator pos) {
          ++data_->version;
          return to_type_iterator(data_->items.erase(to_const_base_type_iterator(pos)));
        }

        iterator erase(const_iterator first, const_iterator last) {
          ++data_->version;
          return to_type_iterator(data_->items.erase(to_const_base_type_iterator(first), to_const_base_type_iterator(last)));
        }

        size_type erase(const key_t & key) {
          auto removed_count = data_->items.erase(key);
          if (removed_count) ++data_->version;
          return removed_count;
        }
        
        node_type extract(const_iterator position) noexcept {
          ++data_->version;
          return data_->items.extract(to_const_base_type_iterator(position));
        }

        node_type extract(const key_t k) {
          ++data_->version;
          return data_->items.extract(k);
        }
        
        const_iterator find(const key_t & key) const {
          return to_const_type_iterator(data_->items.find(key));
        }
        
        iterator find(const key_t & key) {
          return to_type_iterator(data_->items.find(key));
        }
        
        template < class find_key_t >
        const_iterator find(const find_key_t& x) const {
          return to_const_type_iterator(data_->items.find(x));
        }
        
        template < class find_key_t >
        iterator find(const find_key_t& x) {
          return to_type_iterator(data_->items.find(x));
        }
        
        allocator_type get_allocator() const noexcept {return data_->items.get_allocator();}
        
        enumerator < value_type > get_enumerator() const noexcept override {
          struct internal_enumerator : public ienumerator < value_type > {
          public:
            explicit internal_enumerator(const dictionary & items, size_type version) : items_(items), version_(version) {}
            
            const value_type & 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 (iterator_ != items_.items().cend()) {
                static thread_local auto value = value_type {};
                value = value_type {*iterator_};
                return value;
              }
              static auto default_value_type = value_type {};
              return default_value_type;
            }
            
            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.");
              if (!reset_) return ++iterator_ != items_.items().cend();
              reset_ = false;
              iterator_ = items_.items().cbegin();
              return iterator_ != items_.items().cend();
            }
            
            void reset() override {
              reset_ = true;
              version_ = items_.data_->version;
              iterator_ = items_.items().cend();
            }
            
protected:
            bool reset_ = true;
            const dictionary& items_;
            typename dictionary::base_type::const_iterator iterator_ = items_.items().cend();
            size_type version_ = 0;
          };
          return {new_ptr < internal_enumerator > (*this, data_->version)};
        }
        
        hasher hash_function() const {
          return data_->items.hash_function();
        }
        
        key_value_pair < iterator, bool > insert(const value_type & value) {
          const auto& [iterator, succeeded] = data_->items.insert(value);
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }

        key_value_pair < iterator, bool > insert(value_type&& value) {
          const auto& [iterator, succeeded] = data_->items.insert(value);
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }

        template < class type_t >
        key_value_pair < iterator, bool > insert(type_t&& value) {
          const auto& [iterator, succeeded] = data_->items.insert(value);
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }

        iterator insert(const_iterator hint, const value_type & value) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_const_base_type_iterator(hint), value));
        }

        iterator insert(const_iterator hint, value_type&& value) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_const_base_type_iterator(hint), value));
        }

        template < class type_t >
        iterator insert(const_iterator hint, type_t&& value) {
          ++data_->version;
          return to_type_iterator(data_->items.insert(to_const_base_type_iterator(hint), value));
        }

        template < class input_iterator_t >
        void insert(input_iterator_t first, input_iterator_t last) {
          for (auto iterator = first; iterator != last; ++iterator) {
            const auto& [key, value] = *iterator;
            add(key, value);
          }
        }

        void insert(std::initializer_list < base_value_type > ilist) {
          for (const auto& [key, value] : ilist)
            add(std::forward < value_type > ({key, value}));
        }

        template < class init_key_t, class init_value_t >
        void insert(std::initializer_list < key_value_pair < init_key_t, init_value_t>> ilist) {
          for (const auto& [key, value] : ilist)
            add(std::forward < value_type > ({key, value}));
        }

        insert_return_type insert(node_type&& nh) {
          ++data_->version;
          return data_->items.inser(nh);
        }

        iterator insert(const_iterator hint, node_type&& nh) {
          ++data_->version;
          return to_type_iterator(data_->items.inser(to_const_base_type_iterator(hint), nh));
        }
        
        template < class type_t >
        key_value_pair < iterator, bool > insert_or_assign(const key_t & k, type_t&& obj) {
          const auto& [iterator, succeeded] = data_->items.insert_or_assign(k, obj);
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }

        template < class type_t >
        key_value_pair < iterator, bool > insert_or_assign(key_t&& k, type_t&& obj) {
          const auto& [iterator, succeeded] = data_->items.insert_or_assign(std::move(k), obj);
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }

        template < class type_t >
        iterator insert_or_assign(const_iterator hint, const key_t & k, type_t&& obj) {
          ++data_->version;
          return to_type_iterator(data_->items.insert_or_assign(to_const_base_type_iterator(hint), k, obj));
        }

        template < class type_t >
        iterator insert_or_assign(const_iterator hint, key_t&& k, type_t&& obj) {
          ++data_->version;
          return to_type_iterator(data_->items.insert_or_assign(to_const_base_type_iterator(hint), std::move(k), obj));
        }
        
        key_equal key_eq() const {
          return data_->items.key_eq();
        }
        
        template < class source_hasher_t, class source_equator_t >
        void merge(dictionary < key_t, value_t, source_hasher_t, source_equator_t, allocator_t > & source) {
          data_->items.merge(source.items);
          ++data_->version;
        }
        
        template < class source_hasher_t, class source_equator_t >
        void merge(dictionary < key_t, value_t, source_hasher_t, source_equator_t, allocator_t > && source) {
          data_->items.merge(std::move(source.items));
          ++data_->version;
        }
        
        template < class source_hasher_t, class source_equator_t >
        void merge(std::unordered_map < key_t, value_t, source_hasher_t, source_equator_t, allocator_t > & source) {
          data_->items.merge(source);
          ++data_->version;
        }
        
        template < class source_hasher_t, class source_equator_t >
        void merge(std::unordered_map < key_t, value_t, source_hasher_t, source_equator_t, allocator_t > && source) {
          data_->items.merge(std::move(source));
          ++data_->version;
        }
        
        template < class source_hasher_t, class source_equator_t >
        void merge(std::unordered_multimap < key_t, value_t, source_hasher_t, source_equator_t, allocator_t > & source) {
          data_->items.merge(source);
          ++data_->version;
        }
        
        template < class source_hasher_t, class source_equator_t >
        void merge(std::unordered_multimap < key_t, value_t, source_hasher_t, source_equator_t, allocator_t > && source) {
          data_->items.merge(std::move(source));
          ++data_->version;
        }
        
        void rehash(size_type count) {
          data_->items.rehash(count);
        }
        
        bool remove(const key_t & key) noexcept override {
          return erase(key) == 1;
        }
        
        bool remove(const value_type & item) noexcept override {
          if (!contains_value(item.value())) return false;
          return erase(item.key()) == 1;
        }
        
        bool remove(const key_t & key, value_t& value) noexcept {
          auto iterator = find(key);
          if (iterator == end()) return false;
          value = iterator->value();
          return erase(iterator) != end();
        }
        
        void reserve(size_type count) {
          data_->items.reserve(count);
        }
        
        void swap(dictionary & other) noexcept {
          data_->items.swap(other.data_->items);
          std::swap(data_->version, other.data_->version);
        }
        
        xtd::string to_string() const noexcept override {return xtd::string::format("{{{}}}", xtd::string::join(", ", *this));}
        
        void trim_excess(size_type capacity) {
          if (capacity < count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);;
          rehash(capacity);
        }
        
        void trim_excess() {
          rehash(count());
        }
        
        bool try_add(const key_t & key, const value_t value) noexcept {
          const auto& [iterator, succeeded] = data_->items.insert(std::forward < base_value_type > ({key, value}));
          if (succeeded) ++data_->version;
          return succeeded;
        }
        
        template < class ...args_t >
        key_value_pair < iterator, bool > try_emplace(const key_t & k, args_t&&... args) {
          const auto& [iterator, succeeded] = to_type_iterator(data_->items.try_emplace(k, std::forward < args_t > (args)...));
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }

        template < class ...args_t >
        key_value_pair < iterator, bool > try_emplace(key_t&& k, args_t&&... args) {
          const auto& [iterator, succeeded] = to_type_iterator(data_->items.try_emplace(std::move(k), std::forward < args_t > (args)...));
          if (succeeded) ++data_->version;
          return {to_type_iterator(iterator), succeeded};
        }

        template < class ...args_t >
        iterator try_emplace(const_iterator hint, const key_t & k, args_t&&... args) {
          ++data_->version;
          return to_type_iterator(data_->items.try_emplace(to_const_base_type_iterator(hint), k, std::forward < args_t > (args)...));
        }

        template < class ...args_t >
        iterator try_emplace(const_iterator hint, key_t&& k, args_t&&... args) {
          ++data_->version;
          return to_type_iterator(data_->items.try_emplace(to_const_base_type_iterator(hint), std::move(k), std::forward < args_t > (args)...));
        }
        
        bool try_get_value(const key_t & key, value_t& value) const override {
          auto iterator = find(key);
          if (iterator != end()) {
            value = iterator->value();
            return true;
          }
          value = value_t {};
          return false;
        }

        
        
        dictionary& operator =(dictionary&& other) noexcept {
          data_->comparer = std::move(other.data_->comparer);
          data_->items = std::move(other.data_->items);
          data_->version = std::move(other.data_->version);
          return *this;
        }

        dictionary& operator =(std::unordered_map < key_t, value_t > && other) noexcept {
          data_->items = std::move(other);
          ++data_->version;
          return *this;
        }

        dictionary& operator =(const dictionary & other) noexcept = default;
        dictionary& operator =(const std::unordered_map < key_t, value_t > & other) noexcept {
          data_->items.clear();
          for (const auto& [key, value] : other)
            add(key, value);
        }

        dictionary& operator =(std::initializer_list < base_value_type > ilist) {
          data_->items.clear();
          for (const auto& [key, value] : ilist)
            add(key, value);
        }

        template < class init_key_t, class init_value_t >
        dictionary& operator =(std::initializer_list < key_value_pair < init_key_t, init_value_t>> ilist) {
          data_->items.clear();
          for (const auto& [key, value] : ilist)
            add(key, value);
        }
        
        const value_t& operator [](const key_t & key) const override {return at(key);}
        value_t& operator [](const key_t & key) override {
          ++data_->version;
          return data_->items[key];}
          
        operator const base_type & () const noexcept {return data_->items;}
        operator base_type & () noexcept {return data_->items;}
        
      private:
        typename base_type::const_iterator to_const_base_type_iterator(const_iterator value) const noexcept {
          return idictionary < key_t, value_t >::to_const_iterator(value, *this, data_->items);
        }
        
        const_iterator to_const_type_iterator(typename base_type::const_iterator value) const noexcept {
          return idictionary < key_t, value_t >::to_const_iterator(value, data_->items, *this);
        }
        
        typename base_type::const_iterator to_base_type_iterator(const_iterator value) const noexcept {
          return idictionary < key_t, value_t >::to_iterator(value, *this, data_->items);
        }
        
        typename base_type::iterator to_base_type_iterator(iterator value) noexcept {
          return idictionary < key_t, value_t >::to_iterator(value, *this, data_->items);
        }
        
        const_iterator to_type_iterator(typename base_type::const_iterator value) const noexcept {
          return idictionary < key_t, value_t >::to_iterator(value, data_->items, *this);
        }
        
        iterator to_type_iterator(typename base_type::iterator value) noexcept {
          return idictionary < key_t, value_t >::to_iterator(value, data_->items, *this);
        }
        
        struct data {
          data() : items {size_type {}, hasher {}, equator {}, allocator_type {}} {}
          data(ptr < iequality_comparer < key_t>> comparer) : comparer {comparer},  items {size_type {}, hasher {comparer.get()}, equator {comparer.get()}, allocator_type {}} {}
          data(size_type bucket_count) noexcept : items {bucket_count, hasher {}, equator {}, allocator_type {}} {}
          data(ptr < iequality_comparer < key_t>> comparer, const base_type & items, size_type version) noexcept : comparer {comparer}, items {size_type {}, hasher {comparer.get()}, equator {comparer.get()}, allocator_type {}}, version {version} {
            for (const auto& item : items)
              this->items.insert(item);
          }
          data(base_type&& items, size_type version) noexcept : items {size_type {}, hasher {}, equator {}, allocator_type {}}, version {version} {
            for (auto&& item : items)
              this->items.insert(item);
          }
          
          ptr < iequality_comparer < key_t>> comparer;
          base_type items;
          size_type version = 0;
          xtd::object sync_root;
        };
        xtd::ptr < data > data_ = xtd::new_ptr < data > ();
      };
      
      // C++17 deduction guides for xtd::collections::generic::dictionary
      // {
      template < class key_t, class value_t >
      dictionary(idictionary < key_t, value_t >) -> dictionary < key_t, value_t, helpers::hasher<key_t>, helpers::equator<key_t>, helpers::allocator < std::pair < const key_t, value_t >>>;
      
      template < class key_t, class value_t >
      dictionary(ienumerable < key_value_pair < key_t, value_t>>) -> dictionary<key_t, value_t, helpers::hasher<key_t>, helpers::equator<key_t >, helpers::allocator < std::pair < const key_t, value_t >>>;
      
      template < class key_t, class value_t, class hasher_t = helpers::hasher < key_t>, class equator_t = helpers::equator<key_t>, class allocator_t = helpers::allocator<std::pair < const key_t, value_t >>>
      dictionary(std::initializer_list < key_value_pair < key_t, value_t>>, xtd::size = 0, hasher_t = hasher_t {}, equator_t = equator_t {}, allocator_t = allocator_t {}) -> dictionary < key_t, value_t, hasher_t, equator_t, allocator_t >;
      
      template < class key_t, class value_t, class allocator_t >
      dictionary(std::initializer_list < key_value_pair < key_t, value_t>>, xtd::size, allocator_t) -> dictionary<key_t, value_t, helpers::hasher<key_t >, helpers::equator < key_t >, allocator_t >;
      
      template < class key_t, class value_t, class allocator_t >
      dictionary(std::initializer_list < key_value_pair < key_t, value_t>>, allocator_t) -> dictionary<key_t, value_t, helpers::hasher<key_t >, helpers::equator < key_t >, allocator_t >;
      
      template < class key_t, class value_t, class hasher_t, class allocator_t >
      dictionary(std::initializer_list < key_value_pair < key_t, value_t>>, xtd::size, hasher_t, allocator_t) -> dictionary<key_t, value_t, hasher_t, helpers::equator < key_t >, allocator_t >;
      
      template < class key_t, class value_t, class hasher_t = helpers::hasher < key_t>, class equator_t = helpers::equator<key_t>, class allocator_t = helpers::allocator<std::pair < const key_t, value_t >>>
      dictionary(std::initializer_list < std::pair < key_t, value_t>>, xtd::size bucket_count = 0, hasher_t = hasher_t {}, equator_t = equator_t {}, allocator_t = allocator_t {}) -> dictionary < key_t, value_t, hasher_t, equator_t, allocator_t >;
      
      template < class key_t, class value_t, class allocator_t >
      dictionary(std::initializer_list < std::pair < key_t, value_t>>, xtd::size, allocator_t) -> dictionary<key_t, value_t, helpers::hasher<key_t >, helpers::equator < key_t >, allocator_t >;
      
      template < class key_t, class value_t, class allocator_t >
      dictionary(std::initializer_list < std::pair < key_t, value_t>>, allocator_t) -> dictionary<key_t, value_t, helpers::hasher<key_t >, helpers::equator < key_t >, allocator_t >;
      
      template < class key_t, class value_t, class hasher_t, class allocator_t >
      dictionary(std::initializer_list < std::pair < key_t, value_t>>, xtd::size, hasher_t, allocator_t) -> dictionary<key_t, value_t, hasher_t, helpers::equator < key_t >, allocator_t >;
      
      template < class input_iterator_t, class hasher_t = helpers::hasher < helpers::iterator_key_t<input_iterator_t>>, class equator_t = helpers::equator<helpers::iterator_key_t<input_iterator_t>>, class allocator_t = helpers::allocator < helpers::iterator_to_allocator_t < input_iterator_t >>>
      dictionary(input_iterator_t, input_iterator_t, xtd::size = 0, hasher_t = hasher_t {}, equator_t = equator_t {}, allocator_t = allocator_t {}) -> dictionary < helpers::iterator_key_t < input_iterator_t>, helpers::iterator_mapped_t<input_iterator_t >, hasher_t, equator_t, allocator_t >;
      
      template < class input_iterator_t, class allocator_t >
      dictionary(input_iterator_t, input_iterator_t, xtd::size, allocator_t) -> dictionary < helpers::iterator_key_t < input_iterator_t>, helpers::iterator_mapped_t<input_iterator_t>, helpers::hasher<helpers::iterator_key_t<input_iterator_t>>, helpers::equator < helpers::iterator_key_t < input_iterator_t >>, allocator_t >;
      
      template < class input_iterator_t, class allocator_t >
      dictionary(input_iterator_t, input_iterator_t, allocator_t) -> dictionary < helpers::iterator_key_t < input_iterator_t>, helpers::iterator_mapped_t<input_iterator_t>, helpers::hasher<helpers::iterator_key_t<input_iterator_t>>, helpers::equator < helpers::iterator_key_t < input_iterator_t >>, allocator_t >;
      
      template < class input_iterator_t, class hasher_t, class allocator_t >
      dictionary(input_iterator_t, input_iterator_t, xtd::size, hasher_t, allocator_t) -> dictionary < helpers::iterator_key_t < input_iterator_t>, helpers::iterator_mapped_t<input_iterator_t>, hasher_t, helpers::equator<helpers::iterator_key_t < input_iterator_t >>, allocator_t >;
      // }
    }
  }
}