C++ Library Extensions 2022.12.09
To help learn modern C++ programming
tpf_types.hpp File Reference

Type functions are implemented. More...

#include <iostream>
#include <iomanip>
#include <sstream>
#include <numeric>
#include <type_traits>
#include <string>
#include <cstring>
#include <vector>
#include <deque>
#include <exception>
#include <variant>
#include <tuple>
#include <array>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <list>
#include <any>
#include <functional>
#include <future>
#include <thread>
#include <atomic>
#include <mutex>
#include <memory>
#include <iterator>
#include <execution>
#include <ratio>
#include <optional>
#include <string_view>
#include <cassert>
Include dependency graph for tpf_types.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  tpf::debug_exception
 This class implements all debugging requirements for C++ Library Extension. More...
 
class  tpf::types::tag_type< Type, Tag >
 
struct  tpf::types::hidden::st_is_tag_type_v< Type >
 
struct  tpf::types::hidden::st_is_tag_type_v< tag_type< Type, Tag > >
 
struct  tpf::types::hidden::st_is_numbers_type_v< Type >
 
struct  tpf::types::hidden::st_is_numbers_type_v< ContainerType< Ints... > >
 
struct  tpf::types::hidden::st_make_non_class_wrapper< Type, Tag, bool >
 
struct  tpf::types::hidden::st_make_non_class_wrapper< Type, Tag, true >
 
struct  tpf::types::type_list_t< Types >
 This type is used to manipulate type list. More...
 
struct  tpf::types::numbers_t< Ints >
 
struct  tpf::types::hidden::st_is_vector_v< Type >
 
struct  tpf::types::hidden::st_is_vector_v< std::vector< Type, Types... > >
 
struct  tpf::types::hidden::st_is_integer_sequence< Type >
 
struct  tpf::types::hidden::st_is_integer_sequence< std::integer_sequence< Type, Indices... > >
 
struct  tpf::types::hidden::st_is_type_list< T >
 
struct  tpf::types::hidden::st_is_type_list< type_list_t< Ts... > >
 
struct  tpf::types::hidden::st_recursive_type_list< T >
 
struct  tpf::types::hidden::st_recursive_type_list< TemplateType< Types... > >
 
struct  tpf::types::hidden::st_is_template_type< Type >
 
struct  tpf::types::hidden::st_is_template_type< TemplateType< Types... > >
 
struct  tpf::types::hidden::st_is_template_type< TemplateType< T, args... > >
 
struct  tpf::types::hidden::st_is_template_type< TemplateType< args... > >
 
struct  tpf::types::hidden::st_is_template_type< TemplateType< arg, Types... > >
 
struct  tpf::types::hidden::st_type_list_to_tuple_of_vectors< Types >
 
struct  tpf::types::hidden::st_type_list_to_tuple_of_vectors< type_list_t< Types... > >
 
struct  tpf::types::hidden::st_type_list_to_tuple_of_vectors< CntrType< Types... > >
 
struct  tpf::types::hidden::st_tuple_to_type_list< std::tuple< Types... > >
 
struct  tpf::types::hidden::st_type_list_to_tuple< type_list_t< Types... > >
 
struct  tpf::types::hidden::st_variant_to_type_list< std::variant< Types... > >
 
struct  tpf::types::hidden::st_vector< I >
 
struct  tpf::types::hidden::st_index_tuple_vector< std::index_sequence< Is... > >
 
struct  tpf::types::array_wrapper_t< PointerType, SizeType >
 
struct  tpf::types::hidden::st_dummy_type_container< Type >
 
struct  tpf::types::range< Type >
 
struct  tpf::thread_bundle
 
struct  tpf::boolean
 
struct  tpf::types::hidden::is_variant_st< Type >
 
struct  tpf::types::hidden::is_variant_st< std::variant< Types... > >
 
struct  tpf::types::hidden::is_unique_ptr_st< Type >
 
struct  tpf::types::hidden::is_unique_ptr_st< std::unique_ptr< Type, Types... > >
 
struct  tpf::types::hidden::is_pair_st< Type >
 
struct  tpf::types::hidden::is_pair_st< std::pair< Type_1, Type_2 > >
 
struct  tpf::types::hidden::is_pair_of_variant_st< Type >
 
struct  tpf::types::hidden::is_pair_of_variant_st< std::pair< Type, Types... > >
 
struct  tpf::types::hidden::is_map_or_unordered_map_st< Type >
 
struct  tpf::types::hidden::is_map_or_unordered_map_st< std::map< KeyType, ValueType, Types... > >
 
struct  tpf::types::hidden::is_map_or_unordered_map_st< std::unordered_map< KeyType, ValueType, Types... > >
 
struct  tpf::types::hidden::is_set_or_unordered_set_st< Type >
 
struct  tpf::types::hidden::is_set_or_unordered_set_st< std::set< Type, Types... > >
 
struct  tpf::types::hidden::is_set_or_unordered_set_st< std::unordered_set< Type, Types... > >
 
struct  tpf::types::hidden::is_tuple_st< Type >
 
struct  tpf::types::hidden::is_tuple_st< std::tuple<> >
 
struct  tpf::types::hidden::is_tuple_st< std::tuple< Type, Types... > >
 
struct  tpf::types::hidden::is_any_st< Type >
 
struct  tpf::types::hidden::is_any_st< std::any >
 
struct  tpf::types::hidden::is_basic_string_st< Type >
 
struct  tpf::types::hidden::is_basic_string_st< std::basic_string< Type, Types... > >
 
struct  tpf::types::hidden::is_basic_string_st< std::basic_string_view< Type, Types... > >
 
struct  tpf::types::hidden::is_char_st< Type >
 
struct  tpf::types::hidden::is_char_st< char >
 
struct  tpf::types::hidden::is_char_st< unsigned char >
 
struct  tpf::types::hidden::st_tuple_size< Type >
 
struct  tpf::types::hidden::st_tuple_size< std::tuple< Type, ArgTypes... > >
 
struct  tpf::set_tag< ContainerType, EleType, Types >
 
struct  tpf::types::no_type_t
 This type is used to test validity of a type. More...
 
struct  tpf::types::void_type_t
 
struct  tpf::types::hidden::return_type_st< Type >
 
struct  tpf::types::hidden::return_type_st< void >
 
struct  tpf::types::hidden::st_is_std_array< Type >
 
struct  tpf::types::hidden::st_is_std_array< std::array< Type, Size > >
 
struct  tpf::types::hidden::st_std_array_element< Type >
 
struct  tpf::types::hidden::st_std_array_element< std::array< Type, Size > >
 
struct  tpf::types::indexer_type< T, Value >
 
struct  tpf::types::indexer_2d_type< T, RowValue, ColumnValue >
 
struct  tpf::types::indexer_3d_type< T, HeightValue, RowValue, ColumnValue >
 
struct  tpf::types::hidden::st_sequence_first_element< T >
 
struct  tpf::types::hidden::st_sequence_first_element< std::integer_sequence< T, First, Remainders... > >
 
struct  tpf::types::hidden::st_sequence_last_element< std::integer_sequence< T, First > >
 
struct  tpf::types::hidden::st_sequence_last_element< std::integer_sequence< T, First, Remainders... > >
 
struct  tpf::types::hidden::st_sequence_nth_element< 0, std::integer_sequence< T, First, Remainders... > >
 
struct  tpf::types::hidden::st_sequence_nth_element< Nth, std::integer_sequence< T, First, Remainders... > >
 
struct  tpf::types::hidden::st_sequence_element_count< T >
 
struct  tpf::types::hidden::st_sequence_element_count< std::integer_sequence< T, Elements... > >
 
struct  tpf::types::hidden::st_revese_sequence_operation< std::integer_sequence< T, args... >, std::integer_sequence< T > >
 
struct  tpf::types::hidden::st_revese_sequence_operation< std::integer_sequence< T, args1... >, std::integer_sequence< T, first, args2... > >
 
struct  tpf::types::hidden::st_reverse_sequence< std::integer_sequence< T, args... > >
 
struct  tpf::types::hidden::st_sequence_element_type< T >
 
struct  tpf::types::hidden::st_sequence_element_type< std::integer_sequence< T, Elements... > >
 
struct  tpf::types::hidden::st_sequence_span< std::integer_sequence< T, First > >
 
struct  tpf::types::hidden::st_sequence_span< std::integer_sequence< T, First, Second, Remainders... > >
 
struct  tpf::types::hidden::st_sequence_info< T, FirstValue, LastValue, CountValue, stack_order >
 
struct  tpf::types::hidden::st_sequence_info< T, FirstValue, LastValue, CountValue, !StackInOrder >
 
struct  tpf::types::hidden::st_workhorse_range< T, BeginValue, EndValue, IncrementValue >
 
struct  tpf::types::hidden::st_create_workhorse_range< SequenceInOrder, EndValue >
 
struct  tpf::types::hidden::st_create_workhorse_range< SequenceInOrder, BeginValue, EndValue >
 
struct  tpf::types::hidden::st_create_workhorse_range< SequenceInOrder, BeginValue, EndValue, IncrementValue >
 
struct  tpf::types::hidden::type_count_st< Types >
 
struct  tpf::types::hidden::type_count_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::type_count_st< TemplateType< Types... > >
 
struct  tpf::types::hidden::is_template_st< Type >
 
struct  tpf::types::hidden::is_template_st< ContainerType< Types... > >
 
struct  tpf::types::hidden::is_template_st< ContainerType< Type, Args... > >
 
struct  tpf::types::hidden::is_same_template_type_st< Type1, Type2 >
 
struct  tpf::types::hidden::is_same_template_type_st< ContainerType< Types... >, ContainerType< Types... > >
 
struct  tpf::types::hidden::is_same_template_type_st< ContainerType< Type, Types... >, ContainerType< Type, Types... > >
 
struct  tpf::types::hidden::is_same_template_type_st< ContainerType< Type1, Type2, Types... >, ContainerType< Type1, Type2, Types... > >
 
struct  tpf::types::hidden::is_same_template_type_st< ContainerType< Type1, Type2, Type3, Types... >, ContainerType< Type1, Type2, Type3, Types... > >
 
struct  tpf::types::hidden::is_same_template_type_st< ContainerType< Type1, Type2, Type3, Type4, Types... >, ContainerType< Type1, Type2, Type3, Type4, Types... > >
 
struct  tpf::types::hidden::is_same_template_st< Type1, Type2 >
 
struct  tpf::types::hidden::is_same_template_st< ContainerType< Types1... >, ContainerType< Types2... > >
 
struct  tpf::types::hidden::is_same_template_st< ContainerType< TypeA, TypeAs... >, ContainerType< TypeB, TypeBs... > >
 
struct  tpf::types::hidden::is_same_template_st< ContainerType< TypeA1, TypeA2, TypeAs... >, ContainerType< TypeB1, TypeB2, TypeBs... > >
 
struct  tpf::types::hidden::is_same_template_st< ContainerType< TypeA1, TypeA2, TypeA3, TypeAs... >, ContainerType< TypeB1, TypeB2, TypeB3, TypeBs... > >
 
struct  tpf::types::hidden::is_same_template_st< ContainerType< TypeA1, TypeA2, TypeA3, TypeA4, TypeAs... >, ContainerType< TypeB1, TypeB2, TypeB3, TypeB4, TypeBs... > >
 
struct  tpf::types::hidden::is_string_st< Type >
 
struct  tpf::types::hidden::is_string_st< const char * >
 
struct  tpf::types::hidden::is_string_st< const wchar_t * >
 
struct  tpf::types::hidden::is_string_st< std::basic_string< CharType > >
 
struct  tpf::types::hidden::is_same_st< Type >
 
struct  tpf::types::hidden::is_same_st< Type1, Type2 >
 
struct  tpf::types::hidden::is_same_st< Type1, Type2, Types... >
 
struct  tpf::types::hidden::is_same_st< type_list_t< Type > >
 
struct  tpf::types::hidden::is_same_st< type_list_t< Type1, Type2 > >
 
struct  tpf::types::hidden::is_same_st< type_list_t< Type1, Type2, Types... > >
 
struct  tpf::types::hidden::is_in_list_st< TestType, Types >
 
struct  tpf::types::hidden::is_in_list_st< TestType >
 
struct  tpf::types::hidden::is_in_list_st< TestType, Type >
 
struct  tpf::types::hidden::is_in_list_st< TestType, Type, Types... >
 
struct  tpf::types::hidden::is_in_list_st< TestType, type_list_t<> >
 
struct  tpf::types::hidden::is_in_list_st< TestType, type_list_t< Type > >
 
struct  tpf::types::hidden::is_in_list_st< TestType, type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::are_all_in_list_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::are_all_in_list_st< type_list_t< Types... >, TestType >
 
struct  tpf::types::hidden::are_all_in_list_st< type_list_t< Types... >, TestType, TestTypes... >
 
struct  tpf::types::hidden::are_all_in_list_st< type_list_t< Types... >, type_list_t<> >
 
struct  tpf::types::hidden::are_all_in_list_st< type_list_t< Types... >, type_list_t< TestType > >
 
struct  tpf::types::hidden::are_all_in_list_st< type_list_t< Types... >, type_list_t< TestType, TestTypes... > >
 
struct  tpf::types::hidden::make_signed_st< Type, bInteger >
 
struct  tpf::types::hidden::make_signed_st< Type, true >
 
struct  tpf::types::hidden::make_unsigned_st< Type, bInteger >
 
struct  tpf::types::hidden::make_unsigned_st< Type, true >
 
struct  tpf::types::hidden::make_signed_integral_st< Type, bIntegral >
 
struct  tpf::types::hidden::make_signed_integral_st< Type, true >
 
struct  tpf::types::hidden::make_unsigned_integral_st< Type, bIntegral >
 
struct  tpf::types::hidden::make_unsigned_integral_st< Type, true >
 
struct  tpf::types::hidden::common_type_st< Type >
 
struct  tpf::types::hidden::common_type_st< Type1, Type2 >
 
struct  tpf::types::hidden::common_type_st< Type1, Type2, Types... >
 
struct  tpf::types::hidden::common_type_st< type_list_t<> >
 
struct  tpf::types::hidden::common_type_st< type_list_t< Type > >
 
struct  tpf::types::hidden::common_type_st< type_list_t< Type1, Type2 > >
 
struct  tpf::types::hidden::common_type_st< type_list_t< Type1, Type2, Types... > >
 
struct  tpf::types::hidden::st_common_type_solver<>
 
struct  tpf::types::hidden::st_common_type_solver< type_list_t<> >
 
struct  tpf::types::hidden::st_common_type_solver< Type >
 
struct  tpf::types::hidden::st_common_type_solver< type_list_t< Type > >
 
struct  tpf::types::hidden::st_common_type_solver< Type, Types... >
 
struct  tpf::types::hidden::st_common_type_solver< type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::select_first_type_st<>
 
struct  tpf::types::hidden::select_first_type_st< Type >
 
struct  tpf::types::hidden::select_first_type_st< Type, Types... >
 
struct  tpf::types::hidden::select_first_type_st< type_list_t<> >
 
struct  tpf::types::hidden::select_first_type_st< type_list_t< Type > >
 
struct  tpf::types::hidden::select_first_type_st< type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::select_last_type_st<>
 
struct  tpf::types::hidden::select_last_type_st< Type >
 
struct  tpf::types::hidden::select_last_type_st< Type, Types... >
 
struct  tpf::types::hidden::select_last_type_st< type_list_t<> >
 
struct  tpf::types::hidden::select_last_type_st< type_list_t< Type > >
 
struct  tpf::types::hidden::select_last_type_st< type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::select_nth_type_st< SelectIndex >
 
struct  tpf::types::hidden::select_nth_type_st< 0, Type, Types... >
 
struct  tpf::types::hidden::select_nth_type_st< SelectIndex, Type, Types... >
 
struct  tpf::types::hidden::select_nth_type_st< SelectIndex, type_list_t<> >
 
struct  tpf::types::hidden::select_nth_type_st< 0, type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::select_nth_type_st< SelectIndex, type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::is_reference_wrapper_st< Type >
 
struct  tpf::types::hidden::is_reference_wrapper_st< std::reference_wrapper< Type > >
 
struct  tpf::types::hidden::push_front_type_st< ArgType, Types >
 
struct  tpf::types::hidden::push_front_type_st< ArgType, type_list_t< Types... > >
 
struct  tpf::types::hidden::push_back_type_st< ArgType, Types >
 
struct  tpf::types::hidden::push_back_type_st< ArgType, type_list_t< Types... > >
 
struct  tpf::types::hidden::pop_front_type_st< type_list_t<> >
 
struct  tpf::types::hidden::pop_front_type_st< type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::pop_front_wrapper_st< Types >
 
