ordered_dictionary.hpp

Go to the documentation of this file.

#pragma once
#include "dictionary.hpp"
#include "list.hpp"
#include "helpers/iterator.hpp"
#include "../../threading/lock.hpp"

namespace xtd {
  namespace collections {
    namespace generic {
      template<typename key_t, typename value_t, typename allocator_t = xtd::collections::generic::helpers::allocator<std::pair<const key_t, value_t>>>
      class ordered_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::usize;
        using base_value_type = xtd::collections::generic::key_value_pair<key_type, mapped_type>;
        using base_type = xtd::collections::generic::dictionary<key_type, mapped_type>;
        using list_type = xtd::collections::generic::list<key_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;
        
        
        ordered_dictionary() noexcept = default;
        ordered_dictionary(const xtd::collections::generic::idictionary<key_t, value_t>& dictionary) {
          data_->items = dictionary;
          data_->keys.capacity(dictionary.count());
          for (const auto& item : dictionary)
            data_->keys.add(item.first);
        }

        ordered_dictionary(const xtd::collections::generic::idictionary<key_t, value_t>& dictionary, const xtd::collections::generic::iequality_comparer<key_type>& comparer) {
          data_->items = base_type(dictionary, comparer);
          data_->keys.capacity(dictionary.count());
          for (const auto& item : dictionary)
            data_->keys.add(item.first);
        }

        ordered_dictionary(const xtd::collections::generic::ienumerable < value_type >& collection) {
          for (const auto& item : collection)
            add(item);
        }

        template<xtd::iterable iterable_t>
        ordered_dictionary(iterable_t&& items) {
          for (const auto& [key, value] : items)
            add({key, value});
        }

        ordered_dictionary(const xtd::collections::generic::ienumerable < value_type >& collection, const xtd::collections::generic::iequality_comparer<key_type>& comparer) {
          data_->items = base_type(comparer);
          for (const auto& item : collection)
            add(item);
        }

        ordered_dictionary(xtd::usize capacity) {
          data_->keys.capacity(capacity);
          data_->items.ensure_capacity(capacity);
        }

        ordered_dictionary(xtd::usize capacity, const xtd::collections::generic::iequality_comparer<key_type>& comparer) {
          data_->items = base_type(capacity, comparer);
          data_->keys.capacity(capacity);
        }

        ordered_dictionary(const xtd::collections::generic::iequality_comparer<key_type>& comparer) {
          data_->items = base_type(comparer);
        }

        template < class input_iterator_t >
        explicit ordered_dictionary(input_iterator_t first, input_iterator_t last) {
          for (auto iterator = first; iterator != last; ++iterator)
            add(*iterator);
        }

        ordered_dictionary(const ordered_dictionary & other) noexcept : data_(xtd::new_ptr<dictionary_data>(other.data_->items, other.data_->version)) {}
        ordered_dictionary(ordered_dictionary&& other) noexcept = default;
        ordered_dictionary(std::initializer_list<base_value_type> init) {
          for (const auto& [key, value] : init)
            add(key, value);
        }
        template < class init_key_t, typename init_value_t >
        explicit ordered_dictionary(std::initializer_list<key_value_pair<init_key_t, init_value_t>> init) {
          for (const auto& [key, value] : init)
            add(key, value);
        }

        
        
        [[nodiscard]] auto count() const noexcept -> size_type override {return data_->items.count();}
        
        [[nodiscard]] auto comparer() const noexcept -> const iequality_comparer < key_t >& {
          return data_->items.comparer();
        }
        
        [[nodiscard]] virtual auto items() const noexcept -> const base_type& {return data_->items;}
        [[nodiscard]] virtual auto items() noexcept -> base_type& {return data_->items;}
        
        [[nodiscard]] auto keys() const noexcept -> key_collection override {
          auto keys = key_collection {};
          for (const auto& key : data_->keys)
            keys.add(key);
          return keys;
        }
        
        [[nodiscard]] auto values() const noexcept -> value_collection override {
          auto values = value_collection {};
          for (const auto& key : data_->keys)
            values.add(data_->items[key]);
          return values;
        }

        
        
        auto add(const key_t & key, const value_t& value) -> void override {
          insert(count(), key, value);
        }
        
        auto add(const value_type & item) -> void override {
          insert(count(), item.key(), item.value());
        }
        
        auto clear() noexcept -> void override {
          lock_(data_->sync_op) {
            data_->keys.clear();
            data_->items.clear();
          }
          ++data_->version;
        }
        
        [[nodiscard]] auto contains(const value_type & item) const noexcept -> bool override {
          return data_->items.contains(item);
        }
        
        [[nodiscard]] auto contains_key(const key_t & key) const noexcept -> bool override {
          return data_->items.contains_key(key);
        }
        
        [[nodiscard]] auto contains_value(const value_t& value) const noexcept -> bool {
          return data_->items.contains_value(value);
        }
        
        auto copy_to(xtd::array<value_type>& array, xtd::usize 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;
        }
        
        [[nodiscard]] xtd::collections::generic::enumerator<value_type> get_enumerator() const noexcept override {
          struct ordered_dictionary_enumerator : public ienumerator<value_type> {
            explicit ordered_dictionary_enumerator(const ordered_dictionary & items, xtd::usize version) : items_(items), version_(version) {}
            
            [[nodiscard]] const value_type& current() const override {
              if (index_ >= items_.count()) 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 {key_t {items_.data_->keys[index_]}, value_t {items_.data_->items[items_.data_->keys[index_]]}});
            }
            
            [[nodiscard]] 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_.data_->keys.count();
            }
            
