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:
        
        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 base_value_type = std::pair < const key_t, value_t >;
        using base_type = std::unordered_map < key_type, mapped_type, hasher_t, equator_t, allocator_t >;
        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;
        using equator = equator_t;
        using hasher = hasher_t;
        
        
        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);
        }

        dictionary(const xtd::collections::generic::iequality_comparer<key_type>& comparer) : data_(xtd::new_ptr < dictionary_data > (comparer)) {}
        dictionary(size_t capacity) {
          ensure_capacity(capacity);
        }

        dictionary(size_t capacity, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : data_(xtd::new_ptr < dictionary_data > (comparer)) {
          ensure_capacity(capacity);
        }

        dictionary(const idictionary < key_t, value_t >& dictionary, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : data_(xtd::new_ptr < dictionary_data>(comparer)) {
          ensure_capacity(dictionary.count());
          for (const auto& item : dictionary)
            add(item);
        }

        dictionary(const ienumerable < value_type >& collection, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : data_(xtd::new_ptr < dictionary_data>(comparer)) {
          for (const auto& item : collection)
            add(item);
        }

        dictionary(dictionary&& other) noexcept = default;
        dictionary(const dictionary & other) noexcept : data_(xtd::new_ptr < dictionary_data > (*other.data_->comparer, other.data_->items, other.data_->version)) {}
        dictionary(std::unordered_map < key_t, value_t > && other) noexcept : data_(xtd::new_ptr < dictionary_data>(std::move(other))) {}
        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(std::initializer_list < base_value_type > init) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
            self_[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) {
          for (const auto& [key, value] : init) {
            if (contains_key(key)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
            self_[key] = value;
          }
        }

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

        
        
        auto capacity() const noexcept -> size_type {return items().bucket_count();}
        
        auto comparer() const noexcept -> const iequality_comparer < key_t >& {
          if (!data_->comparer) return equality_comparer <key_type>::default_equality_comparer();
          return *data_->comparer;
        }
        
        auto count() const noexcept -> size_type override {return data_->items.size();}
        
        virtual auto items() const noexcept -> const base_type& {return data_->items;}
        virtual auto items() noexcept -> base_type& {return data_->items;}
        
        auto keys() const noexcept -> key_collection override {
          auto keys = key_collection {};
          for (const auto& [key, value] : data_->items)
            keys.add(key);
          return keys;
        }
        
        auto values() const noexcept -> value_collection override {
          auto values = value_collection {};
          for (const auto& [key, value] : data_->items)
            values.add(value);
          return values;
        }

        
        
        auto add(const key_t & key, const value_t& value) -> void override {
          if (!try_add(key, value)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
        }
        
        auto add(const value_type & item) -> void override {
          add(item.key(), item.value());
        }
        
        auto clear() noexcept -> void override {
          data_->items.clear();
          ++data_->version;
        }
        
        auto contains(const value_type & item) const noexcept -> bool override {
          auto iterator = items().find(item.key());
          if (iterator == items().end()) return false;
          return iterator->second == item.value();
        }
        
        auto contains_key(const key_t & key) const noexcept -> bool override {
          return data_->items.find(key) != data_->items.end();
        }
        
        auto contains_value(const value_t& value) const noexcept -> bool {
          for (const auto& [item_key, item_value] : self_)
            if (item_value == value) return true;
          return false;
        }
        
        auto copy_to(xtd::array < value_type >& array, xtd::size array_index) const -> void override {
          if (array_index + count() > array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
          for (const auto& item : self_)
            array[array_index++] = item;
        }
        
        auto ensure_capacity(xtd::size capacity) noexcept -> size_type {
          data_->items.reserve(capacity);
          return self_.capacity();
        }
        
        enumerator<value_type> get_enumerator() const noexcept override {
          struct dictionary_enumerator : public ienumerator < value_type > {
            explicit dictionary_enumerator(const dictionary & items, size_type version) : items_(items), version_(version) {}
            
            const value_type& current() const override {
              if (iterator_ == items_.items().cend()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
              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 (value_ = value_type {*iterator_});
            }
            
            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 (index_++ && iterator_ != items_.data_->items.cend()) ++iterator_;
              else iterator_ = items_.items().cbegin();
              return  iterator_ != items_.data_->items.cend();
            }
            
            void reset() override {
              index_ = 0;
              version_ = items_.data_->version;
              iterator_ = items_.items().cend();
            }
            
          private:
            size_type index_ = 0;
            const dictionary& items_;
            typename dictionary::base_type::const_iterator iterator_ = items_.data_->items.cend();
            mutable value_type value_;
            size_type version_ = 0;
          };
          return {new_ptr < dictionary_enumerator > (self_, data_->version)};
        }
        
        auto remove(const key_t & key) noexcept -> bool override {
          return items().erase(key) == 1;
        }
        
        auto remove(const value_type & item) noexcept -> bool override {
          if (!contains_value(item.value())) return false;
          return items().erase(item.key()) == 1;
        }
        
        auto remove(const key_t & key, value_t& value) noexcept -> bool {
          auto iterator = items().find(key);
          if (iterator == items().end()) return false;
          value = iterator->value();
          return items().erase(iterator) != items().end();
        }
        
        auto to_string() const noexcept -> xtd::string override {return xtd::string::format("{{{}}}", xtd::string::join(", ", self_));}
        
        auto trim_excess(size_type capacity) -> void {
          if (capacity < count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
          items().rehash(capacity);
        }
        
        auto trim_excess() -> void {
          rehash(count());
        }
        
        auto try_add(const key_t & key, const value_t value) noexcept -> bool {
          const auto& [iterator, succeeded] = data_->items.insert(std::forward < base_value_type > ({key, value}));
          if (succeeded) ++data_->version;
          return succeeded;
        }
        
        auto try_get_value(const key_t & key, value_t& value) const -> bool override {
          auto iterator = items().find(key);
          if (iterator != items().end()) {
            value = iterator->second;
            return true;
          }
          value = value_t {};
          return false;
        }

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

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

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

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

        template < class init_key_t, class init_value_t >
        auto operator =(std::initializer_list < key_value_pair < init_key_t, init_value_t>> ilist) -> dictionary& {
          data_->items.clear();
          for (const auto& [key, value] : ilist)
            add(key, value);
        }
        
        const value_t& operator [](const key_t & key) const override {
          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& 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;}
        operator std::unordered_map<key_t, value_t>() const noexcept {
          std::unordered_map<key_t, value_t> result;
          for (auto& [key, value] : data_->items)
            result[key] = value;
          return result;
        }

        
      private:
        auto is_read_only() const noexcept -> bool override {return false;}
        auto is_synchronized() const noexcept -> bool override {return false;}
        const xtd::object& sync_root() const noexcept override {return data_->sync_root;}
        
        struct dictionary_data {
          dictionary_data() = default;
          dictionary_data(const xtd::collections::generic::iequality_comparer<key_type>& comparer) : comparer {&comparer}, items {size_type {}, hasher_t {comparer}, equator_t {comparer}} {}
          dictionary_data(const xtd::collections::generic::iequality_comparer<key_type>& comparer, const base_type & items, size_type version) noexcept : comparer {&comparer}, items {size_type {}, hasher_t {comparer}, equator_t {comparer}}, version {version} {
            for (const auto& item : items)
              self_.items.insert(item);
          }
          dictionary_data(base_type&& items, size_type version) noexcept : version {version} {
            for (auto&& item : items)
              self_.items.insert(item);
          }
          
          const xtd::collections::generic::iequality_comparer<key_type>* comparer = null;
          base_type items;
          size_type version = 0;
          xtd::object sync_root;
        };
        xtd::ptr<dictionary_data> data_ = xtd::new_ptr<dictionary_data>();
      };
      
      // 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>;
      
      template < class key_t, class value_t >
      dictionary(ienumerable < key_value_pair < key_t, value_t>>) -> dictionary<key_t, value_t>;
      
      template < class key_t, class value_t >
      dictionary(std::initializer_list < key_value_pair < key_t, value_t>>) -> dictionary<key_t, value_t>;
      
      template < class key_t, class value_t >
      dictionary(std::initializer_list < std::pair < key_t, value_t>>) -> dictionary<key_t, value_t>;
      
      template < class input_iterator_t >
      dictionary(input_iterator_t, input_iterator_t) -> dictionary<helpers::iterator_key_t<input_iterator_t>, helpers::iterator_mapped_t<input_iterator_t>>;
      // }
    }
  }
}