struct  tpf::types::hidden::pop_front_wrapper_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::pop_back_type_st< type_list_t< LeftTypes... >, type_list_t<> >
 
struct  tpf::types::hidden::pop_back_type_st< type_list_t< LeftTypes... >, type_list_t< Type, RightTypes... > >
 
struct  tpf::types::hidden::pop_back_type_wrapper_st< Types >
 
struct  tpf::types::hidden::pop_back_type_wrapper_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::first_n_types_list_st< 0, type_list_t<>, type_list_t<> >
 
struct  tpf::types::hidden::first_n_types_list_st< 0, type_list_t<>, type_list_t< RightType, RightTypes... > >
 
struct  tpf::types::hidden::first_n_types_list_st< 1, type_list_t< LeftTypes... >, type_list_t<> >
 
struct  tpf::types::hidden::first_n_types_list_st< 1, type_list_t< LeftTypes... >, type_list_t< RightType, RightTypes... > >
 
struct  tpf::types::hidden::first_n_types_list_st< FirstN, type_list_t< LeftTypes... >, type_list_t< RightType, RightTypes... > >
 
struct  tpf::types::hidden::first_n_types_st< FirstN, type_list_t<>, RightTypes... >
 
struct  tpf::types::hidden::first_n_types_st< FirstN, type_list_t<>, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::last_n_types_list_st< 0, type_list_t<>, type_list_t<> >
 
struct  tpf::types::hidden::last_n_types_list_st< 0, type_list_t< LeftType, LeftTypes... >, type_list_t<> >
 
struct  tpf::types::hidden::last_n_types_list_st< 1, type_list_t<>, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::last_n_types_list_st< 1, type_list_t< LeftType, LeftTypes... >, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::last_n_types_list_st< LastN, type_list_t< LeftType, LeftTypes... >, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::last_n_types_st< LastN, LeftTypes >
 
struct  tpf::types::hidden::last_n_types_st< LastN, type_list_t< LeftTypes... > >
 
struct  tpf::types::hidden::is_type_in_list_st< ArgType >
 
struct  tpf::types::hidden::is_type_in_list_st< ArgType, Type, RightTypes... >
 
struct  tpf::types::hidden::is_type_in_list_st< ArgType, type_list_t<> >
 
struct  tpf::types::hidden::is_type_in_list_st< ArgType, type_list_t< Type, RightTypes... > >
 
struct  tpf::types::hidden::unique_types_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::unique_types_st< type_list_t< Types... >, Type >
 
struct  tpf::types::hidden::unique_types_st< type_list_t< Types... >, Type, RightTypes... >
 
struct  tpf::types::hidden::unique_types_st< type_list_t< Types... >, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::to_variant_st< Type, Types >
 
struct  tpf::types::hidden::to_variant_st< type_list_t< Type, Types... > >
 
struct  tpf::types::hidden::to_variant_st< std::tuple< Type, Types... > >
 
struct  tpf::types::hidden::to_tuple_st< Types >
 
struct  tpf::types::hidden::to_tuple_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::to_tuple_st< std::variant< Types... > >
 
struct  tpf::types::hidden::prepend_type_st< ArgType, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::prepend_type_st< type_list_t< ArgTypes... >, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::append_type_st< ArgType, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::append_type_st< type_list_t< ArgTypes... >, type_list_t< RightTypes... > >
 
struct  tpf::types::hidden::union_type_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::union_type_st< type_list_t< Types... >, Type >
 
struct  tpf::types::hidden::union_type_st< type_list_t< Types... >, Type, RightTypes... >
 
struct  tpf::types::hidden::union_type_st< ArgType, type_list_t< Types... > >
 
struct  tpf::types::hidden::union_type_st< type_list_t< Types... >, type_list_t<> >
 
struct  tpf::types::hidden::union_type_st< type_list_t< Types... >, type_list_t< Type > >
 
struct  tpf::types::hidden::union_type_st< type_list_t< Types... >, type_list_t< Type, RightTypes... > >
 
struct  tpf::types::hidden::intersection_type_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::intersection_type_st< type_list_t< Types... >, Type >
 
struct  tpf::types::hidden::intersection_type_st< type_list_t< Types... >, Type, RightTypes... >
 
struct  tpf::types::hidden::intersection_type_st< type_list_t< Types... >, type_list_t<> >
 
struct  tpf::types::hidden::intersection_type_st< type_list_t< Types... >, type_list_t< Type > >
 
struct  tpf::types::hidden::intersection_type_st< type_list_t< Types... >, type_list_t< Type, RightTypes... > >
 
struct  tpf::types::hidden::remove_type_st< ArgType >
 
struct  tpf::types::hidden::remove_type_st< ArgType, Type >
 
struct  tpf::types::hidden::remove_type_st< ArgType, Type, RightTypes... >
 
struct  tpf::types::hidden::remove_type_st< ArgType, type_list_t<> >
 
struct  tpf::types::hidden::remove_type_st< ArgType, type_list_t< Type > >
 
struct  tpf::types::hidden::remove_type_st< ArgType, type_list_t< Type, RightTypes... > >
 
struct  tpf::types::hidden::remove_type_wrapper_st< ArgType, Types >
 
struct  tpf::types::hidden::remove_type_wrapper_st< ArgType, type_list_t< Types... > >
 
struct  tpf::types::hidden::difference_type_st< type_list_t< Types... > >
 
struct  tpf::types::hidden::difference_type_st< type_list_t< Types... >, Type >
 
struct  tpf::types::hidden::difference_type_st< type_list_t< Types... >, Type, RightTypes... >
 
struct  tpf::types::hidden::difference_type_st< type_list_t< Types... >, type_list_t<> >
 
struct  tpf::types::hidden::difference_type_st< type_list_t< Types... >, type_list_t< Type > >
 
struct  tpf::types::hidden::difference_type_st< type_list_t< Types... >, type_list_t< Type, RightTypes... > >
 
struct  tpf::types::hidden::replace_type_st< NewType, OldType >
 
struct  tpf::types::hidden::replace_type_st< NewType, OldType, Type >
 
struct  tpf::types::hidden::replace_type_st< NewType, OldType, Type, RightTypes... >
 
struct  tpf::types::hidden::replace_type_st< NewType, OldType, type_list_t<> >
 
struct  tpf::types::hidden::replace_type_st< NewType, OldType, type_list_t< Type > >
 
struct  tpf::types::hidden::replace_type_st< NewType, OldType, type_list_t< Type, RightTypes... > >
 
struct  tpf::types::hidden::is_type_list_equivalent_st< type_list_t< LeftTypes... > >
 
struct  tpf::types::hidden::is_type_list_equivalent_st< type_list_t< LeftTypes... >, Type >
 
struct  tpf::types::hidden::is_type_list_equivalent_st< type_list_t< LeftTypes... >, Type, RightTypes... >
 
struct  tpf::types::hidden::is_type_list_equivalent_st< type_list_t< LeftTypes... >, type_list_t< RightTypes... > >
 
struct  tpf::types::unique_ptr_wrapper< N, T, deleter >
 
struct  tpf::types::hidden::st_unique_ptr_wrapper< ArgTypes >
 
struct  tpf::types::hidden::st_unique_ptr_wrapper_deleter< deleter, ArgTypes >
 
struct  tpf::types::hidden::st_pairwise_common< T >
 
struct  tpf::types::hidden::st_pairwise_common< T, S >
 
struct  tpf::types::hidden::st_pairwise_common< T, S, Types... >
 
struct  tpf::types::hidden::st_contain_no_type_in_tuple< Type >
 
struct  tpf::types::hidden::st_contain_no_type_in_tuple< std::tuple<> >
 
struct  tpf::types::hidden::st_contain_no_type_in_tuple< std::tuple< Type > >
 
struct  tpf::types::hidden::st_contain_no_type_in_tuple< std::tuple< Type, Types... > >
 
struct  tpf::types::hidden::st_tuple_common_type< T, S >
 
struct  tpf::types::hidden::st_tuple_common_type< std::tuple< ArgTypes1... >, std::tuple< ArgTypes2... > >
 
struct  tpf::types::hidden::st_has_tuple_common_type< Type >
 
struct  tpf::types::hidden::st_has_tuple_common_type< std::tuple< Types... > >
 
struct  tpf::types::hidden::arg_list< Types >
 
struct  tpf::types::hidden::st_is_arg_list< T >
 
struct  tpf::types::hidden::st_is_arg_list< arg_list< Ts... > >
 
struct  tpf::types::hidden::st_is_invocable< CallbackType, arg_list< ArgTypes... > >
 
struct  tpf::types::hidden::st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... > >
 
struct  tpf::types::hidden::st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... >, Type >
 
struct  tpf::types::hidden::st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... >, Type, Types... >
 
struct  tpf::types::hidden::st_is_callable< CallbackType, type_list_t< CallableTypes... >, type_list_t< NonCallableTypes... >, type_list_t< Types... > >
 
struct  tpf::types::hidden::st_build_arg_types< type_list_t< Heads... >, type_list_t< Tails... > >
 
struct  tpf::types::hidden::st_arg_to_type_list< arg_list< Types... > >
 
struct  tpf::types::hidden::st_arg_to_type_list< type_list_t< Types... > >
 
struct  tpf::types::concate_type_st<>
 
struct  tpf::types::concate_type_st< type_list_t<> >
 
struct  tpf::types::concate_type_st< Type >
 
struct  tpf::types::concate_type_st< type_list_t< Type > >
 
struct  tpf::types::concate_type_st< Type, Types... >
 
struct  tpf::types::concate_type_st< type_list_t< Type, Types... > >
 
struct  tpf::types::concate_type_st< type_list_t< Head, Tails... >, Types... >
 
struct  tpf::types::concate_type_st< Type, type_list_t< Head2, Tails2... > >
 
struct  tpf::types::concate_type_st< type_list_t< Types1... >, type_list_t< Types2... > >
 
struct  tpf::types::type_over_set_st< boolean::Or, LeftRight, Type, BinaryPredicate, ListHead, ListTails... >
 
struct  tpf::types::type_over_set_st< boolean::And, LeftRight, Type, BinaryPredicate, ListHead, ListTails... >
 
struct  tpf::types::type_over_set_st< boolean::Or, boolean::Left, Type, BinaryPredicate, ListHead, ListTails... >
 
struct  tpf::types::type_over_set_st< boolean::And, boolean::Left, Type, BinaryPredicate, ListHead, ListTails... >
 
struct  tpf::types::type_over_set_st< boolean::Or, boolean::Right, Type, BinaryPredicate, ListHead, ListTails... >
 
struct  tpf::types::type_over_set_st< boolean::And, boolean::Right, Type, BinaryPredicate, ListHead, ListTails... >
 
struct  tpf::types::type_over_set_st< boolean::Or, boolean::Left, Type, BinaryPredicate, ListHead >
 
struct  tpf::types::type_over_set_st< boolean::And, boolean::Left, Type, BinaryPredicate, ListHead >
 
struct  tpf::types::type_over_set_st< boolean::Or, boolean::Right, Type, BinaryPredicate, ListHead >
 
struct  tpf::types::type_over_set_st< boolean::And, boolean::Right, Type, BinaryPredicate, ListHead >
 
struct  tpf::types::type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, ListHead, ListTails >
 
struct  tpf::types::type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, type_list_t< ListHead, ListTails... > >
 
struct  tpf::types::type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, Head, type_list_t< ListHead, ListTails... > >
 
struct  tpf::types::type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, type_list_t< ListHead, ListTails... >, Head, Tails... >
 
struct  tpf::types::type_opr_over_set_st< OrAnd, LeftRight, Type, BinaryPredicate, type_list_t< ListHead, ListTails... >, type_list_t< Head, Tails... > >
 
class  tpf::types::hidden::container_of_variants_class< ContainerType, ElementTypes >
 
class  tpf::types::hidden::container_of_variants_class< std::pair, KeyType, ElementTypes... >
 
class  tpf::types::hidden::container_of_variants_class< std::map, KeyType, ElementTypes... >
 
class  tpf::types::hidden::container_of_variants_class< std::multimap, KeyType, ElementTypes... >
 
class  tpf::types::hidden::container_of_variants_class< std::unordered_map, KeyType, ElementTypes... >
 
class  tpf::types::hidden::container_of_variants_class< std::unordered_multimap, KeyType, ElementTypes... >
 
struct  tpf::types::hidden::container_of_variants_st< ContainerType, ElementTypes >
 
struct  tpf::types::hidden::container_of_variants_st< ContainerType, type_list_t< ElementTypes... > >
 
struct  tpf::types::hidden::container_of_variants_st< std::pair, KeyType, type_list_t< ElementTypes... > >
 
struct  tpf::types::hidden::container_of_variants_st< std::map, KeyType, type_list_t< ElementTypes... > >
 
struct  tpf::types::hidden::container_of_variants_st< std::multimap, KeyType, type_list_t< ElementTypes... > >
 
struct  tpf::types::hidden::container_of_variants_st< std::unordered_map, KeyType, type_list_t< ElementTypes... > >
 
struct  tpf::types::hidden::container_of_variants_st< std::unordered_multimap, KeyType, type_list_t< ElementTypes... > >
 
struct  tpf::types::hidden::types_to_template_class_st< Type, Types >
 
struct  tpf::types::hidden::types_to_template_class_st< ClassTemplate< InnerTypes... >, Types... >
 
struct  tpf::types::hidden::types_to_template_class_st< ClassTemplate< InnerTypes... >, type_list_t< Types... > >
 
struct  tpf::types::hidden::types_to_template_class_wrapper_st< Type, Types >
 
struct  tpf::types::hidden::types_to_template_class_wrapper_st< ClassTemplate< InnerTypes... >, Types... >
 
struct  tpf::types::hidden::types_to_template_class_wrapper_st< std::variant< InnerTypes... >, Types... >
 
struct  tpf::types::hidden::types_to_template_class_wrapper_st< ClassTemplate< InnerTypes... >, type_list_t< Types... > >
 
struct  tpf::types::hidden::types_to_template_class_wrapper_st< std::variant< InnerTypes... >, type_list_t< Types... > >
 
struct  tpf::types::hidden::type_list_to_template_class_st< ClassTemplate, Types >
 
struct  tpf::types::hidden::type_list_to_template_class_st< ClassTemplate, type_list_t< Types... > >
 
struct  tpf::types::hidden::type_list_to_template_class_wrapper_st< ClassTemplate, Types >
 
struct  tpf::types::hidden::type_list_to_template_class_wrapper_st< ClassTemplate, type_list_t< Types... > >
 
struct  tpf::types::hidden::type_list_to_template_class_wrapper_st< std::variant, Types... >
 
struct  tpf::types::hidden::type_list_to_template_class_wrapper_st< std::variant, type_list_t< Types... > >
 
struct  tpf::types::hidden::nth_type_to_template_class_st< TypeIndex, TemplateClass< InnerTypes... >, Types... >
 
struct  tpf::types::hidden::nth_type_to_template_class_st< TypeIndex, TemplateClass< InnerTypes... >, type_list_t< Types... > >
 
struct  tpf::types::hidden::first_n_types_list_to_template_class_st< FirstN, TemplateClass, Types >
 
struct  tpf::types::hidden::first_n_types_list_to_template_class_st< FirstN, TemplateClass, type_list_t< Types... > >
 
struct  tpf::types::hidden::first_n_types_to_template_class_st< FirstN, TemplateClass< InnerTypes... >, Types... >
 
struct  tpf::types::hidden::first_n_types_to_template_class_st< FirstN, TemplateClass< InnerTypes... >, type_list_t< Types... > >
 
class  tpf::types::hidden::container_of_tuples_class< ContainerType, ElementTypes >
 
class  tpf::types::hidden::container_of_tuples_class< std::map, KeyType, ElementTypes... >
 
class  tpf::types::hidden::container_of_tuples_class< std::multimap, KeyType, ElementTypes... >
 
class  tpf::types::hidden::container_of_tuples_class< std::unordered_map, KeyType, ElementTypes... >
 
class  tpf::types::hidden::container_of_tuples_class< std::unordered_multimap, KeyType, ElementTypes... >
 
struct  tpf::types::hidden::container_of_tuples_st< ContainerType, ElementTypes >
 
struct  tpf::types::hidden::container_of_tuples_st< ContainerType, type_list_t< ElementTypes... > >
 
class  tpf::types::reverse_st< ContainerType >
 
class  tpf::types::reverse_st< ElementType(&)[ElementCount]>
 
struct  tpf::types::static_loop_struct< StartIndex, EndIndex >
 
struct  tpf::types::variant_visitors< CallbackTypes >
 

Namespaces

namespace  tpf
 Includes subnamespace conversion.
 
