Index: uspace/lib/cpp/include/functional =================================================================== --- uspace/lib/cpp/include/functional (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ uspace/lib/cpp/include/functional (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -28,2 +28,6 @@ #include +#include +#include +#include +#include Index: uspace/lib/cpp/include/impl/functional.hpp =================================================================== --- uspace/lib/cpp/include/impl/functional.hpp (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ uspace/lib/cpp/include/impl/functional.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -30,7 +30,7 @@ #define LIBCPP_FUNCTIONAL +#include #include #include -#include #include #include @@ -38,52 +38,4 @@ namespace std { - namespace aux - { - /** - * 20.9.2, requirements: - */ - template - decltype(auto) invoke(R T::* f, T1&& t1, Ts&&... args) - { - if constexpr (is_member_function_pointer_v) - { - if constexpr (is_base_of_v>) - // (1.1) - return (t1.*f)(forward(args)...); - else - // (1.2) - return ((*t1).*f)(forward(args)...); - } - else if constexpr (is_member_object_pointer_v && sizeof...(args) == 0) - { - /** - * Note: Standard requires to N be equal to 1, but we take t1 directly - * so we need sizeof...(args) to be 0. - */ - if constexpr (is_base_of_v>) - // (1.3) - return t1.*f; - else - // (1.4) - return (*t1).*f; - } - - /** - * 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, "invalid invoke"); - } - - template - decltype(auto) invoke(F&& f, Args&&... args) - { - // (1.5) - return f(forward(args)...); - } - } - /** * 20.9.3, invoke: @@ -91,85 +43,7 @@ template - result_of_t invoke(F&& f, Args&&... args) + decltype(auto) invoke(F&& f, Args&&... args) { return aux::invoke(forward(f)(forward(args)...)); - } - - /** - * 20.9.4, reference_wrapper: - */ - - template - class reference_wrapper - { - public: - using type = T; - // TODO: conditional typedefs - - reference_wrapper(type& val) noexcept - : data_{&val} - { /* DUMMY BODY */ } - - reference_wrapper(type&&) = delete; - - reference_wrapper(const reference_wrapper& other) noexcept - : data_{other.data_} - { /* DUMMY BODY */ } - - reference_wrapper& operator=(const reference_wrapper& other) noexcept - { - data_ = other.data_; - - return *this; - } - - operator type&() const noexcept - { - return *data_; - } - - type& get() const noexcept - { - return *data_; - } - - template - result_of_t operator()(Args&&... args) const - { - return invoke(*data_, std::forward(args)...); - } - - private: - type* data_; - }; - - template - reference_wrapper ref(T& t) noexcept - { - return reference_wrapper{t}; - } - - template - reference_wrapper cref(const T& t) noexcept - { - return reference_wrapper{t}; - } - - template - void ref(const T&&) = delete; - - template - void cref(const T&&) = delete; - - template - reference_wrapper ref(reference_wrapper t) noexcept - { - return ref(t.get()); - } - - template - reference_wrapper cref(reference_wrapper t) noexcept - { - return cref(t.get()); } @@ -756,539 +630,4 @@ template constexpr binary_negate not2(const Predicate& pred); - - /** - * 20.9.12, polymorphic function adaptors: - */ - - namespace aux - { - // TODO: fix this - /* template */ - /* struct is_callable_impl: false_type */ - /* { /1* DUMMY BODY *1/ }; */ - - /* template */ - /* struct is_callable_impl< */ - /* void_t(), declval()..., R))>, */ - /* R, Args... */ - /* > : true_type */ - /* { /1* DUMMY BODY *1/ }; */ - - /* template */ - /* struct is_callable: is_callable_impl, T> */ - /* { /1* DUMMY BODY *1/ }; */ - - template - R invoke_callable(Callable* clbl, Args&&... args) - { - return (*clbl)(forward(args)...); - } - - template - void copy_callable(Callable* to, Callable* from) - { - new(to) Callable{*from}; - } - - template - void destroy_callable(Callable* clbl) - { - if (clbl) - clbl->~Callable(); - } - } - - // TODO: implement - class bad_function_call; - - template - class function; // undefined - - /** - * Note: Ideally, this implementation wouldn't - * copy the target if it was a pointer to - * a function, but for the simplicity of the - * implementation, we do copy even in that - * case for now. It would be a nice optimization - * if this was changed in the future. - */ - template - class function - { - public: - using result_type = R; - // TODO: conditional typedefs - - /** - * 20.9.12.2.1, construct/copy/destroy: - */ - - function() noexcept - : callable_{}, callable_size_{}, call_{}, - copy_{}, dest_{} - { /* DUMMY BODY */ } - - function(nullptr_t) noexcept - : function{} - { /* DUMMY BODY */ } - - function(const function& other) - : callable_{}, callable_size_{other.callable_size_}, - call_{other.call_}, copy_{other.copy_}, dest_{other.dest_} - { - callable_ = new uint8_t[callable_size_]; - (*copy_)(callable_, other.callable_); - } - - function(function&& other) - : callable_{other.callable_}, callable_size_{other.callable_size_}, - call_{other.call_}, copy_{other.copy_}, dest_{other.dest_} - { - other.callable_ = nullptr; - other.callable_size_ = size_t{}; - other.call_ = nullptr; - other.copy_ = nullptr; - other.dest_ = nullptr; - } - - // TODO: shall not participate in overloading unless aux::is_callable - template - function(F f) - : callable_{}, callable_size_{sizeof(F)}, - call_{(call_t)aux::invoke_callable}, - copy_{(copy_t)aux::copy_callable}, - dest_{(dest_t)aux::destroy_callable} - { - callable_ = new uint8_t[callable_size_]; - (*copy_)(callable_, (uint8_t*)&f); - } - - /** - * Note: For the moment we're ignoring the allocator - * for simplicity of the implementation. - */ - - template - function(allocator_arg_t, const A& a) noexcept - : function{} - { /* DUMMY BODY */ } - - template - function(allocator_arg_t, const A& a, nullptr_t) noexcept - : function{} - { /* DUMMY BODY */ } - - template - function(allocator_arg_t, const A& a, const function& other) - : function{other} - { /* DUMMY BODY */ } - - template - function(allocator_arg_t, const A& a, function&& other) - : function{move(other)} - { /* DUMMY BODY */ } - - // TODO: shall not participate in overloading unless aux::is_callable - template - function(allocator_arg_t, const A& a, F f) - : function{f} - { /* DUMMY BODY */ } - - function& operator=(const function& rhs) - { - function{rhs}.swap(*this); - - return *this; - } - - /** - * Note: We have to copy call_, copy_ - * and dest_ because they can be templated - * by a type F we don't know. - */ - function& operator=(function&& rhs) - { - clear_(); - - callable_ = rhs.callable_; - callable_size_ = rhs.callable_size_; - call_ = rhs.call_; - copy_ = rhs.copy_; - dest_ = rhs.dest_; - - rhs.callable_ = nullptr; - rhs.callable_size_ = size_t{}; - rhs.call_ = nullptr; - rhs.copy_ = nullptr; - rhs.dest_ = nullptr; - - return *this; - } - - function& operator=(nullptr_t) noexcept - { - clear_(); - - return *this; - } - - // TODO: shall not participate in overloading unless aux::is_callable - template - function& operator=(F&& f) - { - callable_size_ = sizeof(F); - callable_ = new uint8_t[callable_size_]; - call_ = aux::invoke_callable; - copy_ = aux::copy_callable; - dest_ = aux::destroy_callable; - - (*copy_)(callable_, (uint8_t*)&f); - } - - template - function& operator=(reference_wrapper ref) noexcept - { - return (*this) = ref.get(); - } - - ~function() - { - if (callable_) - { - (*dest_)(callable_); - delete[] callable_; - } - } - - /** - * 20.9.12.2.2, function modifiers: - */ - - void swap(function& other) noexcept - { - std::swap(callable_, other.callable_); - std::swap(callable_size_, other.callable_size_); - std::swap(call_, other.call_); - std::swap(copy_, other.copy_); - std::swap(dest_, other.dest_); - } - - template - void assign(F&& f, const A& a) - { - function{allocator_arg, a, forward(f)}.swap(*this); - } - - /** - * 20.9.12.2.3, function capacity: - */ - - explicit operator bool() const noexcept - { - return callable_ != nullptr; - } - - /** - * 20.9.12.2.4, function invocation: - */ - - result_type operator()(Args... args) const - { - // TODO: throw bad_function_call if !callable_ || !call_ - if constexpr (is_same_v) - (*call_)(callable_, forward(args)...); - else - return (*call_)(callable_, forward(args)...); - } - - /** - * 20.9.12.2.5, function target access: - */ - - const type_info& target_type() const noexcept - { - return typeid(*callable_); - } - - template - T* target() noexcept - { - if (target_type() == typeid(T)) - return (T*)callable_; - else - return nullptr; - } - - template - const T* target() const noexcept - { - if (target_type() == typeid(T)) - return (T*)callable_; - else - return nullptr; - } - - private: - using call_t = R(*)(uint8_t*, Args&&...); - using copy_t = void (*)(uint8_t*, uint8_t*); - using dest_t = void (*)(uint8_t*); - - uint8_t* callable_; - size_t callable_size_; - call_t call_; - copy_t copy_; - dest_t dest_; - - void clear_() - { - if (callable_) - { - (*dest_)(callable_); - delete[] callable_; - callable_ = nullptr; - } - } - }; - - /** - * 20.9.12.2.6, null pointer comparisons: - */ - - template - bool operator==(const function& f, nullptr_t) noexcept - { - return !f; - } - - template - bool operator==(nullptr_t, const function& f) noexcept - { - return !f; - } - - template - bool operator!=(const function& f, nullptr_t) noexcept - { - return (bool)f; - } - - template - bool operator!=(nullptr_t, const function& f) noexcept - { - return (bool)f; - } - - /** - * 20.9.12.2.7, specialized algorithms: - */ - - template - void swap(function& f1, function& f2) - { - f1.swap(f2); - } - - template - struct uses_allocator, Alloc> - : true_type - { /* DUMMY BODY */ }; - - /** - * 20.9.10, bind: - */ - - namespace aux - { - template - struct placeholder_t - { - constexpr placeholder_t() = default; - constexpr placeholder_t(const placeholder_t&) = default; - constexpr placeholder_t(placeholder_t&&) = default; - }; - } - - template - struct is_placeholder: integral_constant - { /* DUMMY BODY */ }; - - template // Note: const because they are all constexpr. - struct is_placeholder> - : integral_constant - { /* DUMMY BODY */ }; - - template - inline constexpr int is_placeholder_v = is_placeholder::value; - - namespace aux - { - /** - * Note: Our internal bind return type has an extra type - * template parameter and an extra bool template parameter. - * We use this for the special version of bind that has - * the return type to have a result_type typedef - * (i.e. when the bool is true, the extra type parameter - * is typedefed as result_type - see the structure below). - * This is just a simplification of the implementation - * so that we don't need to have two return types for - * the two bind functions, because unlike function or - * mem_fn, we know exactly when to make the typedef. - */ - - template - struct bind_conditional_result_type - { /* DUMMY BODY */ }; - - template - struct bind_conditional_result_type - { - using result_type = R; - }; - - template - 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 bind_arg_filter - { - public: - bind_arg_filter(Args&&... args) - : args_{forward(args)...} - { /* DUMMY BODY */ } - - template - constexpr decltype(auto) operator[](T&& t) - { - return forward(t); - } - - template - constexpr decltype(auto) operator[](const placeholder_t) - { // Since placeholders are constexpr, this is the best match for them. - /** - * Come on, it's int! Why not use -1 as not placeholder - * and start them at 0? -.- - */ - return get(args_); - } - - template - constexpr T& operator[](reference_wrapper ref) - { - return ref.get(); - } - - template - constexpr decltype(auto) operator[](const bind_t b) - { - return b; // TODO: bind subexpressions - } - - - private: - tuple args_; - }; - - template - class bind_t: public bind_conditional_result_type - { - public: - template - constexpr bind_t(G&& g, BoundArgs&&... args) - : func_{forward(g)}, - bound_args_{forward(args)...} - { /* DUMMY BODY */ } - - constexpr bind_t(const bind_t& other) = default; - constexpr bind_t(bind_t&& other) = default; - - template - constexpr decltype(auto) operator()(ActualArgs&&... args) - { - return invoke_( - make_index_sequence{}, - forward(args)... - ); - } - - private: - function> func_; - tuple...> bound_args_; - - template - constexpr decltype(auto) invoke_( - index_sequence, ActualArgs&&... args - ) - { - /** - * The expression filter[bound_args_[bind_arg_index()]]... - * 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 filter{forward(args)...}; - - return invoke( - func_, - filter[get(bound_args_)]... - ); - } - }; - } - - template - struct is_bind_expression: false_type - { /* DUMMY BODY */ }; - - template - struct is_bind_expression> - : true_type - { /* DUMMY BODY */ }; - - template - aux::bind_t bind(F&& f, Args&&... args) - { - return aux::bind_t{forward(f), forward(args)...}; - } - - template - aux::bind_t bind(F&& f, Args&&... args) - { - return aux::bind_t{forward(f), forward(args)...}; - } - - namespace placeholders - { - /** - * Note: The number of placeholders is - * implementation defined, we've chosen - * 8 because it is a nice number - * and should be enough for any function - * call. - * Note: According to the C++14 standard, these - * are all extern non-const. We decided to use - * the C++17 form of them being inline constexpr - * because it is more convenient, makes sense - * and would eventually need to be upgraded - * anyway. - */ - inline constexpr aux::placeholder_t<1> _1; - inline constexpr aux::placeholder_t<2> _2; - inline constexpr aux::placeholder_t<3> _3; - inline constexpr aux::placeholder_t<4> _4; - inline constexpr aux::placeholder_t<5> _5; - inline constexpr aux::placeholder_t<6> _6; - inline constexpr aux::placeholder_t<7> _7; - inline constexpr aux::placeholder_t<8> _8; - } /** Index: uspace/lib/cpp/include/impl/tuple.hpp =================================================================== --- uspace/lib/cpp/include/impl/tuple.hpp (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ uspace/lib/cpp/include/impl/tuple.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -31,6 +31,6 @@ #include -#include -#include +#include +#include #include #include Index: uspace/lib/cpp/include/impl/type_traits.hpp =================================================================== --- uspace/lib/cpp/include/impl/type_traits.hpp (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ uspace/lib/cpp/include/impl/type_traits.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -33,4 +33,5 @@ #include #include +#include namespace std @@ -893,43 +894,4 @@ /** - * 20.10.7.2, reference modifications: - */ - - template - struct remove_reference: aux::type_is - { /* DUMMY BODY */ }; - - template - struct remove_reference: aux::type_is - { /* DUMMY BODY */ }; - - template - struct remove_reference: aux::type_is - { /* DUMMY BODY */ }; - - // TODO: is this good? - template - struct add_lvalue_reference: aux::type_is - { /* DUMMY BODY */ }; - - // TODO: Special case when T is not referencable! - template - struct add_rvalue_reference: aux::type_is - { /* DUMMY BODY */ }; - - template - struct add_rvalue_reference: aux::type_is - { /* DUMMY BODY */ }; - - template - using remove_reference_t = typename remove_reference::type; - - template - using add_lvalue_reference_t = typename add_lvalue_reference::type; - - template - using add_rvalue_reference_t = typename add_rvalue_reference::type; - - /** * 20.10.7.3, sign modifications: */ @@ -1067,10 +1029,4 @@ struct underlying_type; - template - class result_of; // not defined - - template - class result_of; - template using aligned_storage_t = typename aligned_storage::type; @@ -1087,7 +1043,4 @@ template using underlying_type_t = typename underlying_type::type; - - template - using result_of_t = typename result_of::type; } Index: uspace/lib/cpp/include/impl/utility.hpp =================================================================== --- uspace/lib/cpp/include/impl/utility.hpp (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ uspace/lib/cpp/include/impl/utility.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -32,4 +32,5 @@ #include #include +#include #include @@ -65,26 +66,4 @@ return !(lhs < rhs); } - } - - /** - * 20.2.4, forward/move helpers: - */ - - template - constexpr T&& forward(remove_reference_t& t) noexcept - { - return static_cast(t); - } - - template - constexpr T&& forward(remove_reference_t&& t) noexcept - { - return static_cast(t); - } - - template - constexpr remove_reference_t&& move(T&& t) noexcept - { - return static_cast&&>(t); } @@ -124,13 +103,4 @@ return old_val; } - - /** - * 20.2.5, function template declval: - * Note: This function only needs declaration, not - * implementation. - */ - - template - add_rvalue_reference_t declval() noexcept; /** Index: uspace/lib/cpp/include/internal/functional/bind.hpp =================================================================== --- uspace/lib/cpp/include/internal/functional/bind.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/functional/bind.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,240 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_FUNCTIONAL_BIND +#define LIBCPP_INTERNAL_FUNCTIONAL_BIND + +#include +#include +#include +#include +#include +#include + +namespace std +{ + /** + * 20.9.10, bind: + */ + + namespace aux + { + template + struct placeholder_t + { + constexpr placeholder_t() = default; + constexpr placeholder_t(const placeholder_t&) = default; + constexpr placeholder_t(placeholder_t&&) = default; + }; + } + + template + struct is_placeholder: integral_constant + { /* DUMMY BODY */ }; + + template // Note: const because they are all constexpr. + struct is_placeholder> + : integral_constant + { /* DUMMY BODY */ }; + + template + inline constexpr int is_placeholder_v = is_placeholder::value; + + namespace aux + { + /** + * Note: Our internal bind return type has an extra type + * template parameter and an extra bool template parameter. + * We use this for the special version of bind that has + * the return type to have a result_type typedef + * (i.e. when the bool is true, the extra type parameter + * is typedefed as result_type - see the structure below). + * This is just a simplification of the implementation + * so that we don't need to have two return types for + * the two bind functions, because unlike function or + * mem_fn, we know exactly when to make the typedef. + */ + + template + struct bind_conditional_result_type + { /* DUMMY BODY */ }; + + template + struct bind_conditional_result_type + { + using result_type = R; + }; + + template + 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 bind_arg_filter + { + public: + bind_arg_filter(Args&&... args) + : args_{forward(args)...} + { /* DUMMY BODY */ } + + template + constexpr decltype(auto) operator[](T&& t) + { + return forward(t); + } + + template + constexpr decltype(auto) operator[](const placeholder_t) + { // Since placeholders are constexpr, this is the best match for them. + /** + * Come on, it's int! Why not use -1 as not placeholder + * and start them at 0? -.- + */ + return get(args_); + } + + template + constexpr T& operator[](reference_wrapper ref) + { + return ref.get(); + } + + template + constexpr decltype(auto) operator[](const bind_t b) + { + return b; // TODO: bind subexpressions + } + + + private: + tuple args_; + }; + + template + class bind_t: public bind_conditional_result_type + { + public: + template + constexpr bind_t(G&& g, BoundArgs&&... args) + : func_{forward(g)}, + bound_args_{forward(args)...} + { /* DUMMY BODY */ } + + constexpr bind_t(const bind_t& other) = default; + constexpr bind_t(bind_t&& other) = default; + + template + constexpr decltype(auto) operator()(ActualArgs&&... args) + { + return invoke_( + make_index_sequence{}, + forward(args)... + ); + } + + private: + function> func_; + tuple...> bound_args_; + + template + constexpr decltype(auto) invoke_( + index_sequence, ActualArgs&&... args + ) + { + /** + * The expression filter[bound_args_[bind_arg_index()]]... + * 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 filter{forward(args)...}; + + return invoke( + func_, + filter[get(bound_args_)]... + ); + } + }; + } + + template + struct is_bind_expression: false_type + { /* DUMMY BODY */ }; + + template + struct is_bind_expression> + : true_type + { /* DUMMY BODY */ }; + + template + aux::bind_t bind(F&& f, Args&&... args) + { + return aux::bind_t{forward(f), forward(args)...}; + } + + template + aux::bind_t bind(F&& f, Args&&... args) + { + return aux::bind_t{forward(f), forward(args)...}; + } + + namespace placeholders + { + /** + * Note: The number of placeholders is + * implementation defined, we've chosen + * 8 because it is a nice number + * and should be enough for any function + * call. + * Note: According to the C++14 standard, these + * are all extern non-const. We decided to use + * the C++17 form of them being inline constexpr + * because it is more convenient, makes sense + * and would eventually need to be upgraded + * anyway. + */ + inline constexpr aux::placeholder_t<1> _1; + inline constexpr aux::placeholder_t<2> _2; + inline constexpr aux::placeholder_t<3> _3; + inline constexpr aux::placeholder_t<4> _4; + inline constexpr aux::placeholder_t<5> _5; + inline constexpr aux::placeholder_t<6> _6; + inline constexpr aux::placeholder_t<7> _7; + inline constexpr aux::placeholder_t<8> _8; + } +} + +#endif Index: uspace/lib/cpp/include/internal/functional/function.hpp =================================================================== --- uspace/lib/cpp/include/internal/functional/function.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/functional/function.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,376 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_FUNCTIONAL_FUNCTION +#define LIBCPP_INTERNAL_FUNCTIONAL_FUNCTION + +#include +#include +#include + +namespace std +{ + /** + * 20.9.12, polymorphic function adaptors: + */ + + namespace aux + { + // TODO: fix this + /* template */ + /* struct is_callable_impl: false_type */ + /* { /1* DUMMY BODY *1/ }; */ + + /* template */ + /* struct is_callable_impl< */ + /* void_t(), declval()..., R))>, */ + /* R, Args... */ + /* > : true_type */ + /* { /1* DUMMY BODY *1/ }; */ + + /* template */ + /* struct is_callable: is_callable_impl, T> */ + /* { /1* DUMMY BODY *1/ }; */ + + template + R invoke_callable(Callable* clbl, Args&&... args) + { + return (*clbl)(forward(args)...); + } + + template + void copy_callable(Callable* to, Callable* from) + { + new(to) Callable{*from}; + } + + template + void destroy_callable(Callable* clbl) + { + if (clbl) + clbl->~Callable(); + } + } + + // TODO: implement + class bad_function_call; + + template + class function; // undefined + + /** + * Note: Ideally, this implementation wouldn't + * copy the target if it was a pointer to + * a function, but for the simplicity of the + * implementation, we do copy even in that + * case for now. It would be a nice optimization + * if this was changed in the future. + */ + template + class function + { + public: + using result_type = R; + // TODO: conditional typedefs + + /** + * 20.9.12.2.1, construct/copy/destroy: + */ + + function() noexcept + : callable_{}, callable_size_{}, call_{}, + copy_{}, dest_{} + { /* DUMMY BODY */ } + + function(nullptr_t) noexcept + : function{} + { /* DUMMY BODY */ } + + function(const function& other) + : callable_{}, callable_size_{other.callable_size_}, + call_{other.call_}, copy_{other.copy_}, dest_{other.dest_} + { + callable_ = new uint8_t[callable_size_]; + (*copy_)(callable_, other.callable_); + } + + function(function&& other) + : callable_{other.callable_}, callable_size_{other.callable_size_}, + call_{other.call_}, copy_{other.copy_}, dest_{other.dest_} + { + other.callable_ = nullptr; + other.callable_size_ = size_t{}; + other.call_ = nullptr; + other.copy_ = nullptr; + other.dest_ = nullptr; + } + + // TODO: shall not participate in overloading unless aux::is_callable + template + function(F f) + : callable_{}, callable_size_{sizeof(F)}, + call_{(call_t)aux::invoke_callable}, + copy_{(copy_t)aux::copy_callable}, + dest_{(dest_t)aux::destroy_callable} + { + callable_ = new uint8_t[callable_size_]; + (*copy_)(callable_, (uint8_t*)&f); + } + + /** + * Note: For the moment we're ignoring the allocator + * for simplicity of the implementation. + */ + + template + function(allocator_arg_t, const A& a) noexcept + : function{} + { /* DUMMY BODY */ } + + template + function(allocator_arg_t, const A& a, nullptr_t) noexcept + : function{} + { /* DUMMY BODY */ } + + template + function(allocator_arg_t, const A& a, const function& other) + : function{other} + { /* DUMMY BODY */ } + + template + function(allocator_arg_t, const A& a, function&& other) + : function{move(other)} + { /* DUMMY BODY */ } + + // TODO: shall not participate in overloading unless aux::is_callable + template + function(allocator_arg_t, const A& a, F f) + : function{f} + { /* DUMMY BODY */ } + + function& operator=(const function& rhs) + { + function{rhs}.swap(*this); + + return *this; + } + + /** + * Note: We have to copy call_, copy_ + * and dest_ because they can be templated + * by a type F we don't know. + */ + function& operator=(function&& rhs) + { + clear_(); + + callable_ = rhs.callable_; + callable_size_ = rhs.callable_size_; + call_ = rhs.call_; + copy_ = rhs.copy_; + dest_ = rhs.dest_; + + rhs.callable_ = nullptr; + rhs.callable_size_ = size_t{}; + rhs.call_ = nullptr; + rhs.copy_ = nullptr; + rhs.dest_ = nullptr; + + return *this; + } + + function& operator=(nullptr_t) noexcept + { + clear_(); + + return *this; + } + + // TODO: shall not participate in overloading unless aux::is_callable + template + function& operator=(F&& f) + { + callable_size_ = sizeof(F); + callable_ = new uint8_t[callable_size_]; + call_ = aux::invoke_callable; + copy_ = aux::copy_callable; + dest_ = aux::destroy_callable; + + (*copy_)(callable_, (uint8_t*)&f); + } + + template + function& operator=(reference_wrapper ref) noexcept + { + return (*this) = ref.get(); + } + + ~function() + { + if (callable_) + { + (*dest_)(callable_); + delete[] callable_; + } + } + + /** + * 20.9.12.2.2, function modifiers: + */ + + void swap(function& other) noexcept + { + std::swap(callable_, other.callable_); + std::swap(callable_size_, other.callable_size_); + std::swap(call_, other.call_); + std::swap(copy_, other.copy_); + std::swap(dest_, other.dest_); + } + + template + void assign(F&& f, const A& a) + { + function{allocator_arg, a, forward(f)}.swap(*this); + } + + /** + * 20.9.12.2.3, function capacity: + */ + + explicit operator bool() const noexcept + { + return callable_ != nullptr; + } + + /** + * 20.9.12.2.4, function invocation: + */ + + result_type operator()(Args... args) const + { + // TODO: throw bad_function_call if !callable_ || !call_ + if constexpr (is_same_v) + (*call_)(callable_, forward(args)...); + else + return (*call_)(callable_, forward(args)...); + } + + /** + * 20.9.12.2.5, function target access: + */ + + const type_info& target_type() const noexcept + { + return typeid(*callable_); + } + + template + T* target() noexcept + { + if (target_type() == typeid(T)) + return (T*)callable_; + else + return nullptr; + } + + template + const T* target() const noexcept + { + if (target_type() == typeid(T)) + return (T*)callable_; + else + return nullptr; + } + + private: + using call_t = R(*)(uint8_t*, Args&&...); + using copy_t = void (*)(uint8_t*, uint8_t*); + using dest_t = void (*)(uint8_t*); + + uint8_t* callable_; + size_t callable_size_; + call_t call_; + copy_t copy_; + dest_t dest_; + + void clear_() + { + if (callable_) + { + (*dest_)(callable_); + delete[] callable_; + callable_ = nullptr; + } + } + }; + + /** + * 20.9.12.2.6, null pointer comparisons: + */ + + template + bool operator==(const function& f, nullptr_t) noexcept + { + return !f; + } + + template + bool operator==(nullptr_t, const function& f) noexcept + { + return !f; + } + + template + bool operator!=(const function& f, nullptr_t) noexcept + { + return (bool)f; + } + + template + bool operator!=(nullptr_t, const function& f) noexcept + { + return (bool)f; + } + + /** + * 20.9.12.2.7, specialized algorithms: + */ + + template + void swap(function& f1, function& f2) + { + f1.swap(f2); + } + + template + struct uses_allocator, Alloc> + : true_type + { /* DUMMY BODY */ }; +} + +#endif Index: uspace/lib/cpp/include/internal/functional/invoke.hpp =================================================================== --- uspace/lib/cpp/include/internal/functional/invoke.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/functional/invoke.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_FUNCTIONAL_INVOKE +#define LIBCPP_INTERNAL_FUNCTIONAL_INVOKE + +#include +#include +#include + +namespace std::aux +{ + /** + * 20.9.2, requirements: + */ + + template + decltype(auto) invoke(R T::* f, T1&& t1, Ts&&... args) + { + if constexpr (is_member_function_pointer_v) + { + if constexpr (is_base_of_v>) + // (1.1) + return (t1.*f)(forward(args)...); + else + // (1.2) + return ((*t1).*f)(forward(args)...); + } + else if constexpr (is_member_object_pointer_v && sizeof...(args) == 0) + { + /** + * Note: Standard requires to N be equal to 1, but we take t1 directly + * so we need sizeof...(args) to be 0. + */ + if constexpr (is_base_of_v>) + // (1.3) + return t1.*f; + else + // (1.4) + return (*t1).*f; + } + + /** + * 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, "invalid invoke"); + } + + template + decltype(auto) invoke(F&& f, Args&&... args) + { + // (1.5) + return f(forward(args)...); + } +} + +#endif Index: uspace/lib/cpp/include/internal/functional/reference_wrapper.hpp =================================================================== --- uspace/lib/cpp/include/internal/functional/reference_wrapper.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/functional/reference_wrapper.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_FUNCTIONAL_REFERENCE_WRAPPER +#define LIBCPP_INTERNAL_FUNCTIONAL_REFERENCE_WRAPPER + +#include +#include + +namespace std +{ + /** + * 20.9.4, reference_wrapper: + */ + + template + class reference_wrapper + { + public: + using type = T; + // TODO: conditional typedefs + + reference_wrapper(type& val) noexcept + : data_{&val} + { /* DUMMY BODY */ } + + reference_wrapper(type&&) = delete; + + reference_wrapper(const reference_wrapper& other) noexcept + : data_{other.data_} + { /* DUMMY BODY */ } + + reference_wrapper& operator=(const reference_wrapper& other) noexcept + { + data_ = other.data_; + + return *this; + } + + operator type&() const noexcept + { + return *data_; + } + + type& get() const noexcept + { + return *data_; + } + + template + result_of_t operator()(Args&&... args) const + { + return invoke(*data_, std::forward(args)...); + } + + private: + type* data_; + }; + + template + reference_wrapper ref(T& t) noexcept + { + return reference_wrapper{t}; + } + + template + reference_wrapper cref(const T& t) noexcept + { + return reference_wrapper{t}; + } + + template + void ref(const T&&) = delete; + + template + void cref(const T&&) = delete; + + template + reference_wrapper ref(reference_wrapper t) noexcept + { + return ref(t.get()); + } + + template + reference_wrapper cref(reference_wrapper t) noexcept + { + return cref(t.get()); + } +} + +#endif Index: uspace/lib/cpp/include/internal/result_of.hpp =================================================================== --- uspace/lib/cpp/include/internal/result_of.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/result_of.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_RESULT_OF +#define LIBCPP_INTERNAL_RESULT_OF + +#include + +namespace std +{ + /** + * Note: This doesn't work, C++14 standard allows for F + * to be any complete type, our implementation + * currently works like the C++11 version where + * F has to be callable. + * TODO: Fix this. + */ + + template + struct result_of; + + template + class result_of: aux::type_is< + decltype(aux::invoke(declval(), declval()...)) + > + { /* DUMMY BODY */ }; + + template + using result_of_t = typename result_of::type; +} + +#endif Index: uspace/lib/cpp/include/internal/tuple/tuple_cat.hpp =================================================================== --- uspace/lib/cpp/include/internal/tuple/tuple_cat.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/tuple/tuple_cat.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_TUPLE_TUPLE_CAT +#define LIBCPP_INTERNAL_TUPLE_TUPLE_CAT + +#include + +namespace std +{ // forward declarations + template + struct tuple; + + template + struct tuple_element; + + template + constexpr typename tuple_element>::type& get(tuple& tpl) noexcept; + + template + struct integer_sequence; + + template + using index_sequence = integer_sequence; +} + +namespace std::aux +{ + template + struct tuple_append; + + template + struct tuple_append, tuple, Vs...> + : type_is> + { /* DUMMY BODY */ }; + + template + using tuple_append_t = typename tuple_append::type; + + template + struct remove_first_tuple; + + template + struct remove_first_tuple, Tuples...> + : type_is + { /* DUMMY BODY */ }; + + template + using remove_first_tuple_t = typename remove_first_tuple::type; + + template + struct get_first_tuple; + + template + struct get_first_tuple, Tuples...> + : type_is> + { /* DUMMY BODY */ }; + + template + using get_first_tuple_t = typename get_first_tuple::type; + + template + struct tuple_cat_type_impl; + + template + struct tuple_cat_type_impl, Tuples...> + : type_is< + typename tuple_cat_type_impl< + tuple_append_t, get_first_tuple_t>, + remove_first_tuple_t + >::type + > + { /* DUMMY BODY */ }; + + template + using tuple_cat_type_impl_t = typename tuple_cat_type_impl::type; + + template + struct tuple_cat_type; + + template + struct tuple_cat_type, Tuples...> + : type_is, Tuples...>> + { /* DUMMY BODY */ }; + + template + using tuple_cat_type_t = typename tuple_cat_type::type; + + template + struct concatenate_sequences; + + template + struct concatenate_sequences, index_sequence> + : type_is> + { /* DUMMY BODY */ }; + + template + using concatenate_sequences_t = typename concatenate_sequences::type; + + template + struct append_indices; + + template + struct append_indices, tuple, Tuples...> + : append_indices< + concatenate_sequences_t< + index_sequence, make_index_sequence + >, + Tuples... + > + { /* DUMMY BODY */ }; + + template + using append_indices_t = typename append_indices::types; + + template + struct generate_indices; + + template + struct generate_indices, Tuples...> + : type_is< + append_indices_t< + make_index_sequence, + Tuples... + > + > + { /* DUMMY BODY */ }; + + template + using generate_indices_t = typename generate_indices::type; + + template + tuple_cat_type_t tuple_cat(Tuples&&... tpls, + index_sequence, + index_sequence) + { + return tuple_cat_type_t{ + get( + get( + forward(tpls) + ) + )... + }; + } +} + +#endif Index: uspace/lib/cpp/include/internal/tuple/tuple_ops.hpp =================================================================== --- uspace/lib/cpp/include/internal/tuple/tuple_ops.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/tuple/tuple_ops.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_TUPLE_TUPLE_OPS +#define LIBCPP_INTERNAL_TUPLE_TUPLE_OPS + +#include + +namespace std +{ // forward declarations + template + struct tuple; + + template + struct tuple_element; + + template + constexpr typename tuple_element>::type& get(tuple& tpl) noexcept; +} + +namespace std::aux +{ + template + struct tuple_ops + { + template + static void assign(T&& lhs, U&& rhs) + { + get(forward(lhs)) = get(forward(rhs)); + + tuple_ops::assign(forward(lhs), forward(rhs)); + } + + template + static void swap(T& lhs, U& rhs) + { + std::swap(get(lhs), get(rhs)); + + tuple_ops::swap(lhs, rhs); + } + + template + static bool eq(const T& lhs, const U& rhs) + { + return (get(lhs) == get(rhs)) && tuple_ops::eq(lhs, rhs); + } + + template + static bool lt(const T& lhs, const U& rhs) + { + return (get(lhs) < get(rhs)) || + (!(get(rhs) < get(lhs)) && tuple_ops::lt(lhs, rhs)); + } + }; + + template + struct tuple_ops + { + template + static void assign(T&& lhs, U&& rhs) + { + get(forward(lhs)) = get(forward(rhs)); + } + + template + static void swap(T& lhs, U& rhs) + { + std::swap(get(lhs), get(rhs)); + } + + template + static bool eq(const T& lhs, const U& rhs) + { + return get(lhs) == get(rhs); + } + + template + static bool lt(const T& lhs, const U& rhs) + { + return get(lhs) < get(rhs); + } + }; +} + +#endif Index: pace/lib/cpp/include/internal/tuple_cat.hpp =================================================================== --- uspace/lib/cpp/include/internal/tuple_cat.hpp (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ (revision ) @@ -1,172 +1,0 @@ -/* - * Copyright (c) 2018 Jaroslav Jindrak - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LIBCPP_TUPLE_CAT -#define LIBCPP_TUPLE_CAT - -#include - -namespace std -{ // forward declarations - template - struct tuple; - - template - struct tuple_element; - - template - constexpr typename tuple_element>::type& get(tuple& tpl) noexcept; - - template - struct integer_sequence; - - template - using index_sequence = integer_sequence; -} - -namespace std::aux -{ - template - struct tuple_append; - - template - struct tuple_append, tuple, Vs...> - : type_is> - { /* DUMMY BODY */ }; - - template - using tuple_append_t = typename tuple_append::type; - - template - struct remove_first_tuple; - - template - struct remove_first_tuple, Tuples...> - : type_is - { /* DUMMY BODY */ }; - - template - using remove_first_tuple_t = typename remove_first_tuple::type; - - template - struct get_first_tuple; - - template - struct get_first_tuple, Tuples...> - : type_is> - { /* DUMMY BODY */ }; - - template - using get_first_tuple_t = typename get_first_tuple::type; - - template - struct tuple_cat_type_impl; - - template - struct tuple_cat_type_impl, Tuples...> - : type_is< - typename tuple_cat_type_impl< - tuple_append_t, get_first_tuple_t>, - remove_first_tuple_t - >::type - > - { /* DUMMY BODY */ }; - - template - using tuple_cat_type_impl_t = typename tuple_cat_type_impl::type; - - template - struct tuple_cat_type; - - template - struct tuple_cat_type, Tuples...> - : type_is, Tuples...>> - { /* DUMMY BODY */ }; - - template - using tuple_cat_type_t = typename tuple_cat_type::type; - - template - struct concatenate_sequences; - - template - struct concatenate_sequences, index_sequence> - : type_is> - { /* DUMMY BODY */ }; - - template - using concatenate_sequences_t = typename concatenate_sequences::type; - - template - struct append_indices; - - template - struct append_indices, tuple, Tuples...> - : append_indices< - concatenate_sequences_t< - index_sequence, make_index_sequence - >, - Tuples... - > - { /* DUMMY BODY */ }; - - template - using append_indices_t = typename append_indices::types; - - template - struct generate_indices; - - template - struct generate_indices, Tuples...> - : type_is< - append_indices_t< - make_index_sequence, - Tuples... - > - > - { /* DUMMY BODY */ }; - - template - using generate_indices_t = typename generate_indices::type; - - template - tuple_cat_type_t tuple_cat(Tuples&&... tpls, - index_sequence, - index_sequence) - { - return tuple_cat_type_t{ - get( - get( - forward(tpls) - ) - )... - }; - } -} - -#endif Index: pace/lib/cpp/include/internal/tuple_ops.hpp =================================================================== --- uspace/lib/cpp/include/internal/tuple_ops.hpp (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ (revision ) @@ -1,110 +1,0 @@ -/* - * Copyright (c) 2018 Jaroslav Jindrak - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef LIBCPP_TUPLE_OPS -#define LIBCPP_TUPLE_OPS - -#include - -namespace std -{ // forward declarations - template - struct tuple; - - template - struct tuple_element; - - template - constexpr typename tuple_element>::type& get(tuple& tpl) noexcept; -} - -namespace std::aux -{ - template - struct tuple_ops - { - template - static void assign(T&& lhs, U&& rhs) - { - get(forward(lhs)) = get(forward(rhs)); - - tuple_ops::assign(forward(lhs), forward(rhs)); - } - - template - static void swap(T& lhs, U& rhs) - { - std::swap(get(lhs), get(rhs)); - - tuple_ops::swap(lhs, rhs); - } - - template - static bool eq(const T& lhs, const U& rhs) - { - return (get(lhs) == get(rhs)) && tuple_ops::eq(lhs, rhs); - } - - template - static bool lt(const T& lhs, const U& rhs) - { - return (get(lhs) < get(rhs)) || - (!(get(rhs) < get(lhs)) && tuple_ops::lt(lhs, rhs)); - } - }; - - template - struct tuple_ops - { - template - static void assign(T&& lhs, U&& rhs) - { - get(forward(lhs)) = get(forward(rhs)); - } - - template - static void swap(T& lhs, U& rhs) - { - std::swap(get(lhs), get(rhs)); - } - - template - static bool eq(const T& lhs, const U& rhs) - { - return get(lhs) == get(rhs); - } - - template - static bool lt(const T& lhs, const U& rhs) - { - return get(lhs) < get(rhs); - } - }; -} - -#endif Index: uspace/lib/cpp/include/internal/type_traits/references.hpp =================================================================== --- uspace/lib/cpp/include/internal/type_traits/references.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/type_traits/references.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_TYPE_TRAITS_REFERENCES +#define LIBCPP_INTERNAL_TYPE_TRAITS_REFERENCES + +#include + +namespace std +{ + /** + * 20.10.7.2, reference modifications: + */ + + template + struct remove_reference: aux::type_is + { /* DUMMY BODY */ }; + + template + struct remove_reference: aux::type_is + { /* DUMMY BODY */ }; + + template + struct remove_reference: aux::type_is + { /* DUMMY BODY */ }; + + // TODO: is this good? + template + struct add_lvalue_reference: aux::type_is + { /* DUMMY BODY */ }; + + // TODO: Special case when T is not referencable! + template + struct add_rvalue_reference: aux::type_is + { /* DUMMY BODY */ }; + + template + struct add_rvalue_reference: aux::type_is + { /* DUMMY BODY */ }; + + template + using remove_reference_t = typename remove_reference::type; + + template + using add_lvalue_reference_t = typename add_lvalue_reference::type; + + template + using add_rvalue_reference_t = typename add_rvalue_reference::type; +} + +#endif Index: uspace/lib/cpp/include/internal/type_traits/result_of.hpp =================================================================== --- uspace/lib/cpp/include/internal/type_traits/result_of.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/type_traits/result_of.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_TYPE_TRAITS_RESULT_OF +#define LIBCPP_INTERNAL_TYPE_TRAITS_RESULT_OF + +#include + +namespace std +{ + template + class result_of + { /* DUMMY BODY */ }; + + template + class result_of: aux::type_is< + decltype(aux::invoke(declval(), declval()...)) + > + { /* DUMMY BODY */ }; + + template + using result_of_t = typename result_of::type; +} + +#endif Index: uspace/lib/cpp/include/internal/utility/declval.hpp =================================================================== --- uspace/lib/cpp/include/internal/utility/declval.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/utility/declval.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_UTILITY_DECLVAL +#define LIBCPP_INTERNAL_UTILITY_DECLVAL + +#include + +namespace std +{ + /** + * 20.2.5, function template declval: + * Note: This function only needs declaration, not + * implementation. + */ + + template + add_rvalue_reference_t declval() noexcept; +} + +#endif Index: uspace/lib/cpp/include/internal/utility/forward_move.hpp =================================================================== --- uspace/lib/cpp/include/internal/utility/forward_move.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) +++ uspace/lib/cpp/include/internal/utility/forward_move.hpp (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2018 Jaroslav Jindrak + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef LIBCPP_INTERNAL_UTILITY_FORWARD_MOVE +#define LIBCPP_INTERNAL_UTILITY_FORWARD_MOVE + +#include + +namespace std +{ + /** + * 20.2.4, forward/move helpers: + */ + + template + constexpr T&& forward(remove_reference_t& t) noexcept + { + return static_cast(t); + } + + template + constexpr T&& forward(remove_reference_t&& t) noexcept + { + return static_cast(t); + } + + template + constexpr remove_reference_t&& move(T&& t) noexcept + { + return static_cast&&>(t); + } +} + +#endif Index: uspace/lib/cpp/include/type_traits =================================================================== --- uspace/lib/cpp/include/type_traits (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ uspace/lib/cpp/include/type_traits (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -28,2 +28,4 @@ #include +#include +#include Index: uspace/lib/cpp/include/utility =================================================================== --- uspace/lib/cpp/include/utility (revision daef596e7da9c68c8b9a6b33dd996a2452436ef4) +++ uspace/lib/cpp/include/utility (revision c866a83963c9d6c8d137e5814d6b98011c19030f) @@ -28,2 +28,4 @@ #include +#include +#include