Namespace detail

Description

\exclude

Classes

aligned_union
assert_handler
bool_sequence
bounded_type_impl
bounded_type_impl< Verifier, LowerInclusive, UpperInclusive, T, LowerBound, T >
bounded_type_impl< Verifier, LowerInclusive, UpperInclusive, T, T, T >
bounded_type_impl< Verifier, LowerInclusive, UpperInclusive, T, T, UpperBound >
common_type
common_type< A, void >
common_type< void, A >
common_type< void, void >
compare_variant
compatible_return_type
conditional_impl
conditional_impl< Else >
conditional_impl< std::false_type, Result, Tail... >
conditional_impl< std::true_type, Result, Tail... >
copy_assign_union_value
copy_control
copy_control< false >
copy_control< true >
copy_union
decimal_digit
destroy_union
enable_matching_function
flag_set_impl
get_callable_tag
get_flag_set_impl
get_target_floating_point
get_target_floating_point< floating_point< T > >
get_target_integer
get_target_integer< integer< T, Policy >, Policy >
get_type_index_impl
get_type_index_impl< T >
get_type_index_impl< T, Head, Tail... >
get_type_index_impl< T, T, Tail... >
invalid_functor_tag
is_boolean
is_boolean< bool >
is_boolean< boolean >
is_direct_assignable
is_flag_combo
is_flag_combo< Enum, Enum >
is_flag_combo< flag_combo< Enum >, Enum >
is_flag_set
is_flag_set< Enum, decltype(static_cast< void >(Enum::_flag_set_size))>
is_integer
is_nothrow_swappable
is_optional_impl
is_optional_impl< basic_optional< StoragePolicy > >
is_safe_integer_comparison
is_safe_integer_conversion
is_safe_integer_operation
is_valid
is_variant_impl
is_variant_impl< basic_variant< VariantPolicy, Head, Types... > >
lower_hexadecimal_digit
make_signed
make_signed< integer< T, Policy > >
make_unsigned
make_unsigned< integer< T, Policy > >
map_union
matching_function_pointer_tag
matching_functor_tag
member_size
move_assign_union_value
move_control
move_control< false >
move_control< true >
move_union
no_digit
no_size
non_empty_variant_policy
non_member_size
optional_storage
parse_base
parse_base< T, '0', 'b', Tail... >
parse_base< T, '0', 'B', Tail... >
parse_base< T, '0', 'x', Tail... >
parse_base< T, '0', 'X', Tail... >
parse_base< T, '0', Head, Tail... >
parse_loop
parse_loop< Head, Tail... >
parse_loop<'\'', Tail... >
parse_loop<>
precondition_error_handler
rebind_object_ref_impl
rebind_object_ref_impl< object_ref< T, XValue1 >, XValue2 >
select_flag_set_int
select_variant_policy
select_variant_policy< nullvar_t, Types... >
signed_integer_tag
storage_access
swap_union
to_digit_impl
to_digit_impl< C, decimal_digit >
to_digit_impl< C, lower_hexadecimal_digit >
to_digit_impl< C, upper_hexadecimal_digit >
traits_impl
union_type_id
unsigned_integer_tag
upper_hexadecimal_digit
valid_bound
variant_storage
visit_optional
visit_optional< Save, Visitor, Optional >
visit_optional< Save, Visitor, Optional, Rest... >
visit_variant_impl
visit_variant_impl< AllowIncomplete, Visitor >
visit_variant_impl< AllowIncomplete, Visitor, Variant >
visit_variant_impl< AllowIncomplete, Visitor, Variant, Rest... >
visitor_allow_incomplete
with_union
with_union< Func, Union, union_types< Types... >, Args... >

Functions

do_parse_loop
flag_set_size overload
get_dummy_type overload
index_valid overload
is_empty overload
is_narrowing overload
is_safe_downcast overload
map_invoke overload
max overload
move_if overload
on_disabled_exception
operator!= overload
operator&
operator== overload
operator| overload
operator~ overload
parse
parse_signed
parse_unsigned
sizeof
to_digit
TYPE_SAFE_DETAIL_SELECT overload
underlying_type
validate_downcast
validate_value
verify_static_constrained overload
visit_optional_impl
visit_variant
will_addition_error overload
will_division_error overload
will_modulo_error overload
will_multiplication_error overload
will_subtraction_error overload

Typedefs

Typedefs (arithmetic_policy.hpp)

template <typename T>
using arithmetic_tag_for = typename std::conditional< std::is_signed< T >::value, signed_integer_tag, unsigned_integer_tag >::type

Typedefs (boolean.hpp)

template <typename T>
using enable_boolean = typename std::enable_if< is_boolean< T >::value >::type

Typedefs (bounded_type.hpp)