namespace  tpf::literals
 
namespace  tpf::types
 Type to string name conversions are defined.
 
namespace  tpf::types::hidden
 Implementations in this scope is meant NOT to be accessed directly by the client.
 

Macros

#define NOMINMAX
 
#define Tpf_FormatWidth   12
 
#define Tpf_FormatPrecision   6
 
#define Tpf_ToleranceFloat   1.0e-7
 
#define Tpf_ToleranceDouble   1.0e-12
 
#define Tpf_ToleranceLongDouble   1.0e-12
 
#define __FUNCTION_NAME__   __PRETTY_FUNCTION__
 
#define Tpf_DebugException(debug_message)   tpf::debug_exception{debug_message, __LINE__, __FILE__}
 
#define Tpf_ThrowDebugException(debug_message)   throw tpf::debug_exception{debug_message, __LINE__, __FILE__}
 Throw a debug_exception with message as argument. More...
 
#define Tpf_GetTypeName(type_arg)   tpf::types::type_to_string<type_arg>()
 A macro that returns type_arg's string name. More...
 
#define Tpf_GetTypeCategory(instance_arg)   Tpf_GetTypeName(decltype(instance_arg))
 A macro that returns instance_arg's type category string name. More...
 
#define Tpf_GetValueCategory(instance_arg)   Tpf_GetTypeName(decltype((instance_arg)))
 A macro that returns instance_arg's value category string name. More...
 
#define Tpf_IsTemplateV(type_arg)   tpf::types::is_template_v<type_arg>
 A macro that tells if type_arg is a template type. More...
 
#define Tpf_IsTemplateInstanceV(instance_arg)   tpf::types::is_template_v<decltype(instance_arg)>
 A macro that tells if instance_arg is of a template type. More...
 

Typedefs

template<typename Type >
using tpf::remove_cv_ref_t = std::remove_cv_t< std::remove_reference_t< Type > >
 Remove const volatile reference from Type. More...
 
template<typename Type >
using tpf::decay_remove_cv_ref_t = std::remove_cv_t< std::remove_reference_t< std::decay_t< Type > > >
 Decay, remove const, volatile, reference. More...
 
template<typename Type >
using tpf::decay_remove_ref_t = std::remove_reference_t< std::decay_t< Type > >
 Decay, remove reference. More...
 
template<typename Type >
using tpf::primitive_type_t = remove_cv_ref_t< std::remove_pointer_t< decay_remove_cv_ref_t< Type > > >
 Decay, remove const, volatile, reference, then remove pointer and remove const and volatile. More...
 
using tpf::types::big_integer_t = long long
 
using tpf::types::big_unsigned_t = unsigned long long
 
template<auto Id, auto... Ids>
using tpf::types::index_t = std::index_sequence<(std::size_t) Id,(std::size_t) Ids... >
 
template<auto N>
using tpf::types::make_index_t = std::make_index_sequence<(std::size_t) N >
 
template<typename ... Types>
using tpf::types::index_for = std::make_index_sequence< sizeof...(Types)>
 
template<typename Type >
using tpf::types::remove_cvref_t = remove_cv_ref_t< Type >
 
template<typename Type , auto Tag>
using tpf::types::hidden::non_class_wrapper_t = typename st_make_non_class_wrapper< Type, Tag, std::is_class_v< Type > >::type
 
template<typename Type , auto Tag>
using tpf::types::non_class_wrapper_t = hidden::non_class_wrapper_t< Type, Tag >
 
template<typename Type , auto Size>
using tpf::types::create_tuple_t = decltype(types::convert_to_tuple(std::array< Type, Size >{}))
 
template<typename T >
using tpf::types::hidden::to_recursive_type_list_t = typename st_recursive_type_list< T >::type
 
template<typename T >
using tpf::types::to_recursive_type_list_t = hidden::to_recursive_type_list_t< remove_cv_ref_t< T > >
 
template<typename... Types>
using tpf::types::remove_cv_ref_type_list_t = type_list_t< tpf::remove_cv_ref_t< Types >... >
 Create type_list_t by removing const, volatile, reference. More...
 
template<typename... Types>
using tpf::types::decay_remove_cv_ref_type_list_t = type_list_t< tpf::decay_remove_cv_ref_t< Types >... >
 Create type_list_t by decaying and removing const, volatile, reference. More...
 
template<typename... Types>
using tpf::types::decay_remove_ref_type_list_t = type_list_t< tpf::decay_remove_ref_t< Types >... >
 Create type_list_t by decaying and removing reference. More...
 
template<typename TupleType >
using tpf::types::hidden::tuple_to_type_list_t = typename st_tuple_to_type_list< TupleType >::type
 
template<typename TypeList >
using tpf::types::hidden::type_list_to_tuple_t = typename st_type_list_to_tuple< TypeList >::type
 
template<typename VarType >
using tpf::types::hidden::variant_to_type_list_t = typename st_variant_to_type_list< VarType >::type
 
template<typename TupleType >
using tpf::types::tuple_to_type_list_t = hidden::tuple_to_type_list_t< remove_cvref_t< TupleType > >
 
template<typename TypeList >
using tpf::types::type_list_to_tuple_t = hidden::type_list_to_tuple_t< remove_cvref_t< TypeList > >
 
template<typename VarType >
using tpf::types::variant_to_type_list_t = hidden::variant_to_type_list_t< remove_cvref_t< VarType > >
 
template<typename... Types>
using tpf::types::tuple_of_vectors_t = typename hidden::st_type_list_to_tuple_of_vectors< Types... >::type
 
template<std::size_t N>
using tpf::types::index_tuple_vector_t = typename hidden::st_index_tuple_vector< std::make_index_sequence< N > >::type
 
template<typename Type >
using tpf::types::hidden::map_or_unordered_map_pair_t = typename is_map_or_unordered_map_st< remove_cv_ref_t< Type > >::type
 
template<typename Type >
using tpf::types::map_or_unordered_map_pair_t = hidden::map_or_unordered_map_pair_t< Type >
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::set_element_t = typename SetTagType::set_element_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::set_t = typename SetTagType::set_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::sets_t = typename SetTagType::sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::set_of_sets_t = typename SetTagType::set_of_sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::sets_of_sets_t = typename SetTagType::sets_of_sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::duet_set_element_t = typename SetTagType::duet_set_element_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::duet_set_t = typename SetTagType::duet_set_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::duet_sets_t = typename SetTagType::duet_sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::duet_set_of_sets_t = typename SetTagType::duet_set_of_sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::duet_sets_of_sets_t = typename SetTagType::duet_sets_of_sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::set_of_duets_t = typename SetTagType::set_of_duets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::trio_set_element_t = typename SetTagType::trio_set_element_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::trio_set_t = typename SetTagType::trio_set_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::trio_sets_t = typename SetTagType::trio_sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::trio_set_of_sets_t = typename SetTagType::trio_set_of_sets_t
 
template<typename SetTagType = set_tag<std::vector, int>>
using tpf::trio_sets_of_sets_t = typename SetTagType::trio_sets_of_sets_t
 
using tpf::types::no_throw_t = no_type_t
 
using tpf::types::invalid_t = no_type_t
 
template<typename Type >
using tpf::types::hidden::return_type_t = typename return_type_st< Type >::type
 
template<typename Type >
using tpf::types::return_type_t = hidden::return_type_t< Type >
 
template<typename Type >
using tpf::types::std_array_element_t = typename hidden::st_std_array_element< remove_cv_ref_t< Type > >::type
 
template<auto Index>
using tpf::types::indexer_t = indexer_type< remove_cvref_t< decltype(Index)>, Index >
 
template<auto RowValue, auto ColumnValue>
using tpf::types::indexer_2d_t = indexer_2d_type< remove_cvref_t< decltype(RowValue)>, RowValue, ColumnValue >
 
template<auto HeightValue, auto RowValue, auto ColumnValue>
using tpf::types::indexer_3d_t = indexer_3d_type< remove_cvref_t< decltype(RowValue)>, HeightValue, RowValue, ColumnValue >
 
template<auto... Indices>
using tpf::types::typed_sequence_t = std::integer_sequence< std::common_type_t< remove_cvref_t< decltype(Indices)>... >, Indices... >
 
template<auto Size>
using tpf::types::make_typed_sequence_t = std::make_integer_sequence< remove_cvref_t< decltype(Size)>, Size >
 
template<typename SequenceType >
using tpf::types::hidden::reverse_sequence_t = typename st_reverse_sequence< SequenceType >::type
 
template<typename T >
using tpf::types::hidden::sequence_element_t = typename st_sequence_element_type< T >::type
 
template<bool StackOrder, typename SequenceType >
using tpf::types::hidden::sequence_info_t = st_sequence_info< sequence_element_t< SequenceType >, sequence_first_element_v< SequenceType >, sequence_last_element_v< SequenceType >, sequence_element_count_v< SequenceType >, StackOrder >
 
template<typename SequenceType >
using tpf::types::reverse_sequence_t = hidden::reverse_sequence_t< remove_cvref_t< SequenceType > >
 
template<typename SequenceType >
using tpf::types::sequence_element_t = hidden::sequence_element_t< remove_cvref_t< SequenceType > >
 
template<bool StackOrder, typename SequenceType >
using tpf::types::sequence_info_t = typename hidden::sequence_info_t< StackOrder, remove_cvref_t< SequenceType > >
 
template<bool SequenceInOrder, auto... RangeValues>
using tpf::types::make_sequence_t = typename hidden::st_create_workhorse_range< SequenceInOrder, RangeValues... >::type
 
template<typename T >
using tpf::types::hidden::iterator_value_type_t = decltype(iterator_value_type_fn(std::declval< T >()))
 
template<typename Type , typename ReturnType >
using tpf::types::hidden::enable_if_iterator_type_t = std::enable_if_t< is_iterator_type_v< Type >, ReturnType >
 
template<typename T >
using tpf::types::hidden::enable_if_iterator_value_type_t = std::enable_if_t< is_iterator_type_v< T >, iterator_value_type_t< T > >
 
template<typename T >
using tpf::types::hidden::conditional_iterator_value_type_t = typename std::conditional< is_iterator_type_v< T >, iterator_value_type_t< T >, T >::type
 
template<typename Type , typename ReturnType >
using tpf::types::enable_if_iterator_type_t = hidden::enable_if_iterator_type_t< remove_cv_ref_t< Type >, ReturnType >
 
using tpf::types::character_list_t = type_list_t< char, unsigned char, wchar_t >
 Type list of character types. More...
 
using tpf::types::integer_list_t = type_list_t< short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long >
 Type list of integers EXCLUSING character type and boolean type. More...
 
using tpf::types::signed_integer_list_t = type_list_t< short, int, long, long long >
 Signed integers EXCLUDING char and boolean. More...
 
using tpf::types::unsigned_integer_list_t = type_list_t< unsigned short, unsigned int, unsigned long, unsigned long long >
 Unsigned integers EXCLUDING unsigned char and boolean. More...
 
using tpf::types::integral_list_t = type_list_t< char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long >
 Type list of integral type INCLUDING character type, but EXCLUDING boolean type. More...
 
using tpf::types::unsigned_integral_list_t = type_list_t< unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long >
 Type list of unsigned integral type INCLUDING character type, but EXCLUDING boolean type. More...
 
using tpf::types::signed_integral_list_t = type_list_t< char, short, int, long int, long long int >
 Type list of signed integral type INCLUDING character type, but EXCLUDING boolean type. More...
 
using tpf::types::real_number_list_t = type_list_t< float, double, long double >
 Type list of real numbers (floating-point numbers). More...
 
using tpf::types::numerical_number_list_t = type_list_t< char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, float, double, long double >
 All numbers mathematical operations. More...
 
using tpf::types::arithmetic_number_list_t = type_list_t< char, short, int, long, long long, float, double, long double >
 Arithmetic numbers for mathematical analysis. More...
 
using tpf::types::floating_point_list_t = real_number_list_t
 The same to real_number_list_t, real numbers. More...
 
template<typename Type >
using tpf::types::hidden::template_parameter_type_list_t = typename is_template_st< Type >::type
 
template<typename Type >
using tpf::types::template_parameter_type_list_t = hidden::template_parameter_type_list_t< Type >
 
template<typename Type1 , typename Type2 >
using tpf::types::hidden::is_operable_t = std::remove_reference_t< decltype(is_operable_fn(std::declval< Type1 >(), std::declval< Type2 >()))>
 
template<typename Type , typename ReturnType = void>
using tpf::types::hidden::enable_if_container_type_t = std::enable_if_t< is_container_type_v< remove_cv_ref_t< Type > >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_integral_t = std::enable_if_t< is_integral_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_signed_integral_t = std::enable_if_t< is_signed_integral_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_unsigned_integral_t = std::enable_if_t< is_unsigned_integral_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_integer_t = std::enable_if_t< is_integer_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_not_integer_t = std::enable_if_t<!is_integer_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_signed_integer_t = std::enable_if_t< is_signed_integer_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_unsigned_integer_t = std::enable_if_t< is_unsigned_integer_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_real_number_t = std::enable_if_t< is_real_number_v< Type >, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::hidden::enable_if_numerical_number_t = std::enable_if_t< is_numerical_number_v< Type >, ReturnType >
 
template<typename Type >
using tpf::types::hidden::make_signed_t = typename make_signed_st< Type, is_integer_v< Type > >::type
 
template<typename Type >
using tpf::types::hidden::make_unsigned_t = typename make_unsigned_st< Type, is_integer_v< Type > >::type
 
template<typename Type >
using tpf::types::hidden::make_signed_integral_t = typename make_signed_integral_st< Type, is_integral_v< Type > >::type
 
template<typename Type >
using tpf::types::hidden::make_unsigned_integral_t = typename make_unsigned_integral_st< Type, is_integral_v< Type > >::type
 
template<typename... Types>
using tpf::types::hidden::common_type_t = typename st_common_type_solver< Types... >::type
 
template<typename... Types>
using tpf::types::hidden::select_first_type_t = typename select_first_type_st< Types... >::type
 
template<typename... Types>
using tpf::types::hidden::first_type_t = select_first_type_t< Types... >
 
template<typename... Types>
using tpf::types::hidden::front_type_t = select_first_type_t< Types... >
 
template<typename... Types>
using tpf::types::hidden::select_last_type_t = typename select_last_type_st< Types... >::type
 
template<typename... Types>
using tpf::types::hidden::last_type_t = select_last_type_t< Types... >
 
template<typename... Types>
using tpf::types::hidden::back_type_t = select_last_type_t< Types... >
 
template<auto SelectIndex, typename... Types>
using tpf::types::hidden::select_nth_type_t = typename select_nth_type_st< SelectIndex, Types... >::type
 
template<auto SelectIndex, typename... Types>
using tpf::types::hidden::nth_type_t = select_nth_type_t< SelectIndex, Types... >
 
template<typename Type >
using tpf::types::hidden::first_parameter_type_t = first_type_t< template_parameter_type_list_t< Type > >
 
template<typename Type >
using tpf::types::hidden::last_parameter_type_t = last_type_t< template_parameter_type_list_t< Type > >
 
template<auto SelectIndex, typename Type >
using tpf::types::hidden::nth_parameter_type_t = nth_type_t< SelectIndex, template_parameter_type_list_t< Type > >
 
template<typename ArgType , typename... Types>
using tpf::types::hidden::push_front_type_t = typename push_front_type_st< ArgType, Types... >::type
 
template<typename ArgType , typename... Types>
using tpf::types::hidden::push_back_type_t = typename push_back_type_st< ArgType, Types... >::type
 
template<typename... Types>
using tpf::types::hidden::pop_front_type_t = typename pop_front_wrapper_st< Types... >::type
 
template<typename... Types>
using tpf::types::hidden::pop_back_type_t = typename pop_back_type_wrapper_st< Types... >::type
 
template<size_t FirstN, typename... RightTypes>
using tpf::types::hidden::first_n_types_t = typename first_n_types_st< FirstN, type_list_t<>, RightTypes... >::type
 
template<size_t FirstN, typename... RightTypes>
using tpf::types::hidden::select_first_n_types_t = first_n_types_t< FirstN, RightTypes... >
 
template<size_t LastN, typename... LeftTypes>
using tpf::types::hidden::last_n_types_t = typename last_n_types_st< LastN, LeftTypes... >::type
 
template<size_t LastN, typename... LeftTypes>
using tpf::types::hidden::select_last_n_types_t = last_n_types_t< LastN, LeftTypes... >
 
template<typename TestType , typename TypeList , typename ReturnType = TestType>
using tpf::types::hidden::enable_if_in_list_t = std::enable_if_t< is_type_in_list_v< TestType, TypeList >, ReturnType >
 
