Changeset 22ba300 in mainline

Timestamp:

2018-07-05T21:41:19Z (6 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

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

Children:

ee51635

Parents:

e65c9285

git-author:

Dzejrou <dzejrou@…> (2018-03-01 17:42:10)

git-committer:

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

Message:

fixed compile errors, added a generic hash function, fixed static asserts

File:

• uspace/lib/cpp/include/impl/functional.hpp (modified) (44 diffs)

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

@@ -30 +30 @@
 #define LIBCPP_FUNCTIONAL
 
+#include <limits>
 #include <type_traits>
-
-extern "C" {
-#include <adt/hash.h>
-}
+#include <utility>
 
 namespace std
@@ -44 +42 @@
          */
         template<class R, class T, class T1, class... Ts>
-        decltype(auto) invoke(R T::* f, T1&& t1, Args&&... args)
+        decltype(auto) invoke(R T::* f, T1&& t1, Ts&&... args)
         {
             if constexpr (is_member_function_pointer_v<decltype(f)>)
@@ -50 +48 @@
                 if constexpr (is_base_of_v<T, remove_reference_t<T1>>)
                     // (1.1)
-                    return (t1.*f)(forward<Args>(args)...);
+                    return (t1.*f)(forward<Ts>(args)...);
                 else
                     // (1.2)
-                    return ((*t1).*f)(forward<Args>(args)...);
+                    return ((*t1).*f)(forward<Ts>(args)...);
             }
-            else if (is_member_object_pointer_v<decltype(f)> && sizeof...(args) == 0)
+            else if constexpr (is_member_object_pointer_v<decltype(f)> && sizeof...(args) == 0)
             {
                 /**
@@ -68 +66 @@
                     return (*t1).*f;
             }
-            static_assert(false, "invalid invoke");
+
+            /**
+             * Note: If this condition holds this will not be reachable,
+             *       but a new addition to the standard (17.7 point (8.1))
+             *       prohibits us from simply using false as the condition here,
+             *       so we use this because we know it is false here.
+             */
+            static_assert(is_member_function_pointer_v<decltype(f)>, "invalid invoke");
         }
 
@@ -208 +213 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) + forward<U>(rhs))
         {
@@ -221 +226 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) - forward<U>(rhs))
         {
@@ -234 +239 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) * forward<U>(rhs))
         {
@@ -247 +252 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) / forward<U>(rhs))
         {
@@ -260 +265 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) % forward<U>(rhs))
         {
@@ -273 +278 @@
     {
         template<class T>
-        constexpr auto operator(T&& x) const
+        constexpr auto operator()(T&& x) const
             -> decltype(-forward<T>(x))
         {
@@ -287 +292 @@
 
     template<class T = void>
-    struct equal_to;
+    struct equal_to
     {
         constexpr bool operator()(const T& lhs, const T& rhs) const
@@ -368 +373 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) == forward<U>(rhs))
         {
@@ -381 +386 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) != forward<U>(rhs))
         {
@@ -394 +399 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) > forward<U>(rhs))
         {
@@ -407 +412 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) < forward<U>(rhs))
         {
@@ -420 +425 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) >= forward<U>(rhs))
         {
@@ -433 +438 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) <= forward<U>(rhs))
         {
@@ -488 +493 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) && forward<U>(rhs))
         {
@@ -501 +506 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) || forward<U>(rhs))
         {
@@ -514 +519 @@
     {
         template<class T>
-        constexpr auto operator(T&& x) const
+        constexpr auto operator()(T&& x) const
             -> decltype(!forward<T>(x))
         {
-            return !forward<T>(lhs);
+            return !forward<T>(x);
         }
 
@@ -582 +587 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) & forward<U>(rhs))
         {
@@ -595 +600 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) | forward<U>(rhs))
         {
@@ -608 +613 @@
     {
         template<class T, class U>
-        constexpr auto operator(T&& lhs, U&& rhs) const
+        constexpr auto operator()(T&& lhs, U&& rhs) const
             -> decltype(forward<T>(lhs) ^ forward<U>(rhs))
         {
@@ -621 +626 @@
     {
         template<class T>
-        constexpr auto operator(T&& x) const
+        constexpr auto operator()(T&& x) const
             -> decltype(~forward<T>(x))
         {
-            return ~forward<T>(lhs);
+            return ~forward<T>(x);
         }
 
@@ -710 +715 @@
      */
 
+    namespace aux
+    {
+        template<class T>
+        union converter
+        {
+            T value;
+            uint64_t converted;
+        };
+
+        template<class T>
+        T hash_(uint64_t x) noexcept
+        {
+            // TODO: This is copied form adt/hash (temporarily),
+            //       check if we can use something better.
+            x = (x ^ 61) ^ (x >> 16);
+            x = x + (x << 3);
+            x = x ^ (x >> 4);
+            x = x * 0x27d4eb2d;
+            x = x ^ (x >> 15);
+
+            return static_cast<T>((x << 32) | (x >> 32));
+        }
+
+        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
@@ -719 +760 @@
         size_t operator()(bool x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -731 +772 @@
         size_t operator()(char x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -743 +784 @@
         size_t operator()(signed char x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -755 +796 @@
         size_t operator()(unsigned char x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -767 +808 @@
         size_t operator()(char16_t x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -779 +820 @@
         size_t operator()(char32_t x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -791 +832 @@
         size_t operator()(wchar_t x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -803 +844 @@
         size_t operator()(short x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -815 +856 @@
         size_t operator()(unsigned short x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -827 +868 @@
         size_t operator()(int x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -839 +880 @@
         size_t operator()(unsigned int x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -851 +892 @@
         size_t operator()(long x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -863 +904 @@
         size_t operator()(long long x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -875 +916 @@
         size_t operator()(unsigned long x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -887 +928 @@
         size_t operator()(unsigned long long x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }
 
@@ -899 +940 @@
         size_t operator()(float x) const noexcept
         {
-            return hash_mix(*(size_t*)(&x));
+            return aux::hash(x);
         }
 
@@ -907 +948 @@
 
     template<>
-    struct hash<double>;
+    struct hash<double>
     {
         size_t operator()(double x) const noexcept
         {
-            return hash_mix(*(size_t*)(&x));
+            return aux::hash(x);
         }
 
@@ -919 +960 @@
 
     template<>
-    struct hash<long double>;
+    struct hash<long double>
     {
         size_t operator()(long double x) const noexcept
         {
-            return hash_mix(*(size_t*)(&x));
+            return aux::hash(x);
         }
 
@@ -935 +976 @@
         size_t operator()(T* x) const noexcept
         {
-            return hash_mix(static_cast<size_t>(x));
+            return aux::hash(x);
         }