Changeset a1448e4 in mainline

Timestamp:

2018-07-05T21:41:23Z (7 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

aedae28

Parents:

6a3a64f

git-author:

Dzejrou <dzejrou@…> (2018-05-10 00:22:25)

git-committer:

Dzejrou <dzejrou@…> (2018-07-05 21:41:23)

Message:

cpp: moved hash out of functional.hpp

Location:

uspace/lib/cpp/include

Files:

• functional (modified) (1 diff)
• impl/functional.hpp (modified) (1 diff)
• internal/functional/hash.hpp (added)

uspace/lib/cpp/include/functional

@@ -32 +32 @@
 #include <internal/functional/function.hpp>
 #include <internal/functional/invoke.hpp>
+#include <internal/functional/hash.hpp>
 #include <internal/functional/reference_wrapper.hpp>

uspace/lib/cpp/include/impl/functional.hpp

@@ -80 +80 @@
         return aux::mem_fn_t<R T::*>{f};
     }
-
-    /**
-     * 20.9.13, hash function primary template:
-     */
-
-    namespace aux
-    {
-        template<class T>
-        union converter
-        {
-            T value;
-            uint64_t converted;
-        };
-
-        template<class T>
-        T hash_(uint64_t x) noexcept
-        {
-            /**
-             * Note: std::hash is used for indexing in
-             *       unordered containers, not for cryptography.
-             *       Because of this, we decided to simply convert
-             *       the value to uin64_t, which will help us
-             *       with testing (since in order to create
-             *       a collision in a multiset or multimap
-             *       we simply need 2 values that congruent
-             *       by the size of the table.
-             */
-            return static_cast<T>(x);
-        }
-
-        template<class T>
-        size_t hash(T x) noexcept
-        {
-            static_assert(is_arithmetic_v<T> || is_pointer_v<T>,
-                          "invalid type passed to aux::hash");
-
-            converter<T> conv;
-            conv.value = x;
-
-            return hash_<size_t>(conv.converted);
-        }
-    }
-
-    template<class T>
-    struct hash
-    { /* DUMMY BODY */ };
-
-    template<>
-    struct hash<bool>
-    {
-        size_t operator()(bool x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = bool;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<char>
-    {
-        size_t operator()(char x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = char;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<signed char>
-    {
-        size_t operator()(signed char x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = signed char;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned char>
-    {
-        size_t operator()(unsigned char x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned char;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<char16_t>
-    {
-        size_t operator()(char16_t x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = char16_t;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<char32_t>
-    {
-        size_t operator()(char32_t x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = char32_t;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<wchar_t>
-    {
-        size_t operator()(wchar_t x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = wchar_t;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<short>
-    {
-        size_t operator()(short x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = short;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned short>
-    {
-        size_t operator()(unsigned short x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned short;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<int>
-    {
-        size_t operator()(int x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = int;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned int>
-    {
-        size_t operator()(unsigned int x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned int;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<long>
-    {
-        size_t operator()(long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<long long>
-    {
-        size_t operator()(long long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = long long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned long>
-    {
-        size_t operator()(unsigned long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<unsigned long long>
-    {
-        size_t operator()(unsigned long long x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = unsigned long long;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<float>
-    {
-        size_t operator()(float x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = float;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<double>
-    {
-        size_t operator()(double x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = double;
-        using result_type   = size_t;
-    };
-
-    template<>
-    struct hash<long double>
-    {
-        size_t operator()(long double x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = long double;
-        using result_type   = size_t;
-    };
-
-    template<class T>
-    struct hash<T*>
-    {
-        size_t operator()(T* x) const noexcept
-        {
-            return aux::hash(x);
-        }
-
-        using argument_type = T*;
-        using result_type   = size_t;
-    };
 }