Index: uspace/lib/cpp/include/type_traits =================================================================== --- uspace/lib/cpp/include/type_traits (revision 9dfdb03555c97b28ed8ae4f47e1dad27a2ab6171) +++ uspace/lib/cpp/include/type_traits (revision 9dfdb03555c97b28ed8ae4f47e1dad27a2ab6171) @@ -0,0 +1,429 @@ +/* + * Copyright (c) 2017 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. + */ + +#include + +namespace std +{ + /** + * 20.10.3, helper class: + */ + + template + struct integral_constant; + + using true_type = integral_constant; + using false_type = integral_constant; + + /** + * 20.10.4.1, primary type categories: + */ + + template + struct is_void; + + template + struct is_null_pointer; + + template + struct is_integral; + + template + struct is_floating_point; + + template + struct is_array; + + template + struct is_pointer; + + template + struct is_lvalue_reference; + + template + struct is_rvalue_reference; + + template + struct is_member_object_pointer; + + template + struct is_member_function_pointer; + + template + struct is_enum; + + template + struct is_union; + + template + struct is_class; + + template + struct is_function; + + /** + * 20.10.4.2, composite type categories: + */ + + template + struct is_reference; + + template + struct is_arithmetic; + + template + struct is_fundamental; + + template + struct is_object; + + template + struct is_scalar; + + template + struct is_compound; + + template + struct is_member_pointer; + + /** + * 20.10.4.3, type properties: + */ + + template + struct is_const; + + template + struct is_volatile; + + template + struct is_trivial; + + template + struct is_trivially_copyable; + + template + struct is_standard_layout; + + template + struct is_pod; + + template + struct is_literal_type; + + template + struct is_empty; + + template + struct is_polymorphic; + + template + struct is_abstract; + + template + struct is_final; + + template + struct is_signed; + + template + struct is_unsidned; + + template + struct is_constructible; + + template + struct is_default_constructible; + + template + struct is_copy_constructible; + + template + struct is_move_constructible; + + template + struct is_assignable; + + template + struct is_copy_assignable; + + template + struct is_move_assignable; + + template + struct is_destructible; + + template + struct is_trivially_constructible; + + template + struct is_trivially_default_constructible; + + template + struct is_trivially_copy_constructible; + + template + struct is_trivially_move_constructible; + + template + struct is_trivially_assignable; + + template + struct is_trivially_copy_assignable; + + template + struct is_trivially_move_assignable; + + template + struct is_trivially_destructible; + + template + struct is_nothrow_constructible; + + template + struct is_nothrow_default_constructible; + + template + struct is_nothrow_copy_constructible; + + template + struct is_nothrow_move_constructible; + + template + struct is_nothrow_assignable; + + template + struct is_nothrow_copy_assignable; + + template + struct is_nothrow_move_assignable; + + template + struct is_nothrow_destructible; + + template + struct has_virtual_destructor; + + /** + * 20.10.5, type property queries: + */ + + template + struct alignment_of; + + template + struct rank; + + template + struct extent; + + /** + * 20.10.6, type relations: + */ + + template + struct is_same: false_type; + + template + struct is_same: true_type; + + template + struct is_base_of; + + template + struct is_convertible; + + /** + * 20.10.7.1, const-volatile modifications: + */ + + template + struct remove_const; + + template + struct remove_volatile; + + template + struct remove_cv; + + template + struct add_const; + + template + struct add_volatile; + + template + struct add_cv; + + template + using remove_const_t = typename remove_const::type; + + template + using remove_volatile_t = typename remove_volatile::type; + + template + using remove_cv_t = typename remove_cv::type; + + template + using add_const_t = typename add_const::type; + + template + using add_volatile_t = typename add_volatile::type; + + template + using add_cv_t = typename add_cv::type; + + /** + * 20.10.7.2, reference modifications: + */ + + template + struct remove_reference; + + template + struct add_lvalue_reference; + + template + struct add_rvalue_reference; + + 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: + */ + + template + struct make_signed; + + template + struct make_unsigned; + + template + using make_signed_t = typename make_signed::type; + + template + using make_unsigned_t = typename make_signed::type; + + /** + * 20.10.7.4, array modifications: + */ + + template + struct remove_extent; + + template + struct remove_all_extents; + + template + using remove_extent_t = typename remove_extent::type; + + template + using remove_all_extents_t = typename remove_all_extents::type; + + /** + * 20.10.7.5, pointer modifications: + */ + + template + struct remove_pointer; + + template + struct add_pointer; + + template + using remove_pointer_t = typename remove_pointer::type; + + template + using add_pointer_t = typename add_pointer::type; + + /** + * 20.10.7.6, other transformations: + */ + + // TODO: consult standard on the default value of align + template + struct aligned_storage; + + template + struct aligned_union; + + template + struct decay; + + template + struct enable_if; + + template + struct conditional; + + template + struct common_type; + + template + struct underlying_type; + + template + class result_of; // not defined + + template + class result_of; + + template + using aligned_storage_t = typename aligned_storage::type; + + template + using aligned_union_t = typename aligned_union::type; + + template + using decay_t = typename decay::type; + + template + using enable_if_t = typename enable_if::type; + + template + using conditional_t = typename conditional::type; + + template + using common_type_t = typename common_type::type; + + template + using underlying_type_t = typename underlying_type::type; + + template + using result_of_t = typename result_of::type; + + template + using void_t = void; +}