template <class Verifier, bool LowerInclusive, bool UpperInclusive, typename T, typename U1, typename U2>
using make_bounded_type = typename bounded_type_impl< Verifier, LowerInclusive, UpperInclusive, typename std::decay< T >::type, typename std::decay< U1 >::type, typename std::decay< U2 >::type >::type

Typedefs (compact_optional.hpp)

template <typename StorageType, typename ValueType, typename T>
using storage_reference = typename std::conditional< std::is_same< StorageType, ValueType >::value, T, ValueType >::type

Typedefs (aligned_union.hpp)

template <typename... Types>
using aligned_union_t = typename aligned_union< Types... >::type

Typedefs (all_of.hpp)

template <bool... Bs>
using all_of = std::is_same< bool_sequence< Bs... >, bool_sequence<(true||Bs)... > >

template <bool... Bs>
using none_of = std::is_same< bool_sequence< Bs... >, bool_sequence<(false &&Bs)... > >

template <bool... Bs>
using any_of = std::integral_constant< bool, !none_of< Bs... >::value >

Typedefs (constant_parser.hpp)

template <typename... Ts>
using conditional = typename conditional_impl< Ts... >::type

template <bool Value>
using bool_constant = std::integral_constant< bool, Value >

template <char C>
using digit_category = conditional< bool_constant< C >='0' &&C<='9'>, decimal_digit, bool_constant< C >='a' &&C<='f'>, lower_hexadecimal_digit, bool_constant< C >='A' &&C<='F'>, upper_hexadecimal_digit, no_digit >

Typedefs (variant_impl.hpp)

template <typename T>
using is_variant = is_variant_impl< typename std::decay< T >::type >

template <typename... Types>
using traits = traits_impl< typename std::decay< Types >::type... >

template <typename... Types>
using variant_copy = copy_control< traits< Types... >::copy_constructible::value >

template <typename... Types>
using variant_move = move_control< traits< Types... >::move_constructible::value >

template <class Union, typename T, typename... Args>
using enable_variant_type_impl = typename std::enable_if< Union::type_id::template is_valid< T >() &&std::is_constructible< T, Args... >::value >::type

template <class Union, typename T, typename... Args>
using enable_variant_type = enable_variant_type_impl< Union, typename std::decay< T >::type, Args... >

Typedefs (flag_set.hpp)

template <typename Enum>
using flag_combo = flag_set_impl< Enum, struct combo_tag >

template <typename Enum>
using flag_mask = flag_set_impl< Enum, struct mask_tag >

template <typename T>
using enable_flag = typename std::enable_if< flag_set_traits< T >::value >::type

template <typename T, typename Enum>
using enable_flag_combo = typename std::enable_if< is_flag_combo< T, Enum >::value >::type

Typedefs (integer.hpp)

template <typename From, typename To>
using enable_safe_integer_conversion = typename std::enable_if< is_safe_integer_conversion< From, To >::value >::type

template <typename From, typename To>
using fallback_safe_integer_conversion = typename std::enable_if<!is_safe_integer_conversion< From, To >::value >::type

template <typename A, typename B>
using enable_safe_integer_comparison = typename std::enable_if< is_safe_integer_comparison< A, B >::value >::type

template <typename A, typename B>
using fallback_safe_integer_comparison = typename std::enable_if<!is_safe_integer_comparison< A, B >::value >::type

Typedefs (optional.hpp)

template <typename T>
using optional_copy = copy_control< std::is_copy_constructible< T >::value >

template <typename T>
using optional_move = move_control< std::is_move_constructible< T >::value >

template <typename T>
using is_optional = is_optional_impl< typename std::decay< T >::type >

template <typename TraitsResult, typename Fallback>
using select_optional_storage_policy = typename std::conditional< std::is_same< TraitsResult, void >::value, Fallback, TraitsResult >::type

template <typename T, typename Fallback>
using rebind_optional = typename std::conditional< std::is_void< T >::value, void, basic_optional< select_optional_storage_policy< typename optional_storage_policy_for< T >::type, Fallback > >>::type

Typedefs (reference.hpp)

template <typename T, bool XValue>
using rebind_object_ref = typename rebind_object_ref_impl< typename std::remove_reference< T >::type, XValue >::type

template <typename Result, typename Func, typename Return, typename... Args>
using enable_function_tag = typename std::enable_if< std::is_same< typename get_callable_tag< Func, Return, Args... >::type, Result >::value, int >::type

Typedefs (tagged_union.hpp)

template <typename T, typename... Types>
using get_type_index = get_type_index_impl< T, typename std::decay< Types >::type... >

Typedefs (visitor.hpp)

template <typename A, typename B>
using common_type_t = typename common_type< A, B >::type

Source

Line 56 in include/type_safe/arithmetic_policy.hpp.






Add Discussion as Guest

Log in