template<typename TestTypeList , typename TypeList , typename ReturnType = void>
using tpf::types::hidden::enable_if_all_in_list_t = std::enable_if_t< are_all_in_list_v< TypeList, TestTypeList >, ReturnType >
 
template<typename... Types>
using tpf::types::hidden::unique_types_t = typename unique_types_st< type_list_t<>, Types... >::type
 
template<typename Type , typename... Types>
using tpf::types::hidden::to_variant_t = typename to_variant_st< Type, Types... >::type
 
template<typename... Types>
using tpf::types::hidden::to_tuple_t = typename to_tuple_st< Types... >::type
 
template<typename ArgType , typename RightList >
using tpf::types::hidden::prepend_type_t = typename prepend_type_st< ArgType, RightList >::type
 
template<typename ArgType , typename RightList >
using tpf::types::hidden::append_type_t = typename append_type_st< ArgType, RightList >::type
 
template<typename LeftList , typename RightList >
using tpf::types::hidden::union_type_t = typename union_type_st< LeftList, RightList >::type
 
template<typename LeftList , typename RightList >
using tpf::types::hidden::intersection_type_t = typename intersection_type_st< LeftList, RightList >::type
 
template<typename ArgType , typename... Types>
using tpf::types::hidden::remove_type_t = typename remove_type_wrapper_st< ArgType, Types... >::type
 
template<typename LeftList , typename RightList >
using tpf::types::hidden::difference_type_t = typename difference_type_st< LeftList, RightList >::type
 
template<typename NewType , typename OldType , typename TypeList >
using tpf::types::hidden::replace_type_t = typename replace_type_st< NewType, OldType, TypeList >::type
 
template<typename Type , typename... Types>
using tpf::types::flat_type_list_t = tpf::types::type_list_t< decay_remove_cv_ref_t< Type >, decay_remove_cv_ref_t< Types >... >
 
template<typename ReturnType , typename Type , typename... Types>
using tpf::types::enable_if_same_t = std::enable_if_t< is_same_v< Type, Types... >, ReturnType >
 
template<typename ReturnType , typename... Types>
using tpf::types::enable_if_all_the_same_t = std::enable_if_t< is_same_v< Types... >, ReturnType >
 
template<typename ReturnType , typename Type , typename... Types>
using tpf::types::enable_if_same_flat_t = std::enable_if_t< is_same_flat_v< Type, Types... >, ReturnType >
 
template<typename ReturnType , typename... Types>
using tpf::types::enable_if_all_the_same_flat_t = std::enable_if_t< is_same_flat_v< Types... >, ReturnType >
 
template<typename Type , typename... Types>
using tpf::types::void_if_same_t = std::enable_if_t< is_same_v< Type, Types... > >
 
template<typename... Types>
using tpf::types::void_if_all_the_same_t = std::enable_if_t< is_same_v< Types... > >
 
template<typename Type , typename... Types>
using tpf::types::void_if_same_flat_t = std::enable_if_t< is_same_flat_v< Type, Types... > >
 
template<typename... Types>
using tpf::types::void_if_all_the_same_flat_t = std::enable_if_t< is_same_flat_v< Types... > >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_integral_t = hidden::enable_if_integral_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_signed_integral_t = hidden::enable_if_signed_integral_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_unsigned_integral_t = hidden::enable_if_unsigned_integral_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_integer_t = hidden::enable_if_integer_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_not_integer_t = hidden::enable_if_not_integer_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_signed_integer_t = hidden::enable_if_signed_integer_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_unsigned_integer_t = hidden::enable_if_unsigned_integer_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_real_number_t = hidden::enable_if_real_number_t< Type, ReturnType >
 
template<typename Type , typename ReturnType = Type>
using tpf::types::enable_if_numerical_number_t = hidden::enable_if_numerical_number_t< Type, ReturnType >
 
template<typename Type >
using tpf::types::make_unsigned_t = hidden::make_unsigned_t< Type >
 
template<typename Type >
using tpf::types::make_signed_t = hidden::make_signed_t< Type >
 
template<typename Type >
using tpf::types::make_unsigned_integral_t = hidden::make_unsigned_integral_t< Type >
 
template<typename Type >
using tpf::types::make_signed_integral_t = hidden::make_signed_integral_t< Type >
 
template<typename... Types>
using tpf::types::common_type_t = hidden::common_type_t< Types... >
 
template<typename... Types>
using tpf::types::make_common_unsigned_t = make_unsigned_t< common_type_t< Types... > >
 
template<typename... Types>
using tpf::types::common_unsigned_t = make_unsigned_t< common_type_t< Types... > >
 
template<typename... Types>
using tpf::types::make_common_signed_t = make_signed_t< common_type_t< Types... > >
 
template<typename... Types>
using tpf::types::common_signed_t = make_signed_t< common_type_t< Types... > >
 
template<typename ReturnType , typename... ArgTypes>
using tpf::types::enable_if_common_exisits_t = std::enable_if_t< common_type_v< remove_cvref_t< ArgTypes >... >, ReturnType >
 
template<typename... ArgTypes>
using tpf::types::void_if_common_exisits_t = std::enable_if_t< common_type_v< remove_cvref_t< ArgTypes >... > >
 
template<typename... ArgTypes>
using tpf::types::hidden::make_unique_ptr_wrapper_t = typename st_unique_ptr_wrapper< ArgTypes... >::type
 
template<typename deleter , typename... ArgTypes>
using tpf::types::hidden::make_unique_ptr_deleter_wrapper_t = typename st_unique_ptr_wrapper_deleter< deleter, ArgTypes... >::type
 
template<typename FuncType , typename TupleType >
using tpf::types::apply_return_t = decltype(hidden::fn_apply(std::declval< FuncType >(), std::declval< TupleType >()))
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::common_apply_t = std::common_type_t< apply_return_t< FuncType, TupleTypes >... >
 
template<typename ReturnType , typename FuncType , typename... TupleTypes>
using tpf::types::enable_if_all_apply_t = std::enable_if_t< all_apply_v< FuncType, TupleTypes... >, ReturnType >
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::apply_return_tuple_t = std::tuple< apply_return_t< FuncType, TupleTypes > ... >
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::apply_return_array_t = std::array< std::common_type_t< apply_return_t< FuncType, TupleTypes >... >, sizeof...(TupleTypes)>
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::apply_return_vector_t = std::vector< std::common_type_t< apply_return_t< FuncType, TupleTypes >... > >
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::void_if_all_apply_t = enable_if_all_apply_t< void, FuncType, TupleTypes... >
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::tuple_if_all_apply_t = enable_if_all_apply_t< apply_return_tuple_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::array_if_all_apply_t = enable_if_all_apply_t< apply_return_array_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::vector_if_all_apply_t = enable_if_all_apply_t< apply_return_vector_t< FuncType, TupleTypes... >, FuncType, TupleTypes... >
 
template<typename FuncType , typename... TupleTypes>
using tpf::types::common_type_if_all_apply_t = std::enable_if_t< common_apply_v< FuncType, TupleTypes... >, std::common_type_t< apply_return_t< FuncType, TupleTypes >... > >
 
template<typename FuncType , typename... ArgTypes>
using tpf::types::hidden::function_return_type_t = remove_cvref_t< decltype(function_return_type_fn(std::declval< FuncType >(), std::declval< ArgTypes >()...))>
 
template<typename FuncType , typename... ArgTypes>
using tpf::types::function_return_type_t = hidden::function_return_type_t< FuncType, ArgTypes... >
 
template<typename T , typename... Types>
using tpf::types::enable_pairwise_common_type_t = std::enable_if_t< pairwise_common_type_v< T, Types... > >
 
template<typename T , typename S >
using tpf::types::tuple_common_type_t = typename hidden::st_tuple_common_type< remove_cvref_t< T >, remove_cvref_t< S > >::type
 
template<typename T , typename S >
using tpf::types::tuple_operation_valid_t = std::enable_if_t< tuple_common_type_v< T, S >, tuple_common_type_t< T, S > >
 
template<typename Type , typename ReturnType = void>
using tpf::types::enable_if_container_type_t = hidden::enable_if_container_type_t< Type, ReturnType >
 
template<typename... Types>
using tpf::types::select_first_type_t = hidden::select_first_type_t< Types... >
 
template<typename... Types>
using tpf::types::first_type_t = hidden::first_type_t< Types... >
 
template<typename... Types>
using tpf::types::front_type_t = hidden::front_type_t< Types... >
 
template<typename... Types>
using tpf::types::select_last_type_t = hidden::select_last_type_t< Types... >
 
template<typename... Types>
using tpf::types::last_type_t = hidden::last_type_t< Types... >
 
template<typename... Types>
using tpf::types::back_type_t = hidden::back_type_t< Types... >
 
template<auto SelectIndex, typename... Types>
using tpf::types::select_nth_type_t = hidden::select_nth_type_t< SelectIndex, Types... >
 
template<auto SelectIndex, typename... Types>
using tpf::types::nth_type_t = hidden::nth_type_t< SelectIndex, Types... >
 
template<typename Type >
using tpf::types::first_parameter_type_t = hidden::first_parameter_type_t< Type >
 
template<typename Type >
using tpf::types::last_parameter_type_t = hidden::last_type_t< Type >
 
template<auto SelectIndex, typename Type >
using tpf::types::nth_parameter_type_t = hidden::nth_type_t< SelectIndex, Type >
 
template<typename ArgType , typename... Types>
using tpf::types::push_front_type_t = hidden::push_front_type_t< ArgType, Types... >
 
template<typename ArgType , typename... Types>
using tpf::types::push_back_type_t = hidden::push_back_type_t< ArgType, Types... >
 
template<typename... Types>
using tpf::types::pop_front_type_t = hidden::pop_front_type_t< Types... >
 
template<typename... Types>
using tpf::types::pop_back_type_t = hidden::pop_back_type_t< Types... >
 
template<size_t FirstN, typename... Types>
using tpf::types::first_n_types_t = hidden::first_n_types_t< FirstN, Types... >
 
template<size_t FirstN, typename... Types>
using tpf::types::select_first_n_types_t = hidden::select_first_n_types_t< FirstN, Types... >
 
template<size_t LastN, typename... Types>
using tpf::types::last_n_types_t = hidden::last_n_types_t< LastN, Types... >
 
template<size_t LastN, typename... Types>
using tpf::types::select_last_n_types_t = hidden::select_last_n_types_t< LastN, Types... >
 
template<typename... Types>
using tpf::types::unique_types_t = hidden::unique_types_t< Types... >
 
template<typename Type , typename... Types>
using tpf::types::to_variant_t = hidden::to_variant_t< Type, Types... >
 
template<typename TupleType >
using tpf::types::tuple_to_variant_t = hidden::to_variant_t< TupleType >
 
template<template< typename, typename... > class Container, typename TupleType >
using tpf::types::tuple_to_container_of_variants_t = Container< types::to_variant_t< remove_cvref_t< TupleType > > >
 
template<typename... Types>
using tpf::types::to_tuple_t = hidden::to_tuple_t< Types... >
 
template<typename VarType >
using tpf::types::variant_to_tuple_t = hidden::to_tuple_t< VarType >
 
template<typename ArgType , typename RightList >
using tpf::types::prepend_type_t = hidden::prepend_type_t< ArgType, RightList >
 
template<typename ArgType , typename RightList >
using tpf::types::append_type_t = hidden::append_type_t< ArgType, RightList >
 
template<typename LeftList , typename RightList >
using tpf::types::union_type_t = hidden::union_type_t< unique_types_t< LeftList >, unique_types_t< RightList > >
 
template<typename LeftList , typename RightList >
using tpf::types::intersection_type_t = hidden::intersection_type_t< unique_types_t< LeftList >, unique_types_t< RightList > >
 
template<typename ArgType , typename... Types>
using tpf::types::remove_type_t = hidden::remove_type_t< ArgType, Types... >
 
template<typename LeftList , typename RightList >
using tpf::types::difference_type_t = hidden::difference_type_t< LeftList, RightList >
 
template<typename NewType , typename OldType , typename TypeList >
using tpf::types::replace_type_t = hidden::replace_type_t< NewType, OldType, TypeList >
 
template<typename TupleType >
using tpf::types::hidden::tuple_common_element_t = typename st_has_tuple_common_type< TupleType >::type
 
template<typename TupleType >
using tpf::types::hidden::tuple_to_std_array_t = std::array< tuple_common_element_t< TupleType >, tuple_size_v< TupleType > >
 
template<typename TupleType >
using tpf::types::tuple_common_element_t = hidden::tuple_common_element_t< remove_cvref_t< TupleType > >
 
template<typename TupleType >
using tpf::types::tuple_to_std_array_t = hidden::tuple_to_std_array_t< remove_cvref_t< TupleType > >
 
template<typename Type >
using tpf::types::hidden::arg_to_type_t = typename st_is_arg_list< Type >::type
 
template<typename... Types>
using tpf::types::arg_to_type_list_t = typename hidden::st_arg_to_type_list< Types... >::type
 
template<typename Heads , typename Tails >
using tpf::types::arg_list_t = typename hidden::st_build_arg_types< Heads, Tails >::type
 
template<typename CallbackType , typename... Types>
using tpf::types::callable_list_t = typename hidden::st_is_callable< CallbackType, type_list_t<>, type_list_t<>, Types... >::callables
 
template<typename CallbackType , typename... Types>
using tpf::types::non_callable_list_t = typename hidden::st_is_callable< CallbackType, type_list_t<>, type_list_t<>, Types... >::non_callables
 
template<typename... Types>
using tpf::types::concate_type_t = typename concate_type_st< Types... >::type
 
template<typename TestType , typename TypeList , typename ReturnType = TestType>
using tpf::types::enable_if_in_list_t = hidden::enable_if_in_list_t< TestType, TypeList, ReturnType >
 
template<typename TestTypeList , typename TypeList , typename ReturnType = void>
using tpf::types::enable_if_all_in_list_t = hidden::enable_if_all_in_list_t< TestTypeList, TypeList, ReturnType >
 
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using tpf::types::hidden::container_of_variants_t = typename container_of_variants_st< ContainerType, unique_types_t< ElementTypes... > >::type
 
template<template< typename, typename... > class ContainerType, typename KeyType , typename... ElementTypes>
using tpf::types::hidden::container_map_of_variants_t = typename container_of_variants_st< ContainerType, KeyType, unique_types_t< ElementTypes... > >::type
 
template<typename... ElementTypes>
using tpf::types::hidden::vector_of_variants_t = container_of_variants_t< std::vector, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::deque_of_variants_t = container_of_variants_t< std::deque, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::list_of_variants_t = container_of_variants_t< std::list, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::set_of_variants_t = container_of_variants_t< std::set, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::multiset_of_variants_t = container_of_variants_t< std::multiset, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::unordered_set_of_variants_t = container_of_variants_t< std::unordered_set, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::unordered_multiset_of_variants_t = container_of_variants_t< std::unordered_multiset, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::pair_of_variants_t = container_map_of_variants_t< std::pair, KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::map_of_variants_t = container_map_of_variants_t< std::map, KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::multimap_of_variants_t = container_map_of_variants_t< std::multimap, KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::unordered_map_of_variants_t = container_map_of_variants_t< std::unordered_map, KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::unordered_multimap_of_variants_t = container_map_of_variants_t< std::unordered_multimap, KeyType, ElementTypes... >
 
template<typename Type1 , typename Type2 , typename common_t = common_type_t<Type1, Type2>, bool is_integral_type = is_integral_v<common_t>, typename result_type = std::conditional_t< is_integral_type, make_signed_t<common_t>, common_t>>
using tpf::types::signed_common_t = result_type
 
template<typename Type1 , typename Type2 , typename common_t = common_type_t<Type1, Type2>, bool is_integral_type = is_integral_v<common_t>, typename result_type = std::conditional_t< is_integral_type, make_unsigned_t<common_t>, common_t>>
using tpf::types::unsigned_common_t = result_type
 
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using tpf::types::container_of_variants_t = hidden::container_of_variants_t< ContainerType, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::vector_of_variants_t = hidden::vector_of_variants_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::deque_of_variants_t = hidden::deque_of_variants_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::list_of_variants_t = hidden::list_of_variants_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::set_of_variants_t = hidden::set_of_variants_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::multiset_of_variants_t = hidden::multiset_of_variants_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::unordered_set_of_variants_t = hidden::unordered_set_of_variants_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::unordered_multiset_of_variants_t = hidden::unordered_multiset_of_variants_t< ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::map_of_variants_t = hidden::map_of_variants_t< KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::multimap_of_variants_t = hidden::multimap_of_variants_t< KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::unordered_map_of_variants_t = hidden::unordered_map_of_variants_t< KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::unordered_multimap_of_variants_t = hidden::unordered_multimap_of_variants_t< KeyType, ElementTypes... >
 
