Changeset 3d6f7f3 in mainline

Timestamp:

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

Author:

Dzejrou <dzejrou@…>

Branches:

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

Children:

4a7e47b

Parents:

921174c

git-author:

Dzejrou <dzejrou@…> (2018-04-22 15:47:11)

git-committer:

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

Message:

cpp: reorganized tuple header, added a WIP version of tuple_cat (mismatched indices at the moment)

Location:

uspace/lib/cpp/include

Files:

• impl/tuple.hpp (modified) (7 diffs)
• internal/tuple_cat.hpp (added)
• internal/tuple_ops.hpp (added)

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

@@ -31 +31 @@
 
 #include <internal/aux.hpp>
+#include <internal/tuple_cat.hpp>
+#include <internal/tuple_ops.hpp>
 #include <functional>
 #include <type_traits>
@@ -93 +95 @@
     }
 
-    template<class... Tuples> // TODO: dafuq is ctypes?
-    constexpr tuple<Tuples...> tuple_cat(Tuples&&... tpls);
+    template<class... Tuples>
+    constexpr aux::tuple_cat_type_t<Tuples...> tuple_cat(Tuples&&... tpls)
+    {
+        return aux::tuple_cat(
+            forward<Tuples>(tpls)...,
+            make_index_sequence<sizeof...(Tuples)>{},
+            aux::generate_indices_t<Tuples...>{}
+        );
+    }
 
     /**
@@ -180 +189 @@
             constexpr tuple_element_wrapper() = default;
 
-            constexpr explicit tuple_element_wrapper(T val)
-                : value{val}
+            constexpr explicit tuple_element_wrapper(T&& val)
+                : value{forward<T>(val)}
+            { /* DUMMY BODY */ }
+
+            template<
+                class U,
+                class = enable_if_t<
+                    is_convertible_v<U, T> && !is_same_v<U, T>,
+                    void
+                >
+            >
+            constexpr explicit tuple_element_wrapper(U&& val)
+                : value(forward<U>(val))
             { /* DUMMY BODY */ }
 
@@ -198 +218 @@
                 { /* DUMMY BODY */ }
 
-                constexpr explicit tuple_impl(const Ts&... ts)
-                    : tuple_element_wrapper<Is, Ts>(ts)...
+                constexpr explicit tuple_impl(Ts&&... ts)
+                    : tuple_element_wrapper<Is, Ts>(forward<Ts>(ts))...
+                { /* DUMMY BODY */ }
+
+                // TODO: enable only if Us is convertible to Ts and they are not same
+                template<class... Us>
+                constexpr explicit tuple_impl(Us&&... us)
+                    : tuple_element_wrapper<Is, Ts>(forward<Us>(us))...
                 { /* DUMMY BODY */ }
         };
@@ -255 +281 @@
         return wrapper.value;
     }
-
 
     namespace aux
@@ -286 +311 @@
     }
 
-    namespace aux
-    {
-        template<size_t I, size_t N>
-        struct tuple_ops
-        {
-            template<class T, class U>
-            static void assign(T&& lhs, U&& rhs)
-            {
-                get<I>(forward<T>(lhs)) = get<I>(forward<U>(rhs));
-
-                tuple_ops<I + 1, N>::assign(forward<T>(lhs), forward<U>(rhs));
-            }
-
-            template<class T, class U>
-            static void swap(T& lhs, U& rhs)
-            {
-                std::swap(get<I>(lhs), get<I>(rhs));
-
-                tuple_ops<I + 1, N>::swap(lhs, rhs);
-            }
-
-            template<class T, class U>
-            static bool eq(const T& lhs, const U& rhs)
-            {
-                return (get<I>(lhs) == get<I>(rhs)) && tuple_ops<I + 1, N>::eq(lhs, rhs);
-            }
-
-            template<class T, class U>
-            static bool lt(const T& lhs, const U& rhs)
-            {
-                return (get<I>(lhs) < get<I>(rhs)) ||
-                    (!(get<I>(rhs) < get<I>(lhs)) && tuple_ops<I + 1, N>::lt(lhs, rhs));
-            }
-        };
-
-        template<size_t N>
-        struct tuple_ops<N, N>
-        {
-            template<class T, class U>
-            static void assign(T&& lhs, U&& rhs)
-            {
-                get<N>(forward<T>(lhs)) = get<N>(forward<U>(rhs));
-            }
-
-            template<class T, class U>
-            static void swap(T& lhs, U& rhs)
-            {
-                std::swap(get<N>(lhs), get<N>(rhs));
-            }
-
-            template<class T, class U>
-            static bool eq(const T& lhs, const U& rhs)
-            {
-                return get<N>(lhs) == get<N>(rhs);
-            }
-
-            template<class T, class U>
-            static bool lt(const T& lhs, const U& rhs)
-            {
-                return get<N>(lhs) < get<N>(rhs);
-            }
-        };
-    }
-
     /**
      * 20.4.2, class template tuple:
      */
-
 
     template<class... Ts>
@@ -382 +342 @@
             tuple(tuple&&) = default;
 
-            /* template<class... Us> */
-            /* constexpr tuple(const tuple<Us...>& tpl) */
-            /*     : base_t(tpl) */
-            //{ /* DUMMY BODY */ }
-
-            /* template<class... Us> */
-            /* constexpr tuple(tuple<Us...>& tpl) */
-            /*     : base_t(forward<tuple<Us>>(tpl)...) */
-            //{ /* DUMMY BODY */ }
+            template<class... Us>
+            constexpr tuple(const tuple<Us...>& tpl)
+                : base_t(tpl)
+            { /* DUMMY BODY */ }
+
+            template<class... Us>
+            constexpr tuple(tuple<Us...>&& tpl)
+                : base_t(forward<tuple<Us>>(tpl)...)
+            { /* DUMMY BODY */ }
 
             // TODO: pair related construction and assignment needs convertibility, not size