Namespace detail

Description

No description yet.

Structures

at_least
character
conjunction
conjunction< T >
conjunction< T, Ts... >
disjunction
disjunction< T >
disjunction< T, Ts... >
either
either< Head >
either< Head, Tail... >
empty_iterator
enum_to_type
enum_to_type< value_t::array, Value >
enum_to_type< value_t::boolean, Value >
enum_to_type< value_t::empty, Value >
enum_to_type< value_t::floating, Value >
enum_to_type< value_t::integer, Value >
enum_to_type< value_t::local_date, Value >
enum_to_type< value_t::local_datetime, Value >
enum_to_type< value_t::local_time, Value >
enum_to_type< value_t::offset_datetime, Value >
enum_to_type< value_t::string, Value >
enum_to_type< value_t::table, Value >
exactly
exclude
has_from_toml_method
has_from_toml_method_impl
has_into_toml_method
has_into_toml_method_impl
has_iteratorIntel C++ compiler can not use decltype in parent class declaration, here is a hack to work around it
has_iterator_impl
has_key_type
has_key_type_impl
has_mapped_type
has_mapped_type_impl
has_push_back_method
has_push_back_method_impl
has_reserve_method
has_reserve_method_impl
has_specialized_from
has_specialized_from_impl
has_specialized_into
has_specialized_into_impl
has_value_type
has_value_type_impl
in_range
index_sequence
index_sequence_maker
index_sequence_maker< 0 >
is_basic_value
is_basic_value< T & >
is_basic_value< T const & >
is_basic_value< T const volatile & >
is_basic_value< T volatile & >
is_basic_value<::toml::basic_value< C, M, V > >
is_chrono_duration
is_chrono_duration< std::chrono::duration< Rep, Period > >
is_comparable
is_comparable_impl
is_container
is_container< T & >
is_container< T const & >
is_container< T const volatile & >
is_container< T volatile & >
is_exact_toml_type
is_exact_toml_type< T &, V >
is_exact_toml_type< T const &, V >
is_exact_toml_type< T const volatile &, V >
is_exact_toml_type< T volatile &, V >
is_map
is_map< T & >
is_map< T const & >
is_map< T const volatile & >
is_map< T volatile & >
is_std_forward_list
is_std_forward_list< std::forward_list< T > >
is_std_pair
is_std_pair< std::pair< T1, T2 > >
is_std_tuple
is_std_tuple< std::tuple< Ts... > >
is_string_literal
last_one_in_pack
last_one_in_pack< T >
location
maybe
negation
none_t
push_back_index_sequence
push_back_index_sequence< index_sequence< Ns... >, N >
region
region_base
remove_cvref
repeat
repeat< T, at_least< N > >
repeat< T, exactly< N > >
repeat< T, unlimited >
sequence
sequence< Head >
sequence< Head, Tail... >
storage
switch_cast
type_to_enum
type_to_enum< boolean, Value >
type_to_enum< floating, Value >
type_to_enum< integer, Value >
type_to_enum< local_date, Value >
type_to_enum< local_datetime, Value >
type_to_enum< local_time, Value >
type_to_enum< offset_datetime, Value >
type_to_enum< string, Value >
unlimited

Functions

change_region
comment_index
concat_to_string_impl overload
format_dotted_keys
format_underline
get_region
get_tuple_impl
gmtime_s
insert_nested_key
is_valid_forward_table_definition
key_cast overload
last_one overload
localtime_s

Mentioned in

make_string overload
none
operator!= overload
operator+ overload
operator-
operator< overload
operator<<
operator<= overload
operator== overload
operator> overload
operator>= overload
parse_array
parse_basic_string
parse_binary_integer
parse_boolean
parse_escape_sequence
parse_floating
parse_hexadecimal_integer
parse_integer
parse_key
parse_key_value_pair
parse_literal_string
parse_local_date
parse_local_datetime
parse_local_time
parse_ml_basic_string
parse_ml_literal_string
parse_octal_integer
parse_offset_datetime
parse_simple_key
parse_string
parse_table_key
parse_value
read_utf8_codepoint

Mentioned in

show_char
throw_bad_cast
throw_key_not_found_error
try_reserve_impl overload

Typedefs

Typedefs (lexer.hpp)

using lex_wschar = either< character<' '>, character<'\t'> >

using lex_ws = repeat< lex_wschar, at_least< 1 > >

using lex_newline = either< character<'\n'>, sequence< character<'\r'>, character<'\n'> >>

using lex_lower = in_range< 'a', 'z'>

using lex_upper = in_range< 'A', 'Z'>

using lex_alpha = either< lex_lower, lex_upper >

using lex_digit = in_range< '0', '9'>

using lex_nonzero = in_range< '1', '9'>

using lex_oct_dig = in_range< '0', '7'>

using lex_bin_dig = in_range< '0', '1'>

