/*  Copyright (C) 2015  Povilas Kanapickas <povilas@radix.lt>

    This file is part of cppreference-doc

    This work is licensed under the Creative Commons Attribution-ShareAlike 3.0
    Unported License. To view a copy of this license, visit
    http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
    Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

    Permission is granted to copy, distribute and/or modify this document
    under the terms of the GNU Free Documentation License, Version 1.3 or
    any later version published by the Free Software Foundation; with no
    Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
*/

#ifndef CPPREFERENCE_TYPE_TRAITS_H
#define CPPREFERENCE_TYPE_TRAITS_H

#if CPPREFERENCE_STDVER>= 2011

#include <cstddef> // for size_t

namespace std {

template<class T, T v>
struct integral_constant {
    typedef T value_type;
    typedef integral_constant<T, v> type;

    static constexpr T value = v;
    constexpr operator value_type() const;
    constexpr T operator()() const;
};

typedef integral_constant<bool, false> false_type;
typedef integral_constant<bool, true> true_type;

#if CPPREFERENCE_STDVER >= 2017
template<bool B>
using bool_constant = integral_constant<bool, B>;
#endif

// SIMPLIFIED: the actual base type depends on T
// primary type categories
template<class T> struct is_void : integral_constant<bool, false> {};
#if CPPREFERENCE_STDVER>= 2014
template<class T> struct is_null_pointer : integral_constant<bool, false> {};
#endif
template<class T> struct is_integral : integral_constant<bool, false> {};
template<class T> struct is_floating_point : integral_constant<bool, false> {};
template<class T> struct is_array : integral_constant<bool, false> {};
template<class T> struct is_enum : integral_constant<bool, false> {};
template<class T> struct is_union : integral_constant<bool, false> {};
template<class T> struct is_class : integral_constant<bool, false> {};
template<class T> struct is_function : integral_constant<bool, false> {};
template<class T> struct is_pointer : integral_constant<bool, false> {};
template<class T> struct is_lvalue_reference : integral_constant<bool, false> {};
template<class T> struct is_rvalue_reference : integral_constant<bool, false> {};
template<class T> struct is_member_object_pointer : integral_constant<bool, false> {};
template<class T> struct is_member_function_pointer : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_void_v = false;
template<class T> inline constexpr bool is_null_pointer_v = false;
template<class T> inline constexpr bool is_integral_v = false;
template<class T> inline constexpr bool is_floating_point_v = false;
template<class T> inline constexpr bool is_array_v = false;
template<class T> inline constexpr bool is_enum_v = false;
template<class T> inline constexpr bool is_union_v = false;
template<class T> inline constexpr bool is_class_v = false;
template<class T> inline constexpr bool is_function_v = false;
template<class T> inline constexpr bool is_pointer_v = false;
template<class T> inline constexpr bool is_lvalue_reference_v = false;
template<class T> inline constexpr bool is_rvalue_reference_v = false;
template<class T> inline constexpr bool is_member_object_pointer_v = false;
template<class T> inline constexpr bool is_member_function_pointer_v = false;
#endif

// composite type categories
template<class T> struct is_fundamental : integral_constant<bool, false> {};
template<class T> struct is_arithmetic : integral_constant<bool, false> {};
template<class T> struct is_scalar : integral_constant<bool, false> {};
template<class T> struct is_object : integral_constant<bool, false> {};
template<class T> struct is_compound : integral_constant<bool, false> {};
template<class T> struct is_reference : integral_constant<bool, false> {};
template<class T> struct is_member_pointer : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_fundamental_v = false;
template<class T> inline constexpr bool is_arithmetic_v = false;
template<class T> inline constexpr bool is_scalar_v = false;
template<class T> inline constexpr bool is_object_v = false;
template<class T> inline constexpr bool is_compound_v = false;
template<class T> inline constexpr bool is_reference_v = false;
template<class T> inline constexpr bool is_member_pointer_v = false;
#endif

// type properties
template<class T> struct is_const : integral_constant<bool, false> {};
template<class T> struct is_volatile : integral_constant<bool, false> {};
template<class T> struct is_trivial : integral_constant<bool, false> {};
template<class T> struct is_trivially_copyable : integral_constant<bool, false> {};
template<class T> struct is_standard_layout : integral_constant<bool, false> {};
template<class T> struct is_pod : integral_constant<bool, false> {};
template<class T> struct is_literal_type : integral_constant<bool, false> {};
template<class T> struct is_empty : integral_constant<bool, false> {};
template<class T> struct is_polymorphic : integral_constant<bool, false> {};
#if CPPREFERENCE_STDVER >= 2014
template<class T> struct is_final : integral_constant<bool, false> {};
#endif
template<class T> struct is_abstract : integral_constant<bool, false> {};
template<class T> struct is_signed : integral_constant<bool, false> {};
template<class T> struct is_unsigned : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_const_v = false;
template<class T> inline constexpr bool is_volatile_v = false;
template<class T> inline constexpr bool is_trivial_v = false;
template<class T> inline constexpr bool is_trivially_copyable_v = false;
template<class T> inline constexpr bool is_standard_layout_v = false;
template<class T> inline constexpr bool is_pod_v = false;
template<class T> inline constexpr bool is_literal_type_v = false;
template<class T> inline constexpr bool is_empty_v = false;
template<class T> inline constexpr bool is_polymorphic_v = false;
template<class T> inline constexpr bool is_final_v = false;
template<class T> inline constexpr bool is_abstract_v = false;
template<class T> inline constexpr bool is_signed_v = false;
template<class T> inline constexpr bool is_unsigned_v = false;
#endif

// supported operations
template<class T, class... Args> struct is_constructible : integral_constant<bool, false> {};
template<class T, class... Args> struct is_trivially_constructible : integral_constant<bool, false> {};
template<class T, class... Args> struct is_nothrow_constructible : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T, class... Args> inline constexpr bool is_constructible_v = false;
template<class T, class... Args> inline constexpr bool is_trivially_constructible_v = false;
template<class T, class... Args> inline constexpr bool is_nothrow_constructible_v = false;
#endif

template<class T> struct is_default_constructible : integral_constant<bool, false> {};
template<class T> struct is_trivially_default_constructible : integral_constant<bool, false> {};
template<class T> struct is_nothrow_default_constructible : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_default_constructible_v = false;
template<class T> inline constexpr bool is_trivially_default_constructible_v = false;
template<class T> inline constexpr bool is_nothrow_default_constructible_v = false;
#endif

template<class T> struct is_copy_constructible : integral_constant<bool, false> {};
template<class T> struct is_trivially_copy_constructible : integral_constant<bool, false> {};
template<class T> struct is_nothrow_copy_constructible : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_copy_constructible_v = false;
template<class T> inline constexpr bool is_trivially_copy_constructible_v = false;
template<class T> inline constexpr bool is_nothrow_copy_constructible_v = false;
#endif

template<class T> struct is_move_constructible : integral_constant<bool, false> {};
template<class T> struct is_trivially_move_constructible : integral_constant<bool, false> {};
template<class T> struct is_nothrow_move_constructible : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_move_constructible_v = false;
template<class T> inline constexpr bool is_trivially_move_constructible_v = false;
template<class T> inline constexpr bool is_nothrow_move_constructible_v = false;
#endif

template<class T, class U> struct is_assignable : integral_constant<bool, false> {};
template<class T, class U> struct is_trivially_assignable : integral_constant<bool, false> {};
template<class T, class U> struct is_nothrow_assignable : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T, class U> inline constexpr bool is_assignable_v = false;
template<class T, class U> inline constexpr bool is_trivially_assignable_v = false;
template<class T, class U> inline constexpr bool is_nothrow_assignable_v = false;
#endif

template<class T> struct is_copy_assignable : integral_constant<bool, false> {};
template<class T> struct is_trivially_copy_assignable : integral_constant<bool, false> {};
template<class T> struct is_nothrow_copy_assignable : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_copy_assignable_v = false;
template<class T> inline constexpr bool is_trivially_copy_assignable_v = false;
template<class T> inline constexpr bool is_nothrow_copy_assignable_v = false;
#endif

template<class T> struct is_move_assignable : integral_constant<bool, false> {};
template<class T> struct is_trivially_move_assignable : integral_constant<bool, false> {};
template<class T> struct is_nothrow_move_assignable : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_move_assignable_v = false;
template<class T> inline constexpr bool is_trivially_move_assignable_v = false;
template<class T> inline constexpr bool is_nothrow_move_assignable_v = false;
#endif

template<class T> struct is_destructible : integral_constant<bool, false> {};
template<class T> struct is_trivially_destructible : integral_constant<bool, false> {};
template<class T> struct is_nothrow_destructible : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool is_destructible_v = false;
template<class T> inline constexpr bool is_trivially_destructible_v = false;
template<class T> inline constexpr bool is_nothrow_destructible_v = false;
#endif

template<class T> struct has_virtual_destructor : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr bool has_virtual_destructor_v = false;
#endif

// property queries
template<class T> struct alignment_of : integral_constant<size_t, 0> {};
template<class T> struct rank : integral_constant<size_t, 0> {};
template<class T, unsigned I = 0> struct extent : integral_constant<size_t, 0> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T> inline constexpr size_t alignment_of_v = 0;
template<class T> inline constexpr size_t rank_v = 0;
template<class T, unsigned I = 0> inline constexpr size_t extent_v = 0;
#endif

// type relationships
template<class T, class U> struct is_same : integral_constant<bool, false> {};
template<class Base, class Derived> struct is_base_of : integral_constant<bool, false> {};
template<class From, class To> struct is_convertible : integral_constant<bool, false> {};

#if CPPREFERENCE_STDVER >= 2014
template<class T, class U> inline constexpr bool is_same_v = false;
template<class Base, class Derived> inline constexpr bool is_base_of_v = false;
template<class From, class To> inline constexpr bool is_convertible_v = false;
#endif

// const-volatility specifiers
template<class T> struct remove_cv {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct remove_const {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct remove_volatile {
    typedef T type; // SIMPLIFIED type
};

#if CPPREFERENCE_STDVER >= 2014
template<class T>
using remove_cv_t = T; // SIMPLIFIED typedef
template<class T>
using remove_const_t = T; // SIMPLIFIED typedef
template<class T>
using remove_volatile_t = T; // SIMPLIFIED typedef
#endif

template<class T> struct add_cv {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct add_const {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct add_volatile {
    typedef T type; // SIMPLIFIED type
};

#if CPPREFERENCE_STDVER >= 2014
template<class T>
using add_cv_t = T; // SIMPLIFIED typedef
template<class T>
using add_const_t = T; // SIMPLIFIED typedef
template<class T>
using add_volatile_t = T; // SIMPLIFIED typedef
#endif

// references
template<class T> struct remove_reference {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct add_lvalue_reference {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct add_rvalue_reference {
    typedef T type; // SIMPLIFIED type
};

#if CPPREFERENCE_STDVER >= 2014
template<class T>
using remove_reference_t = T; // SIMPLIFIED typedef
template<class T>
using add_lvalue_reference_t = T; // SIMPLIFIED typedef
template<class T>
using add_rvalue_reference_t = T; // SIMPLIFIED typedef
#endif

// pointers
template<class T> struct remove_pointer {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct add_pointer {
    typedef T* type; // SIMPLIFIED type
};

#if CPPREFERENCE_STDVER >= 2014
template<class T>
using remove_pointer_t = T; // SIMPLIFIED typedef
template<class T>
using add_pointer_t = T*; // SIMPLIFIED typedef
#endif

// sign modifiers
template<class T> struct make_signed {
    typedef T type; // SIMPLIFIED type
};
template<class T> struct make_unsigned {
    typedef T type; // SIMPLIFIED type
};

#if CPPREFERENCE_STDVER >= 2014
template<class T>
using make_signed_t = T; // SIMPLIFIED typedef
template<class T>
using make_unsigned_t = T; // SIMPLIFIED typedef
#endif

// arrays
template<class T> struct remove_extent {
    typedef T type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<class T>
using remove_extent_t = T; // SIMPLIFIED typedef
#endif

template<class T> struct remove_all_extents {
    typedef T type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<class T>
using remove_all_extents_t = T; // SIMPLIFIED typedef
#endif

// miscellaneous transformations
template<size_t Len, size_t Align = 0> struct aligned_storage {
    typedef int type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<size_t Len, size_t Align = 0>
using aligned_storage_t = int; // SIMPLIFIED typedef
#endif

template<size_t Len, class... Types> struct aligned_union {
    typedef int type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<size_t Len, class... Types>
using aligned_union_t = int; // SIMPLIFIED typedef
#endif

template<class T> struct decay {
    typedef T type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<class T>
using decay_t = T; // SIMPLIFIED typedef
#endif

#if CPPREFERENCE_SIMPLIFY_TYPEDEFS

template<bool, class T = void> struct enable_if {
    typedef int type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<bool, class T = void>
using enable_if_t = int; // SIMPLIFIED typedef
#endif

#else

template<bool, class T = void> struct enable_if {};

template<class T>
struct enable_if<true, T> {
    typedef T type;
};
#if CPPREFERENCE_STDVER >= 2014
template<bool B, class T = void>
using enable_if_t = typename enable_if<B, T>::type;
#endif

#endif // CPPREFERENCE_SIMPLIFY_TYPEDEFS

template<bool, class T, class F> struct conditional {
    typedef int type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<bool, class T, class F>
using conditional_t = int; // SIMPLIFIED typedef
#endif

template<class... T> struct common_type {
    typedef int type;
};
#if CPPREFERENCE_STDVER >= 2014
template<class... T>
using common_type_t = int;
#endif

template<class T> struct underlying_type {
    typedef int type; // SIMPLIFIED type
};
#if CPPREFERENCE_STDVER >= 2014
template<class T>
using underlying_type_t = int; // SIMPLIFIED typedef
#endif

#if CPPREFERENCE_STDVER < 2020
template<class F, class... ArgTypes>
class result_of {
    typedef int type;
}; // SIMPLIFIED: removed specializations
#endif

#if CPPREFERENCE_STDVER >= 2014 && CPPREFERENCE_STDVER < 2020
template<class F, class... ArgTypes>
using result_of_t = int; // SIMPLIFIED typedef
#endif

#if CPPREFERENCE_STDVER >= 2017
template<class F, class... ArgTypes>
class invoke_result {
    typedef int type;
}; // SIMPLIFIED: removed specializations

template<class F, class... ArgTypes>
using invoke_result_t = int; // SIMPLIFIED typedef
#endif

} // namespace std

#endif // CPPREFERENCE_STDVER>= 2011

#endif // CPPREFERENCE_TYPE_TRAITS_H