Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
catsfoot::details::add_const_ref< T >
catsfoot::details::add_ref< T >
catsfoot::details::always_false< T >Predicate always false but depending on type parameters
catsfoot::details::always_true< T >Predicate always true but depending on type parameters
catsfoot::auto_conceptBase marker for auto concepts
catsfoot::axiom_failureException class for axiom failure
catsfoot::build_comparer< T >This is class is used to build an black box equality engine
catsfoot::details::call_tuple_helper< Parameter, Functions >
catsfoot::details::call_with_ret< Op, Tuple >
catsfoot::details::call_with_ret< Op, const std::tuple< Args...> & >
catsfoot::details::call_with_ret< Op, std::tuple< Args...> & >
catsfoot::details::call_with_ret< Op, std::tuple< Args...> >
catsfoot::details::callable_bad_map< T >Traits to use on error
catsfoot::details::callable_bad_map< T(U...)>Traits defining an undefined return type
catsfoot::details::callable_real_map< T >Traits to use when everything is OK
catsfoot::details::callable_real_map< T(U...)>Traits defining the return type
catsfoot::details::class_assert_concept< T, bool, bool, bool >Concept checking: predicate
catsfoot::class_assert_concept< T >Checks that a concept is
catsfoot::details::class_assert_concept< concept_list< F, T...>, A, B, C >Concept checking: recursion on a list of requirements
catsfoot::details::class_assert_concept< concept_list<>, A, B, C >Concept checking: empty list of requirements
catsfoot::details::class_assert_concept< T, false, true, true >Concept checking: T is a auto-concept model
catsfoot::details::class_assert_concept< T, true, B, true >Concept checking: T is a concept model
catsfoot::details::class_assert_verified< T >Check that T is a verified model
catsfoot::details::compare< Generator, T >No left operation
catsfoot::details::compare< Generator, T, Op, Ops...>Compare using the first operator and recurse
catsfoot::details::compare_top< Generator, T, Ops >Builds a black-box comparator
catsfoot::conceptBase marker for concepts
catsfoot::concept_list< T >List representation of several concepts
catsfoot::congruence< Rel, Op, Args >Check whether an operation sees equality as congruence relation
catsfoot::congruence_eq< T, Args >Concept for congruence relation with operator==
catsfoot::constant< T, Value >Functor returning and integral constant
catsfoot::constructor_wrap< T >Wraps constructors
catsfoot::container< T, ValueType >
catsfoot::default_generatorGenerator that build default constructors
catsfoot::disamb< Args >Disambiguates an overloaded functions address
catsfoot::disamb_const< Args >Disambiguates an overloaded const member
catsfoot::equality< T, U >Check whether T is comparable to U by ==
catsfoot::equivalence< T, Rel >Generic concept for equivalence relation
catsfoot::equivalence_eq< T >Concept for equivalence relation with operator==
catsfoot::details::eval< T, bool, bool, bool >Default case: predicate
catsfoot::eval< T >Predicate evaluating models and predicates
catsfoot::details::eval< concept_list< T...>, false, false, false >If the parameter is a list of requirements
catsfoot::details::eval< T, true, false, true >If T is an auto-concept model
catsfoot::details::eval< T, true, true, B >If T is a concept model
false_type
catsfoot::term_generator_builder< Types >::generator< Generator, Functions >
catsfoot::details::generator_choose<>
catsfoot::details::generator_choose< T, Other...>
catsfoot::generator_for< T, Type >Whether T is a generator of Type
catsfoot::details::has_get_axiom< U >Predicate testing that U has static member get_axioms()
catsfoot::details::has_requirements< T >Check whether T has a member type requirements
catsfoot::is_auto_concept< T >Checks if T is an auto concept model
catsfoot::is_callable< T >Default case: callable without parameters?
catsfoot::is_callable< T(U...)>Tells whether T is callable with (U...)
catsfoot::is_callable< void(U...)>Void is a special type that may induce extra error messages
catsfoot::is_concept< T >Checks if T is a concept model
catsfoot::is_constructible< T >Undefined
catsfoot::is_constructible< T(U...)>Tells whether T is constructible with {U...}
catsfoot::is_constructible< void(U...)>Void is a special type that may induce extra error messages
catsfoot::details::is_constructible_work_around< false, T()>If not a class, is it always default constructible (maybe)
catsfoot::details::is_constructible_work_around< false, T(U)>If is explicitly convertible and not a class, then it is like constructible
catsfoot::details::is_constructible_work_around< false, T(U...)>If T is not a class, it cannot be built with several parameter
catsfoot::details::is_constructible_work_around< true, T(U...)>If T is a class, then use the standard library
catsfoot::details::is_same< T, U >
catsfoot::is_same< T, U >Check whether T and U are the same type
catsfoot::details::is_same< T, T >
catsfoot::term_generator_builder< Types >::generator< Generator, Functions >::random_container< Return, false >::iterator
catsfoot::list_data_generator< T >Generator using lists of data provided by the user
catsfoot::details::member_wrapper< Ret(T::*)(Args...) const >Wraps a const member
catsfoot::details::member_wrapper< Ret(T::*)(Args...)>Wraps a non-const member
catsfoot::details::member_wrapper< void(T::*)(Args...)>Wraps a non-const void returning member
catsfoot::details::number_function_returns< T >No function given
catsfoot::details::number_function_returns< T, std::function< const T &(Args...)>, Functions...>The first function returns a T
catsfoot::details::number_function_returns< T, std::function< Ret(Args...)>, Functions...>The first function does not return a T
catsfoot::details::number_function_returns< T, std::function< T &&(Args...)>, Functions...>The first function returns a T
catsfoot::details::number_function_returns< T, std::function< T &(Args...)>, Functions...>The first function returns a T
catsfoot::details::number_function_returns< T, std::function< T(Args...)>, Functions...>The first function returns a T
catsfoot::details::number_ground_terms< T >No function
catsfoot::details::number_ground_terms< T, std::function< const T &()>, Functions...>First function is ground term
catsfoot::details::number_ground_terms< T, std::function< Ret(Args...)>, Functions...>First function is not ground term
catsfoot::details::number_ground_terms< T, std::function< T &&()>, Functions...>First function is ground term
catsfoot::details::number_ground_terms< T, std::function< T &()>, Functions...>First function is ground term
catsfoot::details::number_ground_terms< T, std::function< T()>, Functions...>First function is ground term
catsfoot::op_eqWraps operator==
catsfoot::op_incWraps operator++
catsfoot::op_lshWraps operator<<
catsfoot::op_ltWraps operator<
catsfoot::op_neqWraps operator!=
catsfoot::op_plusWraps operator+
catsfoot::op_post_incWraps operator++(T&, int)
catsfoot::op_starWraps operator*
catsfoot::op_timesWraps operator*
catsfoot::pick_functor< T, Generator >
catsfoot::details::position< T, U >Finds the first occurrence of a type in a list
catsfoot::details::position_impl< size_t, typename, >Finds the first occurrence of a type in a list
catsfoot::details::position_impl< N, T, T, U...>Finds the first occurrence of a type in a list
catsfoot::details::position_impl< N, T, U, V...>Finds the first occurrence of a type in a list
catsfoot::printable< T, U >Check whether U is printable on a stream T
catsfoot::product< Type, Constructor, Projections >
catsfoot::details::remove_side_effect_helper< T >
catsfoot::details::return_of< T >
catsfoot::details::return_of< T(Args...)>
catsfoot::selector< T >Constructible type used to select a type for overloaded functions
catsfoot::simple_product< Type, Projections >
catsfoot::details::static_and< F, T...>Predicate true if all predicate parameters are true
catsfoot::details::static_and<>Predicate true if all predicate parameters are true
catsfoot::details::static_binary_and< T, U, bool >Predicate true if all predicate parameters are true
catsfoot::details::static_binary_and< T, U, true >Predicate true if all predicate parameters are true
T
catsfoot::term_generator_builder< Types >Builds random term generators
catsfoot::details::test_all< T, bool, bool >Test axioms of a predicate (always true)
catsfoot::details::test_all< concept_list< T, U...>, false, B >Test axioms of a list of requirements
catsfoot::details::test_all< T, true, false >Test axioms of a concept with no local axioms
catsfoot::details::test_all< T, true, true >Test axioms of a concept with local axioms
catsfoot::details::tester< T, U...>
catsfoot::details::tester<>
catsfoot::details::try_all_compare< T, std::function< Ret(Args...)> >
catsfoot::details::try_firstTag for prioritizing some overloaded functions
catsfoot::details::try_secondTag for prioritizing some overloaded functions
catsfoot::details::tuple_generator< Generator >Generates tuple from generator
catsfoot::details::tuple_generator_tool< U >
catsfoot::details::tuple_generator_tool< const std::tuple< U...> & >Generates containers of tuples std::tuple<U...>
catsfoot::details::tuple_generator_tool< std::tuple< U...> & >Generates containers of tuples std::tuple<U...>
catsfoot::details::tuple_generator_tool< std::tuple< U...> >Generates containers of tuples std::tuple<U...>
catsfoot::undefined_member_typeType used return by has_member_... in case member does not exist
catsfoot::undefined_return< T >Return type used in case of error for is_callable
catsfoot::verified< T >User type traits for validating models
catsfoot::verified< congruence< op_eq, T, Args...> >When T is a congruence_eq, then T is a congruence for ==
catsfoot::verified< congruence_eq< T, Args...> >When T is a congruence for ==, then T is a congruence_eq
catsfoot::verified< equivalence< T, op_eq > >If T is equivalence_eq, then == is an equivalence relation to T
catsfoot::verified< equivalence_eq< T > >If == is an equivalence relation to T, then T is equivalence_eq
catsfoot::verified< product< Type, constructor_wrap< Type >, Projections...> >
catsfoot::wrapped< T >Get the return type of the wrap function
catsfoot::wrapped_constructor< T >Wraps constructor T
catsfoot::details::wrapped_constructor< T(Args...), false >T(Args...) is not constructible
catsfoot::details::wrapped_constructor< T(Args...), true >Wraps constructor T(Args...)