concurrent_dictionary.hpp

Go to the documentation of this file.

#pragma once
#include "iproducer_consumer_collection.hpp"
#include "../generic/dictionary.hpp"
#include "../../threading/lock_guard.hpp"
#include "../../environment.hpp"
#include "../../object.hpp"

namespace xtd {
  namespace collections {
    namespace concurrent {
      template<typename key_t, typename value_t, typename hasher_t = xtd::collections::generic::helpers::hasher<key_t>, typename equator_t = xtd::collections::generic::helpers::equator<key_t>, typename allocator_t = xtd::collections::generic::helpers::allocator<std::pair<const key_t, value_t>>>
      class concurrent_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 reference = value_type&;
        using const_reference = const value_type&;
        using collection_type = xtd::collections::generic::dictionary<key_t, value_t, 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;
        
        
        concurrent_dictionary() = default;
        concurrent_dictionary(xtd::collections::generic::ienumerable<value_type>&& collection) {
          lock_guard_(items_)
          for (const auto& item : collection)
            items_.add(item);
        }

        concurrent_dictionary(xtd::iterable auto&& collection) {
          lock_guard_(items_)
          for (const auto& item : collection)
            items_add(item);
        }

        concurrent_dictionary(const xtd::collections::generic::iequality_comparer<key_type>& comparer) : items_ {comparer} {}
        concurrent_dictionary(xtd::collections::generic::ienumerable<value_type>&& collection, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : items_ {comparer} {
          lock_guard_(items_)
          for (const auto& item : collection)
            items_.add(item);
        }

        concurrent_dictionary(xtd::iterable auto&& collection, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : items_ {comparer} {
          lock_guard_(items_)
          for (const auto& item : collection)
            items_add(item);
        }

        concurrent_dictionary(xtd::usize concurrent_level, xtd::usize capacity) : items_ {capacity}, concurrent_level_ {concurrent_level} {}
        concurrent_dictionary(xtd::usize concurrent_level, xtd::collections::generic::ienumerable<value_type>&& collection, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : items_ {comparer} {
          lock_guard_(items_)
          for (const auto& item : collection)
            items_.add(item);
        }

        concurrent_dictionary(xtd::usize concurrent_level, xtd::iterable auto&& collection, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : items_ {comparer} {
          lock_guard_(items_)
          for (const auto& item : collection)
            items_add(item);
        }

        concurrent_dictionary(xtd::usize concurrent_level, xtd::usize capacity, const xtd::collections::generic::iequality_comparer<key_type>& comparer) : items_ {capacity, comparer}, concurrent_level_ {concurrent_level} {}
        concurrent_dictionary(std::initializer_list<std::pair<key_t, value_t>> items) {
          lock_guard_(items_) {
            items_.ensure_capacity(items.size());
            for (const auto& [key, value] : items)
              items_.add(key, value);
          }
        }

        concurrent_dictionary(std::initializer_list<value_type> items) {
          lock_guard_(items_) {
            items_.ensure_capacity(items.size());
            for (const auto& item : items)
              items_.add(item);
          }
        }

        
        
        [[nodiscard]] auto comparer() const noexcept -> const xtd::collections::generic::iequality_comparer<key_t>& {
          return items_.comparer();
        }

        [[nodiscard]] auto count() const noexcept -> xtd::usize override {
          lock_guard_(items_)
            return items_.count();
          xtd::environment::unreachable();
        }
        
        [[nodiscard]] auto is_empty() const noexcept -> bool {
          lock_guard_(items_)
            return items_.is_empty();
          xtd::environment::unreachable();
        }
        
        [[nodiscard]] auto is_read_only() const noexcept -> bool override {return false;}
        
        [[nodiscard]] auto is_synchronized() const noexcept -> bool override {return true;}
        
        auto keys() const noexcept -> key_collection override {
          lock_guard_(items_)
            return items_.keys();
          xtd::environment::unreachable();
        }
        
        auto values() const noexcept -> value_collection override {
          lock_guard_(items_)
            return items_.values();
          xtd::environment::unreachable();
        }

        
        
        auto add_or_update(const key_t& key, xtd::callable<value_t, key_t> auto&& add_value_factory, xtd::callable<value_t, key_t, value_t> auto&& update_value_factory) -> const value_t& {
          lock_guard_(items_) {
            if (!items_.contains_key(key)) items_.add(key, add_value_factory(key));
            else items_[key] = update_value_factory(key, items_[key]);
            return items_[key];
          }
          xtd::environment::unreachable();
        }

        auto add_or_update(const key_t& key, const value_t& add_value, xtd::callable<value_t, key_t, value_t> auto&& update_value_factory) -> const value_t& {
          lock_guard_(items_) {
            if (!items_.contains_key(key)) items_.add(key, add_value);
            else items_[key] = update_value_factory(key, items_[key]);
            return items_[key];
          }
          xtd::environment::unreachable();
        }

        template<typename arg_t>
        auto add_or_update(const key_t& key, xtd::callable<value_t, key_t, arg_t> auto&& add_value_factory, xtd::callable<value_t, key_t, value_t, arg_t> auto&& update_value_factory, arg_t&& factory_argument) -> const value_t& {
          lock_guard_(items_) {
            if (!items_.contains_key(key)) items_.add(key, add_value_factory(key, factory_argument));
            else items_[key] = update_value_factory(key, items_[key], factory_argument);
            return items_[key];
          }
          xtd::environment::unreachable();
        }

        auto clear() -> void override {
          lock_guard_(items_)
            items_.clear();
        }
        
        auto contains_key(const key_t& key) const noexcept -> bool override {
          lock_guard_(items_)
            return items_.contains_key(key);
          xtd::environment::unreachable();
        }
        
        auto copy_to(xtd::array<value_type>& array, xtd::usize array_index) const -> void override {
          lock_guard_(items_)
            items_.copy_to(array, array_index);
        }
        
        [[nodiscard]] auto get_enumerator() const -> xtd::collections::generic::enumerator<value_type> override {
          static thread_local auto items = xtd::array<value_type> {};
          items = to_array();
          return items.get_enumerator();
        }
        
        [[nodiscard]] auto get_or_add(const key_t& key, xtd::callable<value_t, key_t> auto&& add_value_factory) -> const value_t& {
          lock_guard_(items_) {
            if (!items_.contains_key(key)) items_.add(key, add_value_factory(key));
            return items_[key];
          }
          xtd::environment::unreachable();
        }

        [[nodiscard]] auto get_or_add(const key_t& key, const value_t& add_value) -> const value_t& {
          lock_guard_(items_) {
            if (!items_.contains_key(key)) items_.add(key, add_value);
            return items_[key];
          }
          xtd::environment::unreachable();
        }

        template<typename arg_t>
        [[nodiscard]] auto get_or_add(const key_t& key, xtd::callable<value_t, key_t, arg_t> auto&& add_value_factory, arg_t&& factory_argument) -> const value_t& {
          lock_guard_(items_) {
            if (!items_.contains_key(key)) items_.add(key, add_value_factory(key, factory_argument));
            return items_[key];
          }
          xtd::environment::unreachable();
        }

        [[nodiscard]] auto to_array() const -> xtd::array<value_type> {
          lock_guard_(items_)
            return items_.to_array();
          xtd::environment::unreachable();
        }
        
        [[nodiscard]] auto to_string() const noexcept -> xtd::string override {
          return to_array().to_string();
        }
        
        auto try_add(const key_t& key, const value_t& value) -> bool {
          lock_guard_(items_) {
            if (items_.contains_key(key)) return false;
            items_.add(key, value);
            return true;
          }
          xtd::environment::unreachable();
        }
        
        auto try_get_value(const key_t& key, value_t& value) const -> bool override {
          lock_guard_(items_)
            return items_.try_get_value(key, value);
          xtd::environment::unreachable();
        }

        auto try_remove(const key_t& key) -> bool {
          auto value = value_t {};
          return try_remove(key, value);
        }

        auto try_remove(const key_t& key, value_t& value) -> bool {
          lock_guard_(items_) {
            if (!items_.try_get_value(key, value)) return false;
            return items_.remove(key);
          }
          xtd::environment::unreachable();
        }

        auto try_remove(const xtd::collections::generic::key_value_pair<key_t, value_t>& item) -> bool {
          lock_guard_(items_) {
            if (!items_.contains(item)) return false;
            return items_.remove(item);
          }
          xtd::environment::unreachable();
        }
        
        auto try_update(const key_t& key, const value_t& new_value, const value_t& comparison_value) -> bool {
          lock_guard_(items_) {
            if (!items_.contains({key, comparison_value})) return false;
            items_[key] = new_value;
            return true;
          }
          xtd::environment::unreachable();
        }

        
        
        auto operator [](const key_t& key) const -> const value_t& override {
          lock_guard_(items_)
            return items_.operator [](key);
          xtd::environment::unreachable();
        }

        auto operator [](const key_t& key) -> value_t& override {
          lock_guard_(items_)
            return items_.operator [](key);
          xtd::environment::unreachable();
        }

        
      private:
        auto sync_root() const noexcept -> const xtd::object& override {return xtd::as<xtd::collections::generic::idictionary<key_t, value_t>>(items_).sync_root();}
        
        auto add(const xtd::collections::generic::key_value_pair<key_t, value_t>& item) -> void override {
          lock_guard_(items_)
            items_.add(item);
        }
        auto add(const key_t& key, const value_t& value) -> void override {
          lock_guard_(items_)
            items_.add(key, value);
        }
        
        auto contains(const xtd::collections::generic::key_value_pair<key_t, value_t>& item) const noexcept -> bool override {
          lock_guard_(items_)
            return items_.contains(item);
          xtd::environment::unreachable();
        }
 
        auto remove(const xtd::collections::generic::key_value_pair<key_t, value_t>& item) -> bool override {
          lock_guard_(items_)
            return items_.remove(item);
          xtd::environment::unreachable();
        }
        
        auto remove(const key_t& key) noexcept -> bool override {
          lock_guard_(items_)
            return items_.remove(key);
          xtd::environment::unreachable();
        }
        
        collection_type items_;
        xtd::usize concurrent_level_ = xtd::environment::processor_count();
      };
      
      // Deduction guides for xtd::collections::concurrent::concurrent_dictionary
      // {
      template<typename key_t, typename value_t >
      concurrent_dictionary(xtd::collections::generic::idictionary<key_t, value_t>) -> concurrent_dictionary<key_t, value_t>;
      
      template<typename key_t, typename value_t >
      concurrent_dictionary(xtd::collections::generic::ienumerable<xtd::collections::generic::key_value_pair<key_t, value_t>>) -> concurrent_dictionary<key_t, value_t>;
      
      template<xtd::iterable iterable_t>
      concurrent_dictionary(iterable_t&&) -> concurrent_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<typename key_t, typename value_t >
      concurrent_dictionary(std::initializer_list<xtd::collections::generic::key_value_pair<key_t, value_t>>) -> concurrent_dictionary<key_t, value_t>;
      
      template<typename key_t, typename value_t >
      concurrent_dictionary(std::initializer_list<std::pair<key_t, value_t>>) -> concurrent_dictionary<key_t, value_t>;
      
      template<typename input_iterator_t >
      concurrent_dictionary(input_iterator_t, input_iterator_t) -> concurrent_dictionary<xtd::collections::generic::helpers::iterator_key_t<input_iterator_t>, xtd::collections::generic::helpers::iterator_mapped_t<input_iterator_t>>;
      // }
    }
  }
}