template<typename Type , typename... Types>
using tpf::types::hidden::types_to_template_class_t = typename types_to_template_class_wrapper_st< Type, Types... >::type
 
template<template< typename... >class ClassTemplate, typename... Types>
using tpf::types::hidden::type_list_to_template_class_t = typename type_list_to_template_class_wrapper_st< ClassTemplate, Types... >::type
 
template<size_t TypeIndex, typename TemplateClass , typename... Types>
using tpf::types::hidden::nth_type_to_template_class_t = typename nth_type_to_template_class_st< TypeIndex, TemplateClass, Types... >::type
 
template<size_t FirstN, template< typename... > typename TemplateClass, typename... Types>
using tpf::types::hidden::first_n_types_list_to_template_class_t = typename first_n_types_list_to_template_class_st< FirstN, TemplateClass, Types... >::type
 
template<size_t FirstN, typename TemplateClass , typename... Types>
using tpf::types::hidden::first_n_types_to_template_class_t = typename first_n_types_to_template_class_st< FirstN, TemplateClass, Types... >::type
 
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using tpf::types::hidden::container_of_tuples_t = typename container_of_tuples_st< ContainerType, ElementTypes... >::type
 
template<typename... ElementTypes>
using tpf::types::hidden::vector_of_tuples_t = container_of_tuples_t< std::vector, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::deque_of_tuples_t = container_of_tuples_t< std::deque, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::list_of_tuples_t = container_of_tuples_t< std::list, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::hidden::set_of_tuples_t = container_of_tuples_t< std::set, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::map_of_tuples_t = container_of_tuples_t< std::map, KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::multimap_of_tuples_t = container_of_tuples_t< std::multimap, KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::unordered_map_of_tuples_t = container_of_tuples_t< std::unordered_map, KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::hidden::unordered_multimap_of_tuples_t = container_of_tuples_t< std::unordered_multimap, KeyType, ElementTypes... >
 
template<typename Type , typename... Types>
using tpf::types::types_to_template_class_t = hidden::types_to_template_class_t< Type, Types... >
 
template<template< typename... > class ClassTemplate, typename... Types>
using tpf::types::type_list_to_template_class_t = hidden::type_list_to_template_class_t< ClassTemplate, Types... >
 
template<size_t SelectTypeIndex, typename TemplateClass , typename... Types>
using tpf::types::nth_type_to_template_class_t = hidden::nth_type_to_template_class_t< SelectTypeIndex, TemplateClass, Types... >
 
template<size_t FirstN, typename TemplateClass , typename... Types>
using tpf::types::first_n_types_to_template_class_t = hidden::first_n_types_to_template_class_t< FirstN, TemplateClass, Types... >
 
template<size_t FirstN, template< typename... > typename TemplateClass, typename... Types>
using tpf::types::first_n_types_list_to_template_class_t = hidden::first_n_types_list_to_template_class_t< FirstN, TemplateClass, Types... >
 
template<template< typename, typename... > class ContainerType, typename... ElementTypes>
using tpf::types::container_of_tuples_t = hidden::container_of_tuples_t< ContainerType, ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::vector_of_tuples_t = hidden::vector_of_tuples_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::deque_of_tuples_t = hidden::deque_of_tuples_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::list_of_tuples_t = hidden::list_of_tuples_t< ElementTypes... >
 
template<typename... ElementTypes>
using tpf::types::set_of_tuples_t = hidden::set_of_tuples_t< ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::map_of_tuples_t = hidden::map_of_tuples_t< KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::multimap_of_tuples_t = hidden::multimap_of_tuples_t< KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::unordered_map_of_tuples_t = hidden::unordered_map_of_tuples_t< KeyType, ElementTypes... >
 
template<typename KeyType , typename... ElementTypes>
using tpf::types::unordered_multimap_of_tuples_t = hidden::unordered_multimap_of_tuples_t< KeyType, ElementTypes... >
 

Enumerations

enum class  tpf::direction_t { tpf::left , tpf::right }
 
enum class  tpf::types::TemplateCategory {
  tpf::types::Unknown , tpf::types::NonTemplate = Unknown , tpf::types::Type , tpf::types::Type_Value ,
  tpf::types::Value , tpf::types::Value_Type
}
 

Functions

constexpr std::size_t tpf::literals::operator""_size_t (unsigned long long value)
 
constexpr unsigned int tpf::literals::operator""_unsigned (unsigned long long value)
 
constexpr short tpf::literals::operator""_short (unsigned long long value)
 
constexpr unsigned short tpf::literals::operator""_ushort (unsigned long long value)
 
constexpr char tpf::literals::operator""_char (unsigned long long value)
 
constexpr char tpf::literals::operator""_schar (unsigned long long value)
 
constexpr unsigned char tpf::literals::operator""_uchar (unsigned long long value)
 
constexpr long double tpf::literals::operator""_ldouble (long double value)
 
template<typename Type_1 , typename Type_2 >
auto tpf::maximum (Type_1 a, Type_2 b)
 
template<typename Type_1 , typename Type_2 , typename... Types>
auto tpf::maximum (Type_1 a, Type_2 b, Types... args)
 
template<typename Type_1 , typename Type_2 >
auto tpf::minimum (Type_1 a, Type_2 b)
 
template<typename Type_1 , typename Type_2 , typename... Types>
auto tpf::minimum (Type_1 a, Type_2 b, Types... args)
 
template<typename Type >
constexpr unsigned long long tpf::two_power_n (Type n)
 
template<std::size_t KeyIndex, typename Type , auto Index, auto... Indices>
constexpr auto tpf::types::get_nth_value (std::integer_sequence< Type, Index, Indices... >) noexcept
 
template<typename Type >
decltype(auto) tpf::types::get_value (Type &&arg)
 
template<class TargetType , class _Ty >
constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, _Ty && > tpf::types::smart_forward (std::remove_reference_t< _Ty > &_Arg) noexcept
 
template<class TargetType , class _Ty >
constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType > tpf::types::smart_forward (std::remove_reference_t< _Ty > &_Arg) noexcept
 
template<class TargetType , class _Ty >
constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, _Ty && > tpf::types::smart_forward (std::remove_reference_t< _Ty > &&_Arg) noexcept
 
template<class TargetType , class _Ty >
constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType > tpf::types::smart_forward (std::remove_reference_t< _Ty > &&_Arg) noexcept
 
template<class TargetType , class _Ty >
constexpr std::enable_if_t< std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, std::remove_reference_t< _Ty > && > tpf::types::smart_move (_Ty &&_Arg) noexcept
 
template<class TargetType , class _Ty >
constexpr std::enable_if_t< !std::is_same_v< std::remove_reference_t< TargetType >, std::remove_reference_t< _Ty > >, TargetType > tpf::types::smart_move (_Ty &&_Arg) noexcept
 
template<auto N, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
 
template<auto N, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::index_sequence< N >, std::unique_ptr< T[], Deleter > &uptr) noexcept
 
template<auto N, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
 
template<auto N, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::index_sequence< N >, std::unique_ptr< T[], Deleter > const &uptr) noexcept
 
template<auto N1, auto N2, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
 
template<auto N1, auto N2, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, std::unique_ptr< T[], Deleter > &uptr) noexcept
 
template<auto N1, auto N2, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
 
template<auto N1, auto N2, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, std::unique_ptr< T[], Deleter > const &uptr) noexcept
 
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::unique_ptr< T[], Deleter > &uptr) noexcept
 
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, std::unique_ptr< T[], Deleter > &uptr) noexcept
 
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::unique_ptr< T[], Deleter > const &uptr) noexcept
 
template<auto N1, auto N2, auto N3, typename T , typename Deleter >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, std::unique_ptr< T[], Deleter > const &uptr) noexcept
 
template<auto N1, auto N2, typename T , auto N, typename = std::enable_if_t<N1* N2 == N>>
auto & tpf::types::cast_ref (T(&array)[N]) noexcept
 
template<auto N1, auto N2, typename T , auto N, typename = std::enable_if_t<N1* N2 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, T(&array)[N]) noexcept
 
template<auto N1, auto N2, typename T , auto N = N1 * N2>
auto & tpf::types::cast_ref (T(&array)[N1][N2]) noexcept
 
template<auto N1, auto N2, typename T , auto N = N1 * N2>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, T(&array)[N1][N2]) noexcept
 
template<auto N1, auto N2, auto N3, typename T , auto N, typename = std::enable_if_t<N1* N2* N3 == N>>
auto & tpf::types::cast_ref (T(&array)[N]) noexcept
 
template<auto N1, auto N2, auto N3, typename T , auto N, typename = std::enable_if_t<N1* N2* N3 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, T(&array)[N]) noexcept
 
template<auto N1, auto N2, auto N3, typename T , auto N = N1 * N2* N3>
auto & tpf::types::cast_ref (T(&array)[N1][N2][N3]) noexcept
 
template<auto N1, auto N2, auto N3, typename T , auto N = N1 * N2* N3>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, T(&array)[N1][N2][N3]) noexcept
 
template<auto N, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto & tpf::types::cast_ref (T array) noexcept
 
template<auto N1, auto N2, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto & tpf::types::cast_ref (T array) noexcept
 
template<auto N1, auto N2, auto N3, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto & tpf::types::cast_ref (T array) noexcept
 
template<auto N, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto & tpf::types::cast_ref (std::index_sequence< N >, T array) noexcept
 
template<auto N1, auto N2, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, T array) noexcept
 
template<auto N1, auto N2, auto N3, typename T , typename = std::enable_if_t<std::is_pointer_v<T>>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, T array) noexcept
 
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t<N1 == N>>
auto & tpf::types::cast_ref (std::array< T, N > &array) noexcept
 
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t<N1 == N>>
auto & tpf::types::cast_ref (std::array< T, N > const &array) noexcept
 
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto & tpf::types::cast_ref (std::array< T, N > &array) noexcept
 
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto & tpf::types::cast_ref (std::array< T, N > const &array) noexcept
 
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t< N1 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1 >, std::array< T, N > &array) noexcept
 
template<std::size_t N1, typename T , std::size_t N, typename = std::enable_if_t< N1 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1 >, std::array< T, N > const &array) noexcept
 
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, std::array< T, N > &array) noexcept
 
template<std::size_t N1, std::size_t N2, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, std::array< T, N > const &array) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto & tpf::types::cast_ref (std::array< T, N > &array) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto & tpf::types::cast_ref (std::array< T, N > const &array) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, std::array< T, N > &array) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T , std::size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, std::array< T, N > const &array) noexcept
 
template<std::size_t N, typename T >
auto & tpf::types::cast_ref (std::vector< T > &vctr) noexcept
 
template<std::size_t N, typename T >
auto & tpf::types::cast_ref (std::vector< T > const &vctr) noexcept
 
template<std::size_t N, typename T >
auto & tpf::types::cast_ref (std::index_sequence< N >, std::vector< T > &vctr) noexcept
 
