Changeset d275344 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:

e9f2f4e

Parents:

78a794ab

git-author:

Dzejrou <dzejrou@…> (2018-05-04 20:40:34)

git-committer:

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

Message:

cpp: fixed passing references to bind without std::ref or std::cref, now they are not modified and the user needs to use the aforementioned functions

Location:

uspace/lib/cpp/include/impl

Files:

• functional.hpp (modified) (7 diffs)
• tuple.hpp (modified) (1 diff)

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

@@ -1104 +1104 @@
         {
             constexpr placeholder_t() = default;
+            constexpr placeholder_t(const placeholder_t&) = default;
+            constexpr placeholder_t(placeholder_t&&) = default;
         };
     }
@@ -1121 +1123 @@
     namespace aux
     {
-        template<size_t I>
-        struct bind_arg_index
-        { /* DUMMY BODY */ };
-
-        template<class... Args>
-        class bind_bound_args
-        {
-            public:
-                template<class... BoundArgs>
-                constexpr bind_bound_args(BoundArgs&&... args)
-                    : tpl_{forward<BoundArgs>(args)...}
-                { /* DUMMY BODY */ }
-
-                template<size_t I>
-                constexpr decltype(auto) operator[](bind_arg_index<I>)
-                {
-                    return get<I>(tpl_);
-                }
-
-            private:
-                tuple<Args...> tpl_;
-        };
-
         template<class F, class... Args>
         class bind_t;
 
+        /**
+         * Filter class that uses its overloaded operator[]
+         * to filter our placeholders, reference_wrappers and bind
+         * subexpressions and replace them with the correct
+         * arguments (extracts references, calls the subexpressions etc).
+         */
         template<class... Args>
         class bind_arg_filter
@@ -1157 +1142 @@
                 template<class T>
                 constexpr decltype(auto) operator[](T&& t)
-                { // Since placeholders are constexpr, this is a worse match for them.
+                {
                     return forward<T>(t);
                 }
@@ -1193 +1178 @@
             // TODO: conditional typedefs
             public:
-                // TODO: T& gets captured by ref, should be by value :/
-                template<class... BoundArgs>
-                constexpr bind_t(F&& f, BoundArgs&&... args)
-                    : func_{forward<F>(f)},
-                      bound_args_{forward<BoundArgs>(args)...}
+                template<class G, class... BoundArgs>
+                constexpr bind_t(G&& g, BoundArgs&&... args)
+                    : func_{forward<F>(g)},
+                      bound_args_{forward<Args>(args)...}
                 { /* DUMMY BODY */ }
 
@@ -1214 +1198 @@
             private:
                 function<decay_t<F>> func_;
-                bind_bound_args<Args...> bound_args_;
+                tuple<decay_t<Args>...> bound_args_;
 
                 template<size_t... Is, class... ActualArgs>
@@ -1221 +1205 @@
                 )
                 {
+                    /**
+                     * The expression filter[bound_args_[bind_arg_index<Is>()]]...
+                     * here expands bind_arg_index to 0, 1, ... sizeof...(ActualArgs) - 1
+                     * and then passes this variadic list of indices to the bound_args_
+                     * tuple which extracts the bound args from it.
+                     * Our filter will then have its operator[] called on each of them
+                     * and filter out the placeholders, reference_wrappers etc and changes
+                     * them to the actual arguments.
+                     */
                     bind_arg_filter<ActualArgs...> filter{forward<ActualArgs>(args)...};
 
                     return invoke(
                         func_,
-                        filter[bound_args_[bind_arg_index<Is>()]]...
+                        filter[get<Is>(bound_args_)]...
                     );
                 }
@@ -1247 +1240 @@
 
     template<class R, class F, class... Args>
-    aux::bind_t<F, Args...> bind(F&& f, Args&&... args);
+    aux::bind_t<F, Args...> bind(F&& f, Args&&... args)
+    {
+        // TODO: this one should have a result_type typedef equal to R
+        return aux::bind_t<F, Args...>{forward<F>(f), forward<Args>(args)...};
+    }
 
     namespace placeholders

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

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