            void reset() override {
              version_ = items_.data_->version;
              index_ = xtd::npos;
            }
            
          private:
            size_type index_ = xtd::npos;
            const ordered_dictionary& items_;
            mutable value_type value_;
            size_type version_ = 0;
          };
          
          return {new_ptr<ordered_dictionary_enumerator>(self_, data_->version)};
        }
        
        auto insert(xtd::usize index, const key_t & key) -> void {insert(index, key, value_t {});}
        
        auto insert(xtd::usize index, const key_t & key, const value_t& value) -> void {
          if (contains_key(key)) return xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
          lock_(data_->sync_op) {
            data_->items.add(key, value);
            data_->keys.insert(index, key);
          }
          ++data_->version;
        }
        
        auto remove(const key_t & key) noexcept -> bool override {
          if (!contains_key(key)) return false;
          lock_(data_->sync_op) {
            remove_at(get_index(key));
          }
          ++data_->version;
          return true;
        }
        
        auto remove(const value_type & item) noexcept -> bool override {
          lock_(data_->sync_op) {
            auto result = data_->items.remove(item.first);
            if (!result) return false;
            data_->keys.remove_at(get_index(item.first));
          }
          ++data_->version;
          return true;
        }
        
        auto remove_at(xtd::usize index) -> void {
          lock_(data_->sync_op) {
            data_->items.remove(data_->keys[index]);
            data_->keys.remove_at(index);
          }
          ++data_->version;
        }
        
        [[nodiscard]] auto to_string() const noexcept -> xtd::string override {return xtd::string::format("{{{}}}", xtd::string::join(", ", self_));}
        
        [[nodiscard]] auto try_get_value(const key_t & key, value_t& value) const -> bool override {
          return data_->items.try_get_value(key, value);
        }

        
        
        auto operator =(ordered_dictionary&& other) noexcept -> ordered_dictionary& = default;
        auto operator =(const ordered_dictionary & other) noexcept -> ordered_dictionary& {
          *data_ = *other.data_;
          return self_;
        }

        auto operator =(std::initializer_list<base_value_type> ilist) -> ordered_dictionary& {
          clear();
          for (const auto& [key, value] : ilist)
            add(key, value);
          return self_;
        }

        template < class init_key_t, typename init_value_t >
        auto operator =(std::initializer_list<key_value_pair<init_key_t, init_value_t>> ilist) -> ordered_dictionary& {
          clear();
          for (const auto& [key, value] : ilist)
            add(key, value);
          return self_;
        }
        
        auto operator()(xtd::usize index) const -> const value_t& {return operator [](data_->keys[index]);}
        auto operator()(xtd::usize index) -> value_t& {return operator [](data_->keys[index]);}
        
        const value_t& operator [](const key_t & key) const override {return data_->items[key];}
        value_t& operator [](const key_t & key) override {
          auto iterator = data_->items.items().find(key);
          if (iterator != data_->items.items().end())
            return iterator->second;
          data_->keys.add(key);
          return data_->items[key];
        }
        
        operator const base_type& () const noexcept {return data_->items;}
        operator base_type& () noexcept {return data_->items;}
        
      private:
        auto get_index(const key_t & key) const noexcept -> xtd::usize {
          auto index = xtd::usize {0};
          for (const auto& item_key : data_->keys) {
            if (item_key == key) return index;
            ++index;
          }
          return xtd::npos;
        }
        
        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() noexcept = default;
          dictionary_data(const base_type & items, size_type version) noexcept : items {items}, version {version} {
            for (const auto& item : this->items)
              keys.add(item.first);
          }
          dictionary_data(base_type&& items, size_type version) noexcept : items {items}, version {version} {
            for (const auto& item : this->items)
              keys.add(item.first);
          }
          
          list_type keys;
          base_type items;
          size_type version = 0;
          xtd::object sync_root;
          xtd::object sync_op;
        };
        xtd::ptr < dictionary_data > data_ = xtd::new_ptr < dictionary_data > ();
      };
      
      // Deduction guides for xtd::collections::specialized::ordered_dictionary
      // {
      template < class key_t, typename value_t >
      ordered_dictionary(xtd::collections::generic::idictionary < key_t, value_t >) -> ordered_dictionary < key_t, value_t>;
      
      template < class key_t, typename value_t >
      ordered_dictionary(xtd::collections::generic::ienumerable < key_value_pair < key_t, value_t>>) -> ordered_dictionary<key_t, value_t>;
      
      template<xtd::iterable iterable_t>
      ordered_dictionary(iterable_t&&) -> ordered_dictionary<std::remove_const_t<std::tuple_element_t<0, xtd::iterable_value_type<iterable_t>>>, std::remove_const_t<std::tuple_element_t<1, xtd::iterable_value_type<iterable_t>>>>;
 
      template < class key_t, typename value_t >
      ordered_dictionary(std::initializer_list < key_value_pair < key_t, value_t>>) -> ordered_dictionary < key_t, value_t >;
      
      template < class key_t, typename value_t >
      ordered_dictionary(std::initializer_list < std::pair < key_t, value_t>>) -> ordered_dictionary < key_t, value_t >;
      
      template < class input_iterator_t >
      ordered_dictionary(input_iterator_t, input_iterator_t) -> ordered_dictionary < xtd::collections::generic::helpers::iterator_key_t < input_iterator_t>, xtd::collections::generic::helpers::iterator_mapped_t<input_iterator_t >>;
      // }
    }
  }
}