template<std::size_t N, typename T >
auto & tpf::types::cast_ref (std::index_sequence< N >, std::vector< T > const &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, typename T >
auto & tpf::types::cast_ref (std::vector< T > &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, typename T >
auto & tpf::types::cast_ref (std::vector< T > const &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, typename T >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, std::vector< T > &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, typename T >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2 >, std::vector< T > const &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto & tpf::types::cast_ref (std::vector< T > &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto & tpf::types::cast_ref (std::vector< T > const &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, std::vector< T > &vctr) noexcept
 
template<std::size_t N1, std::size_t N2, std::size_t N3, typename T >
auto & tpf::types::cast_ref (std::index_sequence< N1, N2, N3 >, std::vector< T > const &vctr) noexcept
 
template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t<N1* N2 == N>>
auto tpf::types::cast_array (T(&array)[N]) noexcept
 
template<size_t N1, size_t N2, typename T , size_t N = N1 * N2>
auto tpf::types::cast_array (T(&array)[N1][N2]) noexcept
 
template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t<N1* N2* N3 == N>>
auto tpf::types::cast_array (T(&array)[N]) noexcept
 
template<size_t N1, size_t N2, size_t N3, typename T , size_t N = N1 * N2* N3>
auto tpf::types::cast_array (T(&array)[N1][N2][N3]) noexcept
 
template<typename T , size_t N>
auto tpf::types::cast_array (std::array< T, N > &array) noexcept
 
template<typename T , size_t N>
auto tpf::types::cast_array (std::array< T, N > const &array) noexcept
 
template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto tpf::types::cast_array (std::array< T, N > &array) noexcept
 
template<size_t N1, size_t N2, typename T , size_t N, typename = std::enable_if_t< N1 * N2 == N>>
auto tpf::types::cast_array (std::array< T, N > const &array) noexcept
 
template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto tpf::types::cast_array (std::array< T, N > &array) noexcept
 
template<size_t N1, size_t N2, size_t N3, typename T , size_t N, typename = std::enable_if_t< N1 * N2 * N3 == N>>
auto tpf::types::cast_array (std::array< T, N > const &array) noexcept
 
template<auto Index, typename... ArgTypes, typename = std::enable_if_t<(Index < sizeof...(ArgTypes))>>
decltype(auto) tpf::types::get_nth_argument (ArgTypes &&... args)
 
template<typename T , size_t Size>
auto tpf::types::convert_to_tuple (const std::array< T, Size > &array)
 
template<template< typename... > class TemplateType>
constexpr auto tpf::types::template_category ()
 
template<typename >
constexpr auto tpf::types::template_category (...)
 
template<typename ElementType , size_t ElementCount>
 tpf::types::array_wrapper_t (ElementType(&)[ElementCount]) -> array_wrapper_t< ElementType *, size_t >
 
template<typename ElementType , size_t ElementSize>
auto tpf::types::array_wrapper (ElementType(&array)[ElementSize]) noexcept
 
template<typename Type >
auto tpf::types::to_ref (const Type &value)
 
template<typename ElementType , size_t ElementSize>
constexpr size_t tpf::types::array_size (ElementType(&array)[ElementSize]) noexcept
 
template<typename ContainerType >
auto tpf::types::reverse (ContainerType &&container)
 
template<typename ElementType , size_t ElementCount>
auto tpf::types::reverse (ElementType(&array)[ElementCount])
 
template<typename Type , typename... Types>
auto tpf::types::reverse (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
auto tpf::types::make_vector (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
auto tpf::types::make_container (Type &&arg, Types &&... args)
 
template<template< typename, std::size_t > class ContainerType, typename ArgType , typename... ArgTypes>
auto tpf::types::make_container (ArgType &&arg, ArgTypes &&... args)
 
template<typename ContainerType , typename IndexType >
decltype(auto) tpf::types::get_element (ContainerType container, IndexType index)
 
template<typename Type , typename... Types>
auto tpf::types::make_variants (Type &&arg, Types &&... args)
 
template<typename Type >
decltype(auto) tpf::types::decay (Type &&arg)
 
template<typename Type >
std::string tpf::types::type_to_string ()
 Returns Type's string name. More...
 
template<typename Type >
std::ostream & tpf::types::operator<< (std::ostream &os, range< Type > const &r)
 
template<typename Type >
 tpf::types::range (Type) -> range< Type >
 
template<typename Type >
 tpf::types::range (Type, Type) -> range< Type >
 
template<typename IndexType , typename ContainerType , typename container_t = tpf::remove_cv_ref_t<ContainerType>, typename iterator_type = typename container_t::iterator>
auto tpf::index_to_iterator (ContainerType &&cntr, IndexType &&index)
 
template<typename IndexType , typename ContainerType , typename container_t = tpf::remove_cv_ref_t<ContainerType>, typename reverse_iterator_type = typename container_t::reverse_iterator>
auto tpf::index_to_reverse_iterator (ContainerType &&cntr, IndexType &&offset)
 
template<typename ContainerType , typename container_t = tpf::remove_cv_ref_t<ContainerType>, typename iterator_type = typename container_t::iterator>
auto tpf::iterator_to_index (ContainerType &&cntr, iterator_type &&offset)
 
template<typename ContainerType , typename container_t = tpf::remove_cv_ref_t<ContainerType>, typename reverse_iterator_type = typename container_t::reverse_iterator>
auto tpf::reverse_iterator_to_index (ContainerType &&cntr, reverse_iterator_type &&offset)
 
template<typename ReverseIteratorType , typename reverse_iterator_type = std::remove_reference_t<ReverseIteratorType>>
auto tpf::reverse_iterator_to_iterator (ReverseIteratorType &&itr)
 
template<typename IteratorType , typename iterator_type = std::remove_reference_t<IteratorType>>
auto tpf::iterator_to_reverse_iterator (IteratorType &&itr)
 
template<direction_t direction = direction_t::left, typename ContainerType = std::vector<int>, typename container_t = tpf::remove_cv_ref_t<ContainerType>, typename iterator_type = typename container_t::iterator, typename reverse_iterator_type = typename container_t::reverse_iterator>
auto tpf::make_rotator (ContainerType &&cntr)
 
template<direction_t direction = direction_t::left, typename ContainerType = std::vector<int>, typename container_t = tpf::remove_cv_ref_t<ContainerType>, typename iterator_type = typename container_t::iterator, typename reverse_iterator_type = typename container_t::reverse_iterator, typename execution_policy_type = std::execution::parallel_unsequenced_policy>
auto tpf::make_rotator (ContainerType &&cntr, execution_policy_type policy)
 
template<typename ForwardIterator , typename EleType , typename CompareCallbackType = std::less<>>
auto tpf::find_range_iterators (ForwardIterator first, ForwardIterator last, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename ForwardIterator , typename EleType , typename CompareCallbackType = std::less<>>
auto tpf::find_range_indices (ForwardIterator first, ForwardIterator last, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename EleType , template< typename, typename... > class ContainerType, typename... Types, typename CompareCallbackType = std::less<>>
auto tpf::find_range_iterators (const ContainerType< EleType, Types... > &container, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename EleType , template< typename, typename... > class ContainerType, typename... Types, typename CompareCallbackType = std::less<>>
auto tpf::find_range_indices (const ContainerType< EleType, Types... > &container, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename ForwardIterator , typename EleType , typename CompareCallbackType = std::less<>>
auto tpf::binary_find_iterator (ForwardIterator first, ForwardIterator last, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename ForwardIterator , typename EleType , typename CompareCallbackType = std::less<>>
auto tpf::binary_find_index (ForwardIterator first, ForwardIterator last, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename EleType , template< typename, typename... > class ContainerType, typename... Types, typename CompareCallbackType = std::less<>>
auto tpf::binary_find_iterator (const ContainerType< EleType, Types... > &container, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename ForwardIterator , typename EleType , typename CompareCallbackType = std::less<>>
auto tpf::binary_find_bool_iterator_pair (ForwardIterator first, ForwardIterator last, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename EleType , template< typename, typename... > class ContainerType, typename... Types, typename CompareCallbackType = std::less<>>
auto tpf::binary_find_bool_iterator_pair (const ContainerType< EleType, Types... > &container, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename EleType , template< typename, typename... > class ContainerType, typename... Types, typename CompareCallbackType = std::less<>>
auto tpf::binary_find_index (const ContainerType< EleType, Types... > &container, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename ForwardIterator , typename EleType , typename CompareCallbackType = std::less<>>
auto tpf::binary_find_bool_index_pair (ForwardIterator first, ForwardIterator last, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename EleType , template< typename, typename... > class ContainerType, typename... Types, typename CompareCallbackType = std::less<>>
auto tpf::binary_find_bool_index_pair (const ContainerType< EleType, Types... > &container, const EleType &value, CompareCallbackType &&compare_callback=CompareCallbackType{})
 
template<typename CharType >
std::basic_ostream< CharType > & tpf::types::operator<< (std::basic_ostream< CharType > &os, const no_type_t &)
 
template<typename CharType >
std::basic_ostream< CharType > & tpf::types::operator>> (std::basic_ostream< CharType > &os, const no_type_t &)
 
template<typename T , typename S >
auto tpf::types::hidden::addition_vaild_fn (T t, S s) -> decltype(t+s)
 
template<typename T , typename S >
auto tpf::types::hidden::subtraction_vaild_fn (T t, S s) -> decltype(t - s)
 
template<typename T , typename S >
auto tpf::types::hidden::multiplication_vaild_fn (T t, S s) -> decltype(t *s)
 
template<typename T , typename S >
auto tpf::types::hidden::division_vaild_fn (T t, S s) -> decltype(t/s)
 
constexpr no_type_t tpf::types::operator+ (no_type_t, no_type_t) noexcept
 
constexpr no_type_t tpf::types::operator- (no_type_t, no_type_t) noexcept
 
constexpr no_type_t tpf::types::operator* (no_type_t, no_type_t) noexcept
 
constexpr no_type_t tpf::types::operator/ (no_type_t, no_type_t) noexcept
 
constexpr bool tpf::types::operator== (no_type_t, no_type_t) noexcept
 
constexpr bool tpf::types::operator!= (no_type_t, no_type_t) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, bool > tpf::types::operator== (no_type_t, T &&) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, bool > tpf::types::operator!= (T &&, no_type_t) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator+ (no_type_t, T &&) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator+ (T &&, no_type_t) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator- (no_type_t, T &&) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator- (T &&, no_type_t) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator* (no_type_t, T &&) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator* (T &&, no_type_t) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator/ (no_type_t, T &&) noexcept
 
template<typename T >
constexpr std::enable_if_t<!is_no_type_v< remove_cvref_t< T > >, no_type_ttpf::types::operator/ (T &&, no_type_t) noexcept
 
template<auto N, typename T , T Id, T... Ids>
constexpr T tpf::types::fn_seq_element (std::integer_sequence< T, Id, Ids... >)
 
template<typename T , T Id, T... Ids>
auto tpf::types::seq_to_array (std::integer_sequence< T, Id, Ids... >)
 
template<typename IdType , typename IntType , std::size_t N>
std::array< IntType, N > tpf::types::seq_indices (IdType i, std::array< IntType, N > const &powers)
 
bool tpf::types::is_stack_reversed ()
 
bool tpf::types::is_stack_in_order ()
 
template<auto Begin, auto End, auto Size>
constexpr auto tpf::types::hidden::compute_span ()
 
template<typename T , T... Indices, T Begin, T End, T Increment>
constexpr auto tpf::types::hidden::fn_create_sequence_in_order (std::integer_sequence< T, Indices... >, st_workhorse_range< T, Begin, End, Increment >)
 
template<typename T , T... Indices, T Begin, T End, T Increment>
constexpr auto tpf::types::hidden::fn_create_sequence_reverse_order (std::integer_sequence< T, Indices... >, st_workhorse_range< T, Begin, End, Increment >)
 
bool tpf::types::is_parameter_stack_order_reversed ()
 
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto) tpf::types::array_indexer (ArrayType &&array)
 
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto) tpf::types::array_indexer_row_column (ArrayType &&array)
 
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto) tpf::types::array_writer (ArrayType &&array)
 
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto) tpf::types::array_writer_row_column (ArrayType &&array)
 
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto) tpf::types::array_reader (ArrayType &&array)
 
template<auto RowValue, auto ColumnValue, typename ArrayType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t< is_std_array_v<ArrayType> && Count == std_array_size_v<ArrayType>>>
decltype(auto) tpf::types::array_reader_row_column (ArrayType &&array)
 
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto) tpf::types::tuple_reader (TupleType &&tuple)
 
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto) tpf::types::tuple_reader_row_column (TupleType &&tuple)
 
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto) tpf::types::tuple_writer (TupleType &&tuple)
 
template<auto RowValue, auto ColumnValue, typename TupleType , auto Count = RowValue * ColumnValue, typename = std::enable_if_t<is_tuple_v<TupleType> && Count == tuple_size_v<TupleType>>>
decltype(auto) tpf::types::tuple_writer_row_column (TupleType &&tuple)
 
template<typename... ArgTypes>
void tpf::types::hidden::process_arguments (ArgTypes &&...)
 
template<typename WorkhorseType , auto... Indices>
void tpf::types::hidden::drive_workhorse (WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
 
template<typename WorkhorseType , auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 > > > tpf::types::hidden::drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
 
template<typename WorkhorseType , auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_2d_t< 0, 0 > > > tpf::types::hidden::drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
 
template<typename WorkhorseType , auto... HeightIndices, auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 >, indexer_t< 0 > > > tpf::types::hidden::drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< HeightIndices... >, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
 
template<typename WorkhorseType , auto... HeightIndices, auto... RowIndices, auto... ColumnIndices>
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_3d_t< 0, 0, 0 > > > tpf::types::hidden::drive_workhorse (WorkhorseType &&cabin, typed_sequence_t< HeightIndices... >, typed_sequence_t< RowIndices... >, typed_sequence_t< ColumnIndices... >)
 
template<size_t Count, typename WorkhorseType >
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 > > > tpf::types::drive_workhorse (WorkhorseType &&workhorse)
 
template<auto RowCount, auto ColumnCount, typename WorkhorseType >
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 > >||std::is_invocable_v< WorkhorseType, indexer_2d_t< 0, 0 > > > tpf::types::drive_workhorse (WorkhorseType &&workhorse)
 
template<auto HeightCount, auto RowCount, auto ColumnCount, typename WorkhorseType >
std::enable_if_t< std::is_invocable_v< WorkhorseType, indexer_3d_t< 0, 0, 0 > >||std::is_invocable_v< WorkhorseType, indexer_t< 0 >, indexer_t< 0 >, indexer_t< 0 > > > tpf::types::drive_workhorse (WorkhorseType &&workhorse)
 
template<typename WorkhorseType , auto... Indices>
std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > > > tpf::types::hidden::run_workhorse (WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
 
template<typename WorkhorseType , auto... Indices, typename dummy_sequence = sequence_info_t<StackInOrder, typed_sequence_t<1>>>
std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, dummy_sequence > > tpf::types::hidden::run_workhorse (WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
 
template<typename TupleType , typename WorkhorseType , auto... Indices>
std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > &&std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > > > tpf::types::hidden::run_workhorse (TupleType &&tuple, WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
 
template<typename TupleType , typename WorkhorseType , auto... Indices>
std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > &&std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, std::tuple_element_t< 0, remove_cvref_t< TupleType > > > > tpf::types::hidden::run_workhorse (TupleType &&tuple, WorkhorseType &&workhorse, typed_sequence_t< Indices... >)
 
template<auto... RangeValues, typename WorkhorseType , typename dummy_sequence = make_sequence_t<StackInOrder, 1>, typename sequence_info = sequence_info_t<true, dummy_sequence>>
std::enable_if_t< std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > >||std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, sequence_info > > tpf::types::for_workhorse (WorkhorseType &&workhorse)
 
template<typename TupleType , typename WorkhorseType , typename dummy_sequence = make_sequence_t<StackInOrder, 1>, typename sequence_info = sequence_info_t<true, dummy_sequence>>
std::enable_if_t< is_tuple_v< remove_cvref_t< TupleType > > &&(std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 > >||std::is_invocable_v< remove_cvref_t< WorkhorseType >, indexer_t< 0 >, sequence_info >)> tpf::types::for_workhorse (TupleType &&tuple, WorkhorseType &&workhorse)
 
template<auto... Ints, typename FuncType >
auto tpf::types::hidden::for_tuple (FuncType &&f, typed_sequence_t< Ints... >)
 
template<auto... Ints, typename FuncType >
auto tpf::types::hidden::for_tuple (typed_sequence_t< Ints... >, FuncType &&f)
 
template<auto... RangeValues, typename FuncType >
auto tpf::types::for_tuple (FuncType &&f)
 
template<typename... Types>
auto tpf::types::reverse_tuple (std::tuple< Types... > const &tuple)
 
template<typename T >
constexpr std::enable_if_t< true, typename std::iterator_traits< T >::value_type > tpf::types::hidden::iterator_value_type_fn (T &&)
 
constexpr no_type_t tpf::types::hidden::iterator_value_type_fn (...)
 
template<typename... Types>
type_list_t< Types... > tpf::types::type_to_string (Types &&... args)
 
template<typename Type1 , typename Type2 >
constexpr auto tpf::types::hidden::is_operable_fn (Type1 &&arg1, Type2 &&arg2) noexcept(noexcept(std::declval< remove_cv_ref_t< Type1 > >()) &&noexcept(std::declval< remove_cv_ref_t< Type2 > >())) -> decltype(true ? arg1 :arg2)
 
constexpr no_type_t tpf::types::hidden::is_operable_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_empty_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.empty())
 
constexpr no_type_t tpf::types::hidden::is_empty_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_capacity_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.capacity())
 
constexpr no_type_t tpf::types::hidden::is_capacity_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_shrink_to_fit_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.shrink_to_fit())
 
constexpr no_type_t tpf::types::hidden::is_shrink_to_fit_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_size_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.size())
 
constexpr no_type_t tpf::types::hidden::is_size_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_front_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.front())
 
constexpr no_type_t tpf::types::hidden::is_front_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_back_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.back())
 
constexpr no_type_t tpf::types::hidden::is_back_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_begin_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.begin())
 
constexpr no_type_t tpf::types::hidden::is_begin_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_end_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.end())
 
constexpr no_type_t tpf::types::hidden::is_end_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_rbegin_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.rbegin())
 
constexpr no_type_t tpf::types::hidden::is_rbegin_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_rend_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.rend())
 
constexpr no_type_t tpf::types::hidden::is_rend_available_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_push_front_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.push_front(std::declval< Type >()))
 
constexpr no_type_t tpf::types::hidden::is_push_front_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_index_operator_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.operator[]((size_t) 1))
 
constexpr no_type_t tpf::types::hidden::is_index_operator_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_push_back_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.push_back(std::declval< Type >()))
 
constexpr no_type_t tpf::types::hidden::is_push_back_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_erase_valid_fn (ContainerType< Type, Types... > &&arg) -> decltype(arg.erase(arg.cbegin()))
 
constexpr no_type_t tpf::types::hidden::is_erase_valid_fn (...)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_reserve_valid_fn (ContainerType< Type, Types... > &&arg) -> decltype(arg.reserve((size_t) 0))
 
constexpr no_type_t tpf::types::hidden::is_reserve_valid_fn (...)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_insert_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.insert(std::declval< Type >()))
 
constexpr no_type_t tpf::types::hidden::is_insert_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_insert_iterator_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.insert(arg.cend(), std::declval< Type >()))
 
constexpr no_type_t tpf::types::hidden::is_insert_iterator_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_resize_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.resize(std::declval< size_t >()))
 
constexpr no_type_t tpf::types::hidden::is_resize_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_emplace_front_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.emplace_front(std::declval< Type >()))
 
constexpr no_type_t tpf::types::hidden::is_emplace_front_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_emplace_back_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.emplace_back(std::declval< Type >()))
 
constexpr no_type_t tpf::types::hidden::is_emplace_back_valid_fn (...) noexcept
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_emplace_valid_fn (ContainerType< Type, Types... > &&arg) noexcept(noexcept(std::declval< ContainerType< Type, Types... > >())) -> decltype(arg.emplace(arg.cbegin(), std::declval< Type >()))
 
constexpr no_type_t tpf::types::hidden::is_emplace_valid_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_pop_front_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.pop_front())
 
constexpr no_type_t tpf::types::hidden::is_pop_front_available_fn (...) noexcept
 
template<typename Type >
constexpr auto tpf::types::hidden::is_pop_back_available_fn (Type &&arg) noexcept(noexcept(std::declval< remove_cv_ref_t< Type > >())) -> decltype(arg.pop_back())
 
constexpr no_type_t tpf::types::hidden::is_pop_back_available_fn (...) noexcept
 
template<typename FuncType , typename... ArgTypes>
auto tpf::types::hidden::safe_apply (FuncType &&f, std::tuple< ArgTypes... > const &args) -> decltype(f(std::declval< ArgTypes >()...))
 
template<typename FuncType , typename ArgType , std::size_t N, std::size_t... Ints>
auto tpf::types::hidden::array_apply (FuncType &&f, std::array< ArgType, N > const &args, std::index_sequence< Ints... >) -> decltype(f(std::get< Ints >(args)...))
 
template<typename FuncType , typename ArgType , std::size_t N>
auto tpf::types::hidden::safe_apply (FuncType &&f, std::array< ArgType, N > const &args) -> decltype(array_apply(f, args, std::make_index_sequence< N >{}))
 
template<typename FuncType , typename TupleType >
auto tpf::types::hidden::fn_apply (FuncType &&f, TupleType &&args) -> decltype(safe_apply(f, args))
 
template<typename FuncType , typename... ArgTypes>
types::tuple_if_all_apply_t< FuncType, ArgTypes... > tpf::types::apply_tuple (FuncType &&f, ArgTypes &&... args)
 
template<typename FuncType , typename... ArgTypes>
types::vector_if_all_apply_t< FuncType, ArgTypes... > tpf::types::apply_vector (FuncType &&f, ArgTypes &&... args)
 
template<typename FuncType , typename... ArgTypes>
types::array_if_all_apply_t< FuncType, ArgTypes... > tpf::types::apply_array (FuncType &&f, ArgTypes &&... args)
 
