hash_set.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/allocator.hpp"
#include "helpers/equator.hpp"
#include "helpers/hasher.hpp"
#include "iset.hpp"
#include <unordered_set>

namespace xtd {
  namespace collections {
    namespace generic {
      template<class type_t, class hasher_t = xtd::collections::generic::helpers::hasher<type_t>, class equator_t = xtd::collections::generic::helpers::equator<type_t>, class allocator_t = xtd::collections::generic::helpers::allocator<type_t >>
      class hash_set : public xtd::object, public xtd::collections::generic::iset<type_t> {
      public:
        
        using key_type = typename xtd::collections::generic::iset<type_t>::key_type;
        using value_type = typename xtd::collections::generic::iset <type_t>::value_type;
        using size_type = xtd::size;
        using base_type = std::unordered_set<key_type, hasher_t, equator_t, allocator_t>;
        
        
        hash_set() noexcept = default;
        hash_set(const xtd::collections::generic::iequality_comparer<key_type>& comparer) noexcept : data_(xtd::new_ptr<hash_set_data>(comparer)) {}
        hash_set(const ienumerable<value_type>& collection) noexcept {
          for (const auto& item : collection)
            add(item);
        }

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

        hash_set(size_type capacity) noexcept {
          ensure_capacity(capacity);
        }
        hash_set(hash_set&& other) noexcept = default;
        hash_set(const hash_set& other) noexcept : data_(xtd::new_ptr<hash_set_data>(other.data_->comparer, other.data_->items, other.data_->version)) {}
        hash_set(std::unordered_set<key_type>&& other) noexcept : data_(xtd::new_ptr<hash_set_data>(std::move(other))) {}
        hash_set(const std::unordered_set<key_type>& other) noexcept {
          for (auto iterator = other.begin(); iterator != other.end(); ++iterator)
            add(*iterator);
        }
        hash_set(std::initializer_list <value_type> init) {
          ensure_capacity(init.size());
          for (const auto& value : init)
            add(value);
        }
        template <class input_iterator_t>
        explicit hash_set(input_iterator_t first, input_iterator_t last) {
          for (auto iterator = first; iterator != last; ++iterator)
            add(*iterator);
        }
        
        
        auto capacity() const noexcept -> size_type {return items().bucket_count();}
        
        auto comparer() const noexcept -> const iequality_comparer<key_type>& {
          if (!data_->comparer) return equality_comparer <key_type>::default_equality_comparer();
          return *data_->comparer;
        }
        
        auto count() const noexcept -> size_type override {return items().size();}
        
        virtual auto items() const noexcept -> const base_type& {return data_->items;}
        virtual auto items() noexcept -> base_type& {return data_->items;}
        
        
        auto add(const key_type& item) noexcept -> bool override {
          if (contains(item)) return false;
          items().insert(item);
          ++data_->version;
          return true;
        }
        
        auto clear() noexcept -> void override {
          items().clear();
          ++data_->version;
        }
        
        auto contains(const value_type & item) const noexcept -> bool override {
          return items().find(item) != items().end();
        }
        
        auto copy_to(xtd::array<type_t>& array) const -> void {
          copy_to(0, array, 0, count());
        }
        
        auto copy_to(xtd::array<type_t>& array, size_type index) const -> void override {
          copy_to(0, array, index, count());
        }
        