using lex_hex_dig = either< lex_digit, in_range< 'A', 'F'>, in_range< 'a', 'f'> >

using lex_hex_prefix = sequence< character< '0'>, character< 'x'> >

using lex_oct_prefix = sequence< character< '0'>, character< 'o'> >

using lex_bin_prefix = sequence< character< '0'>, character< 'b'> >

using lex_underscore = character< '_'>

using lex_plus = character<'+'>

using lex_minus = character<'-'>

using lex_sign = either< lex_plus, lex_minus >

using lex_unsigned_dec_int = either< sequence< lex_nonzero, repeat< either< lex_digit, sequence< lex_underscore, lex_digit > >, at_least< 1 > >>, lex_digit >

using lex_dec_int = sequence< maybe< lex_sign >, lex_unsigned_dec_int >

using lex_hex_int = sequence< lex_hex_prefix, sequence< lex_hex_dig, repeat< either< lex_hex_dig, sequence< lex_underscore, lex_hex_dig > >, unlimited > >>

using lex_oct_int = sequence< lex_oct_prefix, sequence< lex_oct_dig, repeat< either< lex_oct_dig, sequence< lex_underscore, lex_oct_dig > >, unlimited > >>

using lex_bin_int = sequence< lex_bin_prefix, sequence< lex_bin_dig, repeat< either< lex_bin_dig, sequence< lex_underscore, lex_bin_dig > >, unlimited > >>

using lex_integer = either< lex_bin_int, lex_oct_int, lex_hex_int, lex_dec_int >

using lex_inf = sequence< character< 'i'>, character< 'n'>, character< 'f'> >

using lex_nan = sequence< character< 'n'>, character< 'a'>, character< 'n'> >

using lex_special_float = sequence< maybe< lex_sign >, either< lex_inf, lex_nan > >

using lex_zero_prefixable_int = sequence< lex_digit, repeat< either< lex_digit, sequence< lex_underscore, lex_digit > >, unlimited > >

using lex_fractional_part = sequence< character<'.'>, lex_zero_prefixable_int >

using lex_exponent_part = sequence< either< character< 'e'>, character< 'E'> >, maybe< lex_sign >, lex_zero_prefixable_int >

using lex_float = either< lex_special_float, sequence< lex_dec_int, either< lex_exponent_part, sequence< lex_fractional_part, maybe< lex_exponent_part > >> >>

using lex_true = sequence< character< 't'>, character< 'r'>, character< 'u'>, character< 'e'> >

using lex_false = sequence< character< 'f'>, character< 'a'>, character< 'l'>, character< 's'>, character< 'e'> >

using lex_boolean = either< lex_true, lex_false >

using lex_date_fullyear = repeat< lex_digit, exactly< 4 > >

using lex_date_month = repeat< lex_digit, exactly< 2 > >

using lex_date_mday = repeat< lex_digit, exactly< 2 > >

using lex_time_delim = either< character< 'T'>, character< 't'>, character<' '> >

using lex_time_hour = repeat< lex_digit, exactly< 2 > >

using lex_time_minute = repeat< lex_digit, exactly< 2 > >

using lex_time_second = repeat< lex_digit, exactly< 2 > >

using lex_time_secfrac = sequence< character<'.'>, repeat< lex_digit, at_least< 1 > >>

using lex_time_numoffset = sequence< either< character<'+'>, character<'-'> >, sequence< lex_time_hour, character<':'>, lex_time_minute > >

using lex_time_offset = either< character< 'Z'>, character< 'z'>, lex_time_numoffset >

using lex_partial_time = sequence< lex_time_hour, character<':'>, lex_time_minute, character<':'>, lex_time_second, maybe< lex_time_secfrac > >

using lex_full_date = sequence< lex_date_fullyear, character<'-'>, lex_date_month, character<'-'>, lex_date_mday >

using lex_full_time = sequence< lex_partial_time, lex_time_offset >

using lex_offset_date_time = sequence< lex_full_date, lex_time_delim, lex_full_time >

using lex_local_date_time = sequence< lex_full_date, lex_time_delim, lex_partial_time >

using lex_local_date = lex_full_date

using lex_local_time = lex_partial_time

using lex_quotation_mark = character<'"'>

using lex_basic_unescaped = exclude< either< in_range< 0x00, 0x08 >, in_range< 0x0a, 0x1F >, character< 0x22 >, character< 0x5C >, character< 0x7F > >>

using lex_escape = character<'\\'>

using lex_escape_unicode_short = sequence< character< 'u'>, repeat< lex_hex_dig, exactly< 4 > >>

using lex_escape_unicode_long = sequence< character< 'U'>, repeat< lex_hex_dig, exactly< 8 > >>

using lex_escape_seq_char = either< character<'"'>, character<'\\'>, character<'b'>, character<'f'>, character<'n'>, character<'r'>, character<'t'>, lex_escape_unicode_short, lex_escape_unicode_long >