template<typename FuncType , typename... ArgTypes>
auto tpf::types::hidden::function_return_type_fn (FuncType &&func, ArgTypes &&... args) -> decltype(func(args...))
 
template<typename... ArgTypes1, typename... ArgTypes2>
auto tpf::types::hidden::tuple_addition_operator (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b)
 
template<typename... ArgTypes1, typename... ArgTypes2, auto... Indices>
auto tpf::types::hidden::tuple_addition (const std::tuple< ArgTypes1... > &tuple_a, const std::tuple< ArgTypes2... > &tuple_b, types::typed_sequence_t< Indices... >)
 
template<auto... Ints, typename FuncType >
auto tpf::types::hidden::for_array (FuncType &&f, typed_sequence_t< Ints... >)
 
template<auto... Ints, typename FuncType >
auto tpf::types::hidden::for_array (typed_sequence_t< Ints... >, FuncType &&f)
 
template<auto... RangeValues, typename FuncType >
auto tpf::types::for_array (FuncType &&f)
 
template<typename Type , std::size_t N>
auto tpf::types::reverse_array (std::array< Type, N > const &array)
 
template<auto... Ints, typename FuncType >
auto tpf::types::hidden::for_vector (FuncType &&f, typed_sequence_t< Ints... >)
 
template<auto... Ints, typename FuncType >
auto tpf::types::hidden::for_vector (typed_sequence_t< Ints... >, FuncType &&f)
 
template<auto... RangeValues, typename FuncType >
auto tpf::types::for_vector (FuncType &&f)
 
template<typename ArrayType , typename TupleType , auto... Indices>
auto tpf::types::hidden::set_tuple_to_array (TupleType &&tuple, typed_sequence_t< Indices... >)
 
template<typename ContainerType , typename TupleType , auto... Indices>
auto tpf::types::hidden::set_tuple_to_container (TupleType &&tuple, typed_sequence_t< Indices... >)
 
template<typename T , size_t Size, auto... Indices>
auto tpf::types::hidden::set_array_to_tuple (const std::array< T, Size > &array, typed_sequence_t< Indices... >)
 
template<typename Type , typename... Types, auto Size = sizeof...(Types) + 1, typename common_type = std::common_type_t<Type, Types...>, typename array_type = std::array<common_type, Size>>
auto tpf::types::convert_to_array (const std::tuple< Type, Types... > &tuple)
 
template<template< typename, typename... >class ContainerType, typename Type , typename... Types, auto Size = sizeof...(Types) + 1, typename common_type = std::common_type_t<Type, Types...>, typename container_type = ContainerType<common_type>>
auto tpf::types::convert_to_container (const std::tuple< Type, Types... > &tuple)
 
template<typename ContainerType , typename Type , typename... Types, auto Size = sizeof...(Types) + 1>
auto tpf::types::convert_to_container (const std::tuple< Type, Types... > &tuple)
 
template<template< typename, typename... >class ContainerType, typename Type , typename... Types, size_t Size, typename container_type = ContainerType<Type, Types...>>
auto tpf::types::convert_to_container (const std::array< Type, Size > &array)
 
template<int ArgumentIndex, typename FuncType , typename ArgType , typename... ArgTypes, typename = std::enable_if_t< (ArgumentIndex < sizeof...(ArgTypes) + 1) >>
auto tpf::types::freeze_parameter (FuncType &&func, ArgType arg, ArgTypes... args)
 
template<int ArgumentIndex, typename FuncType , typename ArgType , typename... ArgTypes, typename = std::enable_if_t< (ArgumentIndex < sizeof...(ArgTypes) + 1) >>
auto tpf::types::freeze_parameter (FuncType &&func, const std::tuple< ArgType, ArgTypes... > &arguments)
 
template<int FuncIndex, int ArgumentIndex, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes, typename = std::enable_if_t< ( FuncIndex < (sizeof...(FuncTypes) + 1) ) && (ArgumentIndex < sizeof...(ArgTypes) + 1 )>>
auto tpf::types::freeze_parameter (const std::tuple< FuncType, FuncTypes... > &func_tuple, ArgFirst arg, ArgTypes... args)
 
template<int FuncIndex, int ArgumentIndex, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes, typename = std::enable_if_t< ( FuncIndex < sizeof...(FuncTypes) + 1 ) && (ArgumentIndex < sizeof...(ArgTypes)+1)>>
auto tpf::types::freeze_parameter (const std::tuple< FuncType, FuncTypes... > &func_tuple, const std::tuple< ArgFirst, ArgTypes... > &arguments)
 
template<template< typename, size_t > class ReturnClass, typename TupleType , auto... Indices, typename... ArgTypes>
auto tpf::types::hidden::evaluate_lambdas (typed_sequence_t< Indices... >, TupleType &&tuple, ArgTypes &&... args)
 
template<template< typename, size_t > class ReturnClass, typename TupleType , auto... Indices, typename ArgTuple >
auto tpf::types::hidden::evaluate_lambdas_tuple (typed_sequence_t< Indices... >, TupleType &&tuple, ArgTuple &&arguments)
 
template<template< typename, size_t > class ReturnClass, typename FuncType , typename... FuncTypes, typename ArgFirst , typename... ArgTypes>
auto tpf::types::evaluate_lambdas (const std::tuple< FuncType, FuncTypes... > &tuple, ArgFirst &&arg, ArgTypes &&... args)
 
template<template< typename, size_t > class ReturnClass, typename FuncType , typename... FuncTypes, typename ArgFirst >
auto tpf::types::evaluate_lambdas (const std::tuple< FuncType, FuncTypes... > &tuple, ArgFirst &&arg)
 
template<template< typename, typename... > class ContainerType, typename EleType , typename... Types>
auto tpf::types::erase (ContainerType< EleType, Types... > &container, size_t index)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
auto tpf::types::pop_front (ContainerType< Type, Types... > &container)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
auto tpf::types::pop_back (ContainerType< Type, Types... > &container)
 
template<template< typename, typename... > class ContainerType, typename EleType , typename Type , typename... Types>
void tpf::types::push_front (ContainerType< Type, Types... > &container, EleType &&ele)
 
template<template< typename, typename... > class ContainerType, typename EleType , typename Type , typename... Types>
void tpf::types::push_back (ContainerType< Type, Types... > &container, EleType &&ele)
 
template<template< typename, typename... > class ContainerType, typename... EleTypes, typename Type , typename... Types>
void tpf::types::emplace_front (ContainerType< Type, Types... > &container, EleTypes &&... eles)
 
template<template< typename, typename... > class ContainerType, typename... EleTypes, typename Type , typename... Types>
void tpf::types::emplace_back (ContainerType< Type, Types... > &container, EleTypes &&... eles)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
ContainerType< Type, Types... > tpf::types::reverse_order (const ContainerType< Type, Types... > &container)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
void tpf::types::reverse_order_in_place (ContainerType< Type, Types... > &container)
 
template<bool bReverseOrder, typename TargetContainerType , typename SourceContainerType >
void tpf::types::append_to_container (TargetContainerType &target_container, SourceContainerType &&source_container)
 
