hasher.hpp

Go to the documentation of this file.

#pragma once
#include "../iequality_comparer.hpp"
#include "../../../object.hpp"
#include "../../../ihashable.hpp"
#include <type_traits>

namespace xtd {
  namespace collections {
    namespace generic {
      namespace helpers {
        template<class key_t>
        struct hasher {
          
          using argument_type = key_t;
          using result_type = xtd::size;
          
          
          hasher() noexcept = default;
          explicit hasher(const xtd::collections::generic::iequality_comparer<key_t>& comparer) noexcept : comparer {const_cast<xtd::collections::generic::iequality_comparer<key_t>*>(&comparer)} {}
          
          hasher(const hasher&) noexcept = default;
          hasher(hasher&&) noexcept = default;
          hasher& operator=(const hasher&) noexcept = default;
          hasher& operator=(hasher&&) noexcept = default;
          
          
          auto operator()(const argument_type& key) const noexcept -> result_type {
            if (comparer) return comparer->get_hash_code(key);
            if constexpr(std::is_polymorphic_v<argument_type> && std::is_base_of_v<xtd::ihashable, argument_type>) return static_cast<const xtd::ihashable&>(key).get_hash_code();
            else if constexpr(std::is_polymorphic_v<argument_type> && std::is_base_of_v<xtd::object, argument_type>) return static_cast<const xtd::object&>(key).get_hash_code();
            else if constexpr(std::is_invocable_v<std::hash<argument_type>, const argument_type&>) return std::hash<argument_type> {}(key);
            else return std::hash<std::intptr_t> {}(reinterpret_cast<std::intptr_t>(&key));
          }

          
        private:
          xtd::collections::generic::iequality_comparer<key_t>* comparer = nullptr;
        };
      }
    }
  }
}