using lex_escaped = sequence< lex_escape, lex_escape_seq_char >

using lex_basic_char = either< lex_basic_unescaped, lex_escaped >

using lex_basic_string = sequence< lex_quotation_mark, repeat< lex_basic_char, unlimited >, lex_quotation_mark >

using lex_ml_basic_string_delim = repeat< lex_quotation_mark, exactly< 3 > >

using lex_ml_basic_string_open = lex_ml_basic_string_delim

using lex_ml_basic_string_close = sequence< repeat< lex_quotation_mark, exactly< 3 > >, maybe< lex_quotation_mark >, maybe< lex_quotation_mark > >

using lex_ml_basic_unescaped = exclude< either< in_range< 0x00, 0x08 >, in_range< 0x0a, 0x1F >, character< 0x5C >, character< 0x7F >, lex_ml_basic_string_delim > >

using lex_ml_basic_escaped_newline = sequence< lex_escape, maybe< lex_ws >, lex_newline, repeat< either< lex_ws, lex_newline >, unlimited > >

using lex_ml_basic_char = either< lex_ml_basic_unescaped, lex_escaped >

using lex_ml_basic_body = repeat< either< lex_ml_basic_char, lex_newline, lex_ml_basic_escaped_newline >, unlimited >

using lex_ml_basic_string = sequence< lex_ml_basic_string_open, lex_ml_basic_body, lex_ml_basic_string_close >

using lex_literal_char = exclude< either< in_range< 0x00, 0x08 >, in_range< 0x10, 0x19 >, character< 0x27 > >>

using lex_apostrophe = character<'\''>

using lex_literal_string = sequence< lex_apostrophe, repeat< lex_literal_char, unlimited >, lex_apostrophe >

using lex_ml_literal_string_delim = repeat< lex_apostrophe, exactly< 3 > >

using lex_ml_literal_string_open = lex_ml_literal_string_delim

using lex_ml_literal_string_close = sequence< repeat< lex_apostrophe, exactly< 3 > >, maybe< lex_apostrophe >, maybe< lex_apostrophe > >

using lex_ml_literal_char = exclude< either< in_range< 0x00, 0x08 >, in_range< 0x10, 0x1F >, character< 0x7F >, lex_ml_literal_string_delim > >

using lex_ml_literal_body = repeat< either< lex_ml_literal_char, lex_newline >, unlimited >

using lex_ml_literal_string = sequence< lex_ml_literal_string_open, lex_ml_literal_body, lex_ml_literal_string_close >

using lex_string = either< lex_ml_basic_string, lex_basic_string, lex_ml_literal_string, lex_literal_string >

using lex_comment_start_symbol = character<'#'>

using lex_non_eol = either< character<'\t'>, exclude< in_range< 0x00, 0x19 > >>

using lex_comment = sequence< lex_comment_start_symbol, repeat< lex_non_eol, unlimited > >

using lex_dot_sep = sequence< maybe< lex_ws >, character<'.'>, maybe< lex_ws > >

using lex_unquoted_key = repeat< either< lex_alpha, lex_digit, character<'-'>, character< '_'> >, at_least< 1 > >

using lex_quoted_key = either< lex_basic_string, lex_literal_string >

using lex_simple_key = either< lex_unquoted_key, lex_quoted_key >

using lex_dotted_key = sequence< lex_simple_key, repeat< sequence< lex_dot_sep, lex_simple_key >, at_least< 1 > > >

using lex_key = either< lex_dotted_key, lex_simple_key >

using lex_keyval_sep = sequence< maybe< lex_ws >, character<'='>, maybe< lex_ws > >

using lex_std_table_open = character<'['>

using lex_std_table_close = character<']'>

using lex_std_table = sequence< lex_std_table_open, maybe< lex_ws >, lex_key, maybe< lex_ws >, lex_std_table_close >

using lex_array_table_open = sequence< lex_std_table_open, lex_std_table_open >

using lex_array_table_close = sequence< lex_std_table_close, lex_std_table_close >

using lex_array_table = sequence< lex_array_table_open, maybe< lex_ws >, lex_key, maybe< lex_ws >, lex_array_table_close >

Typedefs (traits.hpp)

template <std::size_t N>
using make_index_sequence = typename index_sequence_maker< N-1 >::type

template <bool B, typename T>
using enable_if_t = typename std::enable_if< B, T >::type

template <typename F, typename ... Args>
using return_type_of_t = typename std::result_of< F(Args...)>::type

template <typename T>
using remove_cvref_t = typename remove_cvref< T >::type

Typedefs (types.hpp)

template <value_t V>
using value_t_constant = std::integral_constant< value_t, V >

Typedefs (utility.hpp)

template <typename ... Ts>
using last_one_in_pack_t = typename last_one_in_pack< Ts... >::type

Source

Line 26 in toml/combinator.hpp.






Add Discussion as Guest

Log in