Changeset aa0fa86a in mainline

Timestamp:

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

Author:

Dzejrou <dzejrou@…>

Branches:

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

Children:

93af98f

Parents:

255bb63

git-author:

Dzejrou <dzejrou@…> (2018-05-01 21:57:00)

git-committer:

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

Message:

cpp: added pair::pair(piecewise_construct_t, …), but had to temporarily remove templated tuple constructor which needs is_convertible etc on variadic types

Location:

uspace/lib/cpp/include/impl

Files:

• tuple.hpp (modified) (1 diff)
• utility.hpp (modified) (4 diffs)

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

@@ -207 +207 @@
 
                 // 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 */ }
+                /* template<class... Us> */
+                /* constexpr explicit tuple_impl(Us&&... us) */
+                /*     : tuple_element_wrapper<Is, Ts>(forward<Us>(us))... */
+                /* { /1* DUMMY BODY *1/ } */
         };
 

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

@@ -135 +135 @@
 
     /**
+     * 20.5.2, class template integer_sequence:
+     */
+
+    template<class T, T... Is>
+    struct integer_sequence
+    {
+        using value_type = T;
+
+        static constexpr size_t size() noexcept
+        {
+            return sizeof...(Is);
+        }
+
+        using next = integer_sequence<T, Is..., sizeof...(Is)>;
+    };
+
+    template<std::size_t... Is>
+    using index_sequence = integer_sequence<std::size_t, Is...>;
+
+    /**
+     * 20.5.3, alias template make_integer_sequence:
+     */
+
+    namespace aux
+    {
+        template<class T, uintmax_t N>
+        struct make_integer_sequence
+        {
+            /**
+             * Recursive to the bottom case below, appends sizeof...(Is) in
+             * every next "call", building the sequence.
+             */
+            using type = typename make_integer_sequence<T, N - 1>::type::next;
+        };
+
+        template<class T>
+        struct make_integer_sequence<T, std::uintmax_t(0)>
+        {
+            using type = integer_sequence<T>;
+        };
+    }
+
+
+    /**
+     * Problem: We can't specialize the N parameter because it is a value parameter
+     *          depending on a type parameter.
+     * Solution: According to the standard: if N is negative, the program is ill-formed,
+     *           so we just recast it to uintmax_t :)
+     */
+    template<class T, T N>
+    using make_integer_sequence = typename aux::make_integer_sequence<T, std::uintmax_t(N)>::type;
+
+    template<size_t N>
+    using make_index_sequence = make_integer_sequence<std::size_t, N>;
+
+    /**
      * 20.3, pairs:
      */
+
+    template<size_t, class>
+    class tuple_element;
+
+    template<size_t I, class T>
+    using tuple_element_t = typename tuple_element<I, T>::type;
+
+    template<class...>
+    class tuple;
+
+    template<size_t I, class... Ts>
+    constexpr tuple_element_t<I, tuple<Ts...>>&& get(tuple<Ts...>&&) noexcept;
+
+    namespace aux
+    {
+        template<class T, class... Args, size_t... Is>
+        T from_tuple(tuple<Args...>&& tpl, index_sequence<Is...>)
+        {
+            return T{get<Is>(move(tpl))...};
+        }
+
+        template<class T, class... Args>
+        T from_tuple(tuple<Args...>&& tpl)
+        {
+            return from_tuple<T>(move(tpl), make_index_sequence<sizeof...(Args)>{});
+        }
+    }
 
     struct piecewise_construct_t
@@ -142 +225 @@
         explicit piecewise_construct_t() = default;
     };
+
+    inline constexpr piecewise_construct_t piecewise_construct{};
 
     template<typename T1, typename T2>
@@ -179 +264 @@
         { /* DUMMY BODY */ }
 
-        /* TODO: need tuple, piecewise_construct_t
         template<class... Args1, class... Args2>
         pair(piecewise_construct_t, tuple<Args1...> first_args, tuple<Args2...> second_args)
-        {
-            // TODO:
-        }
-        */
+            : first{aux::from_tuple<first_type>(move(first_args))},
+              second{aux::from_tuple<second_type>(move(second_args))}
+        { /* DUMMY BODY */ }
 
         pair& operator=(const pair& other)
@@ -383 +466 @@
         return get<1>(move(p));
     }
-
-    /**
-     * 20.5.2, class template integer_sequence:
-     */
-
-    template<class T, T... Is>
-    struct integer_sequence
-    {
-        using value_type = T;
-
-        static constexpr size_t size() noexcept
-        {
-            return sizeof...(Is);
-        }
-
-        using next = integer_sequence<T, Is..., sizeof...(Is)>;
-    };
-
-    template<std::size_t... Is>
-    using index_sequence = integer_sequence<std::size_t, Is...>;
-
-    /**
-     * 20.5.3, alias template make_integer_sequence:
-     */
-
-    namespace aux
-    {
-        template<class T, uintmax_t N>
-        struct make_integer_sequence
-        {
-            /**
-             * Recursive to the bottom case below, appends sizeof...(Is) in
-             * every next "call", building the sequence.
-             */
-            using type = typename make_integer_sequence<T, N - 1>::type::next;
-        };
-
-        template<class T>
-        struct make_integer_sequence<T, std::uintmax_t(0)>
-        {
-            using type = integer_sequence<T>;
-        };
-    }
-
-
-    /**
-     * Problem: We can't specialize the N parameter because it is a value parameter
-     *          depending on a type parameter.
-     * Solution: According to the standard: if N is negative, the program is ill-formed,
-     *           so we just recast it to uintmax_t :)
-     */
-    template<class T, T N>
-    using make_integer_sequence = typename aux::make_integer_sequence<T, std::uintmax_t(N)>::type;
-
-    template<size_t N>
-    using make_index_sequence = make_integer_sequence<std::size_t, N>;
 }