template<bool bReverseOrder, typename TargetContainerType , typename SourceContainerType >
void tpf::types::prepend_to_container (TargetContainerType &target_container, SourceContainerType &&source_container)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
auto tpf::types::make_random_access_container (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
auto tpf::types::make_deque (Type &&arg, Types &&... args)
 
template<typename ArgType , typename... ArgTypes>
auto tpf::types::make_container (ArgType &&arg, ArgTypes &&... args)
 create either tuple or vector More...
 
template<typename ArgType , typename... ArgTypes>
auto tpf::types::create_container (ArgType &&arg, ArgTypes &&... args)
 Create a container object. More...
 
template<typename VisitorType , typename PairType >
std::enable_if_t< is_pair_of_variant_v< remove_cv_ref_t< PairType > > > tpf::types::visit_variant (VisitorType &&visit, PairType &&vpr)
 
template<typename VisitorType , typename VariantType >
std::enable_if_t< is_variant_v< remove_cv_ref_t< VariantType > > > tpf::types::visit_variant (VisitorType &&visit, VariantType &&vt)
 
template<typename VisitorType , typename IteratorType , typename PairType >
std::enable_if_t< is_pair_of_variant_v< remove_cv_ref_t< PairType > > > tpf::types::visit_variant (VisitorType &&visit, IteratorType &&itr, PairType &&vpr)
 
template<typename VisitorType , typename IteratorType , typename VariantType >
std::enable_if_t< is_variant_v< remove_cv_ref_t< VariantType > > > tpf::types::visit_variant (VisitorType &&visit, IteratorType &&itr, VariantType &&vt)
 
template<typename... CallbackTypes>
 tpf::types::variant_visitors (CallbackTypes...) -> variant_visitors< CallbackTypes... >
 
template<typename... CallbackTypes>
variant_visitors< remove_cv_ref_t< CallbackTypes >... > tpf::types::make_variant_visitors (CallbackTypes &&... visitors)
 
template<typename ContainerType , typename IndexType >
decltype(auto) tpf::get_element (ContainerType container, IndexType index)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
decltype(auto) tpf::make_random_access_container (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
decltype(auto) tpf::make_vector (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
decltype(auto) tpf::make_deque (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
decltype(auto) tpf::make_container (Type &&arg, Types &&... args)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types>
decltype(auto) tpf::make_container (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
decltype(auto) tpf::create_container (Type &&arg, Types &&... args)
 
template<typename Type , typename... Types>
decltype(auto) tpf::make_variants (Type &&arg, Types &&... args)
 
template<typename ContainerType >
decltype(auto) tpf::reverse (ContainerType &&container)
 
template<typename ElementType , size_t ElementCount>
decltype(auto) tpf::reverse (ElementType(&array)[ElementCount])
 
template<typename Type , typename... Types>
decltype(auto) tpf::reverse (Type &&arg, Types &&... args)
 
template<typename IndexType , typename ContainerType , typename iterator_type >
auto tpf::index_to_iterator (ContainerType &&cntr, IndexType &&index)
 
template<typename IndexType , typename ContainerType , typename reverse_iterator_type >
auto tpf::index_to_reverse_iterator (ContainerType &&cntr, IndexType &&index)
 
template<typename ContainerType , typename iterator_type >
auto tpf::iterator_to_index (ContainerType &&cntr, iterator_type &&itr)
 
template<typename ContainerType , typename reverse_iterator_type >
auto tpf::reverse_iterator_to_index (ContainerType &&cntr, reverse_iterator_type &&rev_itr)
 

Variables

template<typename Type >
constexpr bool tpf::is_const_v = std::is_const_v<std::remove_reference_t<Type>>
 
template<typename Type >
constexpr bool tpf::is_const_reference_v
 Test if Type is reference to const object. More...
 
template<typename Type >
constexpr auto tpf::types::type_max_v = std::numeric_limits<Type>::max()
 
constexpr size_t tpf::types::InvalidIndex = type_max_v<size_t>
 
constexpr size_t tpf::types::SelectAll = InvalidIndex
 
template<typename Type >
constexpr bool tpf::types::hidden::is_tag_type_v = st_is_tag_type_v<Type>::value
 
template<typename Type >
constexpr bool tpf::types::is_tag_type_v = hidden::is_tag_type_v<remove_cvref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_numbers_type_v = hidden::st_is_numbers_type_v<remove_cvref_t<Type>>::value
 
template<typename Type >
constexpr bool tpf::types::hidden::is_integer_sequence_v = st_is_integer_sequence<Type>::value
 
template<typename T >
constexpr bool tpf::types::hidden::is_type_list_v = st_is_type_list<remove_cv_ref_t<T>>::value
 
template<typename Type >
constexpr bool tpf::types::is_vector_v = hidden::st_is_vector_v<remove_cvref_t<Type>>::value
 
template<typename Type >
constexpr bool tpf::types::is_integer_sequence_v = hidden::is_integer_sequence_v<remove_cvref_t<Type>>
 
template<typename T >
constexpr bool tpf::types::is_type_list_v = hidden::is_type_list_v<remove_cv_ref_t<T>>
 
template<typename Type >
constexpr bool tpf::types::hidden::is_template_type_v = st_is_template_type<Type>::value
 
template<typename Type >
constexpr bool tpf::types::is_template_type_v = hidden::is_template_type_v<remove_cvref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_array_v = std::is_array_v<remove_cv_ref_t<Type>>
 
template<auto FuncType, typename... ArgTypes>
constexpr auto tpf::types::is_noexcept_v = noexcept(FuncType(std::declval<ArgTypes>()...))
 Test if a function is specified with the keyword noexcept. More...
 
template<typename Type >
constexpr auto tpf::types::hidden::is_variant_v = is_variant_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_unique_ptr_v = is_unique_ptr_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_pair_v = is_pair_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_pair_of_variant_v = is_pair_of_variant_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_map_or_unordered_map_v = is_map_or_unordered_map_st<remove_cv_ref_t<Type>>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_set_or_unordered_set_v = is_set_or_unordered_set_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_tuple_v = is_tuple_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_tuple_empty_v = is_tuple_st<Type>::empty
 
template<typename Type >
constexpr auto tpf::types::hidden::is_any_v = is_any_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_basic_string_v = is_basic_string_st<Type>::value
 
template<typename Type >
constexpr bool tpf::types::hidden::is_char_v = is_char_st<tpf::remove_cv_ref_t<Type>>::value
 
template<typename Type >
constexpr bool tpf::types::is_char_v = hidden::is_char_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_variant_v = hidden::is_variant_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_unique_ptr_v = hidden::is_variant_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_pair_v = hidden::is_pair_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_pair_of_variant_v = hidden::is_pair_of_variant_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_tuple_v = hidden::is_tuple_v<remove_cvref_t<Type>>
 
template<typename Type >
constexpr auto tpf::types::is_tuple_empty_v = hidden::is_tuple_empty_v<remove_cvref_t<Type>>
 
template<typename Type >
constexpr auto tpf::types::hidden::tuple_size_v = st_tuple_size<Type>::value
 
template<typename Type >
constexpr auto tpf::types::tuple_size_v = hidden::tuple_size_v<remove_cvref_t<Type>>
 
template<typename Type >
constexpr auto tpf::types::is_any_v = hidden::is_any_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_map_or_unordered_map_v = hidden::is_map_or_unordered_map_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_basic_string_v = hidden::is_basic_string_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_set_or_unordered_set_v = hidden::is_set_or_unordered_set_v<Type>
 
template<typename Type >
constexpr bool tpf::types::is_no_type_v = std::is_same_v<Type, no_type_t>
 
no_type_t tpf::types::hidden::addition_vaild_fn (...)
 
template<typename T , typename S >
constexpr bool tpf::types::hidden::is_addition_valid_v
 
no_type_t tpf::types::hidden::subtraction_vaild_fn (...)
 
template<typename T , typename S >
constexpr bool tpf::types::hidden::is_subtraction_valid_v
 
no_type_t tpf::types::hidden::multiplication_vaild_fn (...)
 
template<typename T , typename S >
constexpr bool tpf::types::hidden::is_multiplication_valid_v
 
no_type_t tpf::types::hidden::division_vaild_fn (...)
 
template<typename T , typename S >
constexpr bool tpf::types::hidden::is_division_valid_v
 
template<typename T , typename S >
constexpr bool tpf::types::hidden::is_arithmetic_valid_v
 
template<typename T , typename S >
constexpr bool tpf::types::is_addition_valid_v
 
template<typename T , typename S >
constexpr bool tpf::types::is_subtraction_valid_v
 
template<typename T , typename S >
constexpr bool tpf::types::is_multiplication_valid_v
 
template<typename T , typename S >
constexpr bool tpf::types::is_division_valid_v
 
template<typename T , typename S >
constexpr bool tpf::types::is_arithmetic_valid_v
 
template<typename Type >
constexpr bool tpf::types::is_valid_type_v = !is_no_type_v<Type>
 
template<typename Type >
constexpr bool tpf::types::is_std_array_v = hidden::st_is_std_array<remove_cv_ref_t<Type>>::value
 
template<typename Type >
constexpr size_t tpf::types::std_array_size_v = hidden::st_std_array_element<remove_cv_ref_t<Type>>::value
 
constexpr bool tpf::types::StackInOrder = true
 
constexpr bool tpf::types::InOrderSequence = true
 
constexpr bool tpf::types::ReverseSequence = false
 
template<typename T >
constexpr auto tpf::types::hidden::sequence_first_element_v = st_sequence_first_element<T>::value
 
template<typename T >
constexpr auto tpf::types::hidden::sequence_last_element_v = st_sequence_last_element<T>::value
 
template<auto Nth, typename SequenceType >
constexpr auto tpf::types::hidden::sequence_nth_element_v = st_sequence_nth_element<Nth, SequenceType>::value
 
template<typename T >
constexpr auto tpf::types::hidden::sequence_element_count_v = st_sequence_element_count<T>::value
 
template<typename SequenceType >
constexpr auto tpf::types::hidden::sequence_span_v = st_sequence_span<SequenceType>::value
 
template<typename SequenceType >
constexpr auto tpf::types::sequence_first_element_v = hidden::sequence_first_element_v<remove_cvref_t<SequenceType>>
 
template<typename SequenceType >
constexpr auto tpf::types::sequence_last_element_v = hidden::sequence_last_element_v<remove_cvref_t<SequenceType>>
 
template<auto Nth, typename SequenceType >
constexpr auto tpf::types::sequence_nth_element_v = hidden::sequence_nth_element_v<Nth, remove_cvref_t<SequenceType>>
 
template<typename SequenceType >
constexpr auto tpf::types::sequence_element_count_v = hidden::sequence_element_count_v<remove_cvref_t<SequenceType>>
 
template<typename SequenceType >
constexpr auto tpf::types::sequence_span_v = hidden::sequence_span_v<remove_cvref_t<SequenceType>>
 
template<typename... Types>
constexpr auto tpf::types::hidden::type_count_v = type_count_st<Types...>::value
 
template<typename T >
constexpr bool tpf::types::hidden::is_iterator_type_v
 
template<typename T >
constexpr bool tpf::types::hidden::is_iterator_excluding_pointer_v
 
template<typename T >
constexpr bool tpf::types::is_iterator_type_v = hidden::is_iterator_type_v<remove_cv_ref_t<T>>
 
template<typename T >
constexpr bool tpf::types::is_iterator_excluding_pointer_v
 
template<typename... Types>
constexpr auto tpf::types::type_count_v = hidden::type_count_v<Types...>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_template_v = is_template_st<Type>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::template_parameter_count = is_template_st<Type>::count
 
template<typename Type1 , typename Type2 >
constexpr auto tpf::types::hidden::is_same_template_type_v = is_same_template_type_st<Type1, Type2>::value
 
template<typename Type1 , typename Type2 >
constexpr auto tpf::types::hidden::is_same_template_v = is_same_template_st<Type1, Type2>::value
 
template<typename Type >
constexpr auto tpf::types::is_template_v = hidden::is_template_v<Type>
 Test whether the type parameter is a template type. More...
 
template<typename Type >
constexpr auto tpf::types::template_parameter_count = hidden::template_parameter_count<Type>
 
template<typename Type1 , typename Type2 >
constexpr auto tpf::types::is_same_template_type_v = hidden::is_same_template_type_v<Type1, Type2>
 
template<typename Type1 , typename Type2 >
constexpr auto tpf::types::is_same_template_v = hidden::is_same_template_v<Type1, Type2>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_string_v = is_string_st<remove_cv_ref_t<Type>>::value
 
template<typename Type >
constexpr auto tpf::types::is_string_v = hidden::is_string_v<Type>
 Test is Type is of string type. More...
 
template<typename Type1 , typename Type2 >
constexpr auto tpf::types::hidden::is_operable_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_empty_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_capacity_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_shrink_to_fit_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_size_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_front_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_back_available_v = is_valid_type_v<decltype(is_back_available_fn(std::declval<Type>()))>
 
template<typename Type >
constexpr bool tpf::types::hidden::is_begin_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_end_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_rbegin_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_rend_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_push_front_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_index_operator_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_push_back_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_erase_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_reserve_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_insert_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_insert_iterator_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_resize_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_emplace_front_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_emplace_back_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_emplace_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_pop_front_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_pop_back_available_v
 
template<typename Type >
constexpr bool tpf::types::hidden::is_container_type_v
 
template<typename Type , typename... Types>
constexpr auto tpf::types::hidden::is_same_v = is_same_st<Type, Types...>::value
 
template<typename TestType , typename... Types>
constexpr bool tpf::types::hidden::is_in_list_v = is_in_list_st<TestType, Types...>::value
 
template<typename TypeList , typename... TestTypes>
constexpr auto tpf::types::hidden::are_all_in_list_v = are_all_in_list_st<TypeList, TestTypes...>::value
 
template<typename Type >
constexpr auto tpf::types::hidden::is_integer_v = is_in_list_v<Type, integer_list_t>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_unsigned_integer_v = is_in_list_v<Type, unsigned_integer_list_t>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_signed_integer_v = is_in_list_v<Type, signed_integer_list_t>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_integral_v = is_in_list_v<Type, integral_list_t>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_unsigned_integral_v = is_in_list_v<Type, unsigned_integral_list_t>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_signed_integral_v = is_in_list_v<Type, signed_integral_list_t>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_real_number_v = is_in_list_v<Type, real_number_list_t>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_numerical_number_v = is_in_list_v<Type, numerical_number_list_t>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_integers_v = are_all_in_list_v<integer_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_unsigned_integers_v = are_all_in_list_v<unsigned_integer_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_signed_integers_v = are_all_in_list_v<signed_integer_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_integrals_v = are_all_in_list_v<integral_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_unsigned_integrals_v = are_all_in_list_v<unsigned_integral_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_signed_integrals_v = are_all_in_list_v<signed_integral_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_real_numbers_v = are_all_in_list_v<real_number_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::are_numerical_numbers_v = are_all_in_list_v<numerical_number_list_t, Types...>
 
template<typename... Types>
constexpr auto tpf::types::hidden::common_type_v = is_valid_type_v<common_type_t<Types...>>
 
template<typename Type >
constexpr auto tpf::types::hidden::is_reference_wrapper_v
 
template<typename Type >
constexpr auto tpf::types::hidden::is_template_template_v = is_template_v<first_parameter_type_t<Type>>
 
template<typename ArgType , typename... Types>
constexpr auto tpf::types::hidden::is_type_in_list_v = is_type_in_list_st<ArgType, Types...>::value
 
template<typename LeftList , typename RightList >
constexpr auto tpf::types::hidden::is_type_list_equivalent_v = is_type_list_equivalent_st<LeftList, RightList>::value
 
template<typename Type >
constexpr auto tpf::types::is_reference_wrapper_v = hidden::is_reference_wrapper_v<Type>
 
template<typename Type , typename... Types>
constexpr auto tpf::types::is_same_v = hidden::is_same_v<Type, Types...>
 Test if all types are the same. More...
 
template<typename Type , typename... Types>
constexpr auto tpf::types::is_same_flat_v = is_same_v<flat_type_list_t<Type, Types...>>
 
template<typename TestType , typename... Types>
constexpr auto tpf::types::is_in_list_v = hidden::is_in_list_v<TestType, Types...>
 test if TestType exists in Types... More...
 
template<typename Type >
constexpr auto tpf::types::is_integer_v = hidden::is_integer_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_signed_integer_v = hidden::is_signed_integer_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_unsigned_integer_v = hidden::is_unsigned_integer_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_integral_v = hidden::is_integral_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_signed_integral_v = hidden::is_signed_integral_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_unsigned_integral_v = hidden::is_unsigned_integral_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_real_number_v = hidden::is_real_number_v<Type>
 
template<typename Type >
constexpr auto tpf::types::is_numerical_number_v = hidden::is_numerical_number_v<Type>
 
template<typename TypeList , typename... TestTypes>
constexpr auto tpf::types::are_all_in_list_v = hidden::are_all_in_list_v<TypeList, TestTypes...>
 
template<typename... Types>
constexpr auto tpf::types::are_integers_v = hidden::are_integers_v<Types...>
 
template<typename... Types>
constexpr auto tpf::types::are_signed_integers_v = hidden::are_signed_integers_v<Types...>
 
template<typename... Types>
constexpr auto tpf::types::are_unsigned_integers_v = hidden::are_unsigned_integers_v<Types...>
 
template<typename... Types>
constexpr auto tpf::types::are_integrals_v = hidden::are_integrals_v<Types...>
 
template<typename... Types>
constexpr auto tpf::types::are_signed_integrals_v = hidden::are_signed_integrals_v<Types...>
 
template<typename... Types>
constexpr auto tpf::types::are_unsigned_integrals_v = hidden::are_unsigned_integrals_v<Types...>
 
template<typename... Types>
constexpr auto tpf::types::are_real_numbers_v = hidden::are_real_numbers_v<Types...>
 
template<typename... Types>
constexpr auto tpf::types::are_numerical_numbers_v = hidden::are_numerical_numbers_v<Types...>
 
template<typename Type1 , typename Type2 >
constexpr auto tpf::types::is_operable_v = hidden::is_operable_v<Type1, Type2>
 
template<typename... Types>
constexpr auto tpf::types::common_type_v = hidden::common_type_v<Types...>
 
no_type_t tpf::types::hidden::array_apply (...)
 
no_type_t tpf::types::hidden::safe_apply (...)
 
no_type_t tpf::types::hidden::fn_apply (...)
 
template<typename FuncType , typename TupleType >
constexpr bool tpf::types::is_apply_v = !is_no_type_v<apply_return_t<FuncType, TupleType>>
 
template<typename FuncType , typename... TupleTypes>
constexpr bool tpf::types::all_apply_v = ( is_apply_v<FuncType, TupleTypes> && ... )
 
template<typename FuncType , typename... TupleTypes>
constexpr bool tpf::types::common_apply_v
 
template<typename Type >
constexpr bool tpf::types::is_empty_available_v = hidden::is_empty_available_v<Type>
 
template<typename Type >
constexpr bool tpf::types::is_capacity_available_v = hidden::is_capacity_available_v<Type>
 
template<typename Type >
constexpr bool tpf::types::is_shrink_to_fit_available_v = hidden::is_shrink_to_fit_available_v<Type>
 
template<typename Type >
constexpr bool tpf::types::is_index_operator_available_v = hidden::is_index_operator_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_push_front_available_v = hidden::is_push_front_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_push_back_available_v = hidden::is_push_back_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_begin_available_v = hidden::is_begin_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_end_available_v = hidden::is_end_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_rbegin_available_v = hidden::is_rbegin_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_rend_available_v = hidden::is_rend_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_erase_available_v = hidden::is_erase_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_resize_available_v = hidden::is_resize_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_reserve_available_v = hidden::is_reserve_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_size_available_v = hidden::is_size_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_insert_available_v = hidden::is_insert_available_v<Type>
 
template<typename Type >
constexpr bool tpf::types::is_insert_iterator_available_v = hidden::is_insert_iterator_available_v<Type>
 
template<typename Type >
constexpr bool tpf::types::is_emplace_front_available_v = hidden::is_emplace_front_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_emplace_back_available_v = hidden::is_emplace_back_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_emplace_available_v = hidden::is_emplace_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_front_available_v = hidden::is_front_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_back_available_v = hidden::is_back_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_pop_front_available_v = hidden::is_pop_front_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_pop_back_available_v = hidden::is_pop_back_available_v<remove_cv_ref_t<Type>>
 
template<typename Type >
constexpr bool tpf::types::is_container_type_v = hidden::is_container_type_v<remove_cv_ref_t<Type>>
 
no_type_t tpf::types::hidden::function_return_type_fn (...)
 
template<typename FuncType , typename... ArgTypes>
constexpr bool tpf::types::hidden::is_callable_v = !is_no_type_v<function_return_type_t<FuncType, ArgTypes...>>
 
template<typename FuncType , typename... ArgTypes>
constexpr bool tpf::types::hidden::is_void_return_type_v
 
template<typename FuncType , typename... ArgTypes>
constexpr bool tpf::types::is_callable_v = hidden::is_callable_v<FuncType, ArgTypes...>
 
template<typename FuncType , typename... ArgTypes>
constexpr bool tpf::types::is_void_return_type_v = hidden::is_void_return_type_v<FuncType, ArgTypes...>
 
template<typename T , typename... Types>
constexpr bool tpf::types::pairwise_common_type_v = hidden::st_pairwise_common<remove_cvref_t<T>, remove_cvref_t<Types>...>::value
 
template<typename T , typename S >
constexpr bool tpf::types::tuple_common_type_v = hidden::st_tuple_common_type<remove_cvref_t<T>, remove_cvref_t<S>>::value
 
template<typename ArgType , typename... Types>
constexpr auto tpf::types::is_type_in_list_v = hidden::is_type_in_list_v<ArgType, Types...>
 
template<typename LeftList , typename RightList >
constexpr auto tpf::types::is_type_list_equivalent_v
 
template<typename TupleType >
constexpr bool tpf::types::hidden::has_tuple_common_type_v = st_has_tuple_common_type<TupleType>::value
 
template<typename TupleType >
constexpr bool tpf::types::has_tuple_common_type_v = hidden::has_tuple_common_type_v<remove_cvref_t<TupleType>>
 
template<typename CallbackType , typename... Types>
constexpr bool tpf::types::is_invocable_v = hidden::st_is_invocable<CallbackType, Types...>::value
 
template<typename CallbackType , typename... Types>
constexpr bool tpf::types::is_all_callable_v = types::type_count_v<callable_list_t<CallbackType, Types...>> == types::type_count_v<Types...>
 
template<typename CallbackType , typename... Types>
constexpr bool tpf::types::is_any_callable_v = types::type_count_v<callable_list_t<CallbackType, Types...>> != 0
 
template<typename Type >
constexpr auto tpf::types::is_template_template_v = hidden::is_template_template_v<Type>
 
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool tpf::types::is_type_in_the_set_v
 
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool tpf::types::is_constructible_over_the_set_v
 
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool tpf::types::is_assignable_to_the_set_v
 
template<typename Type , typename ListHead , typename... ListTails>
constexpr bool tpf::types::is_assignable_from_the_set_v
 

Detailed Description

Type functions are implemented.

Author
Thomas Kim (Thoma.nosp@m.sKim.nosp@m.@Talk.nosp@m.Play.nosp@m.Fun.c.nosp@m.om)
Version
0.1
Date
2019-04-13

Definition in file tpf_types.hpp.

Macro Definition Documentation

◆ __FUNCTION_NAME__

#define __FUNCTION_NAME__   __PRETTY_FUNCTION__

Definition at line 88 of file tpf_types.hpp.

◆ NOMINMAX

#define NOMINMAX

Definition at line 16 of file tpf_types.hpp.

◆ Tpf_DebugException

#define Tpf_DebugException (   debug_message)    tpf::debug_exception{debug_message, __LINE__, __FILE__}

Definition at line 1409 of file tpf_types.hpp.

◆ Tpf_FormatPrecision

#define Tpf_FormatPrecision   6

Definition at line 24 of file tpf_types.hpp.

◆ Tpf_FormatWidth

#define Tpf_FormatWidth   12

Definition at line 20 of file tpf_types.hpp.

◆ Tpf_GetTypeCategory

#define Tpf_GetTypeCategory (   instance_arg)    Tpf_GetTypeName(decltype(instance_arg))

A macro that returns instance_arg's type category string name.

See also
001-type_to_string.cpp

Definition at line 1428 of file tpf_types.hpp.

◆ Tpf_GetTypeName

#define Tpf_GetTypeName (   type_arg)    tpf::types::type_to_string<type_arg>()

A macro that returns type_arg's string name.

See also
001-type_to_string.cpp

Definition at line 1422 of file tpf_types.hpp.

◆ Tpf_GetValueCategory

#define Tpf_GetValueCategory (   instance_arg)    Tpf_GetTypeName(decltype((instance_arg)))

A macro that returns instance_arg's value category string name.

See also
001-type_to_string.cpp

Definition at line 1434 of file tpf_types.hpp.

◆ Tpf_IsTemplateInstanceV

#define Tpf_IsTemplateInstanceV (   instance_arg)    tpf::types::is_template_v<decltype(instance_arg)>

A macro that tells if instance_arg is of a template type.

Definition at line 8132 of file tpf_types.hpp.

◆ Tpf_IsTemplateV

#define Tpf_IsTemplateV (   type_arg)    tpf::types::is_template_v<type_arg>

A macro that tells if type_arg is a template type.

Definition at line 8126 of file tpf_types.hpp.

◆ Tpf_ThrowDebugException

#define Tpf_ThrowDebugException (   debug_message)    throw tpf::debug_exception{debug_message, __LINE__, __FILE__}

Throw a debug_exception with message as argument.

Definition at line 1416 of file tpf_types.hpp.

◆ Tpf_ToleranceDouble

#define Tpf_ToleranceDouble   1.0e-12

Definition at line 32 of file tpf_types.hpp.

◆ Tpf_ToleranceFloat

#define Tpf_ToleranceFloat   1.0e-7

Definition at line 28 of file tpf_types.hpp.

◆ Tpf_ToleranceLongDouble

#define Tpf_ToleranceLongDouble   1.0e-12

Definition at line 36 of file tpf_types.hpp.