        auto copy_to(size_type index, xtd::array<type_t>& array, size_type array_index, size_type count) const -> void {
          if (index + count > self_.count() || array_index + count > array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
          auto increment = size_type {};
          for (const auto& item : self_) {
            if (increment >= index + count) return;
            if (increment++ >= index) array[array_index++] = item;
          }
        }
        
        auto ensure_capacity(xtd::size capacity) noexcept -> xtd::size {
          data_->items.reserve(capacity);
          return self_.capacity();
        }
        
        auto except_with(const xtd::collections::generic::ienumerable<type_t>& other) noexcept -> void override {
          if (&other == this) {
            clear();
            return;
          }
          for (const type_t& item : other)
            remove(item);
        }
        
        enumerator<value_type> get_enumerator() const noexcept override {
          struct hash_set_enumerator : public ienumerator < value_type > {
            explicit hash_set_enumerator(const hash_set & 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.");
              value_ = value_type {*iterator_};
              return 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.");
              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 hash_set& items_;
            typename hash_set::base_type::const_iterator iterator_ = items_.data_->items.cend();
            mutable value_type value_;
            size_type version_ = 0;
          };
          return {new_ptr < hash_set_enumerator > (self_, data_->version)};
        }
        
        auto intersect_with(const xtd::collections::generic::ienumerable<type_t>& other) noexcept -> void override {
          auto to_keep = hash_set {other};
          auto to_remove = hash_set {};
          for (const type_t& item : self_)
            if (!to_keep.contains(item))
              to_remove.add(item);
          except_with(to_remove);
        }
        
        auto is_proper_subset_of(const xtd::collections::generic::ienumerable<type_t>& other) const noexcept -> bool override {
          auto set = hash_set {other};
          if (count() == 0) return set.count() > 0;
          if (count() >= set.count()) return false;
          return sub_set(set);
        }
        
        auto is_proper_superset_of(const xtd::collections::generic::ienumerable<type_t>& other) const noexcept -> bool override {
          auto set = hash_set {other};
          if (set.count() == 0) return count() > 0;
          if (set.count() >= count()) return false;
          return super_set(set);
        }
        
        auto is_subset_of(const xtd::collections::generic::ienumerable<type_t>& other) const noexcept -> bool override {
          return sub_set(hash_set {other});
        }
        
        auto is_superset_of(const xtd::collections::generic::ienumerable<type_t>& other) const noexcept -> bool override {
          return super_set(hash_set {other});
        }
        
        auto overlaps(const xtd::collections::generic::ienumerable<type_t>& other) const noexcept -> bool override {
          if (count() == 0) return false;
          for (const auto& item : other)
            if (contains(item)) return true;
          return false;
        }
        
        auto remove(const type_t& item) noexcept -> bool override {
          auto result = items().erase(item) == 1;
          ++data_->version;
          return result;
        }
        
        template<class predicate_t>
        auto remove_where(predicate_t match) noexcept -> size_type {
          auto to_remove = hash_set {};
          for (const auto& item : self_)
            if (match(item)) to_remove.add(item);
          for (const auto& item : to_remove)
            remove(item);
          return to_remove.count();
        }
        
        auto set_equals(const xtd::collections::generic::ienumerable<type_t>& other) const noexcept -> bool override {
          auto set = hash_set {other};
          if (count() != set.count()) return false;
          for (const auto& item : other)
            if (!contains(item)) return false;
          return true;
        }
        
        auto symetric_excep_with(const xtd::collections::generic::ienumerable<type_t>& other) noexcept -> void override {
          for (const auto& item : other)
            if (contains(item)) remove(item);
            else add(item);
        }
        
        auto to_string() const noexcept -> xtd::string override {return xtd::string::format("{{{}}}", xtd::string::join(", ", self_));}
        
        auto union_with(const xtd::collections::generic::ienumerable<type_t>& other) noexcept -> void override {
          for (const auto& item : other)
            if (!contains(item)) add(item);
        }
        
        
        
        
      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;}
        auto sub_set(const hash_set& set) const noexcept -> bool {
          if (count() == 0) return true;
          if (count() > set.count()) return false;
          for (const auto& item : self_)
            if (!set.contains(item)) return false;
          return true;
        }
        
        auto super_set(const hash_set& set) const noexcept -> bool {
          if (set.count() == 0) return true;
          if (set.count() > count()) return false;
          for (const auto& item : set)
            if (!contains(item)) return false;
          return true;
        }
        
        struct hash_set_data {
          hash_set_data() = default;
          hash_set_data(const xtd::collections::generic::iequality_comparer<key_type>& comparer) : comparer {&comparer}, items  {size_type {}, hasher_t {*comparer}, equator_t {*comparer}, allocator_t {}} {}
          hash_set_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}, allocator_t {}}, version {version} {
            for (const auto& item : items)
              self_.items.insert(item);
          }
          hash_set_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 <hash_set_data> data_ = xtd::new_ptr<hash_set_data>();
      };
      
      // Deduction guides for xtd::collections::generic::hash_set
      // {
      template<class type_t>
      hash_set(iset<type_t>) -> hash_set<type_t>;
      
      template<class type_t>
      hash_set(ienumerable<type_t>) -> hash_set<type_t>;
      
      template <class type_t>
      hash_set(std::initializer_list<type_t>) -> hash_set<type_t>;
      
      template <class input_iterator_t >
      hash_set(input_iterator_t, input_iterator_t) -> hash_set<typename input_iterator_t::value_type>;
      // }
    }
  }
}