Classes | Namespaces | Typedefs | Enumerations
type_traits.h File Reference
#include "cetlib/metaprogramming.h"
#include <array>
#include <complex>
#include <set>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes

class  fhicl::Atom< T >
 
class  fhicl::OptionalAtom< T >
 
class  fhicl::Table< T, KeysToIgnore >
 
class  fhicl::OptionalTable< T >
 
class  fhicl::TableFragment< T >
 
class  fhicl::Tuple< TYPES >
 
class  fhicl::OptionalTuple< TYPES >
 
class  fhicl::Sequence< T, N >
 
class  fhicl::OptionalSequence< T, N >
 
class  fhicl::TupleAs< T, ARGS >
 
class  fhicl::OptionalTupleAs< T, ARGS >
 
struct  tt::is_int< T >
 
struct  tt::is_callable< T, typename >
 
struct  tt::is_callable< T, enable_if_function_exists_t< std::set< std::string >(T::*)(),&T::operator()> >
 
struct  tt::is_callable< T, enable_if_function_exists_t< std::set< std::string >(T::*)() const, &T::operator()> >
 
struct  tt::maybe_const< T, C >
 
struct  tt::maybe_const< T, const_flavor::require_const >
 
struct  tt::is_sequence_type< Container >
 
struct  tt::is_sequence_type< std::array< ARG, SZ > >
 
struct  tt::is_sequence_type< std::tuple< ARGS... > >
 
struct  tt::is_sequence_type< std::vector< ARGS... > >
 
struct  tt::is_table< T >
 
struct  tt::is_table< fhicl::Table< T, KeysToIgnore > >
 
struct  tt::is_table_fragment< T >
 
struct  tt::is_table_fragment< fhicl::TableFragment< T > >
 
struct  tt::is_optional_parameter< T >
 
struct  tt::is_optional_parameter< fhicl::OptionalTable< T > >
 
struct  tt::is_optional_parameter< fhicl::OptionalAtom< T > >
 
struct  tt::is_optional_parameter< fhicl::OptionalSequence< T, SZ > >
 
struct  tt::is_optional_parameter< fhicl::OptionalTuple< TYPES... > >
 
struct  tt::is_optional_parameter< fhicl::OptionalTupleAs< T(ARGS...)> >
 
struct  tt::is_delegated_parameter< T >
 
struct  tt::is_delegated_parameter< fhicl::DelegatedParameter >
 
struct  tt::is_delegated_parameter< fhicl::OptionalDelegatedParameter >
 
struct  tt::is_fhicl_type< T >
 
struct  tt::is_fhicl_type< fhicl::Table< T, KeysToIgnore > >
 
struct  tt::is_fhicl_type< fhicl::OptionalTable< T > >
 
struct  tt::is_fhicl_type< fhicl::Atom< T > >
 
struct  tt::is_fhicl_type< fhicl::OptionalAtom< T > >
 
struct  tt::is_fhicl_type< fhicl::Sequence< T, SZ > >
 
struct  tt::is_fhicl_type< fhicl::OptionalSequence< T, SZ > >
 
struct  tt::is_fhicl_type< fhicl::Tuple< TYPES... > >
 
struct  tt::is_fhicl_type< fhicl::OptionalTuple< TYPES... > >
 
struct  tt::is_fhicl_type< fhicl::TupleAs< T(ARGS...)> >
 
struct  tt::is_fhicl_type< fhicl::OptionalTupleAs< T(ARGS...)> >
 
struct  tt::fhicl_type_impl< T >
 
struct  tt::fhicl_type_impl< fhicl::Sequence< T, SZ > >
 
struct  tt::fhicl_type_impl< fhicl::Table< T, KeysToIgnore > >
 
struct  tt::fhicl_type_impl< fhicl::Tuple< ARGS... > >
 
struct  tt::fhicl_type_impl< fhicl::TupleAs< T(ARGS...)> >
 
struct  tt::fhicl_type_impl< fhicl::OptionalAtom< T > >
 
struct  tt::fhicl_type_impl< fhicl::OptionalSequence< T, SZ > >
 
struct  tt::fhicl_type_impl< fhicl::OptionalTable< T > >
 
struct  tt::fhicl_type_impl< fhicl::OptionalTuple< ARGS... > >
 
struct  tt::fhicl_type_impl< fhicl::OptionalTupleAs< T(ARGS...)> >
 
struct  tt::return_type_impl< T >
 
struct  tt::return_type_impl< fhicl::Atom< T > >
 
struct  tt::return_type_impl< fhicl::Sequence< T, SZ > >
 
struct  tt::return_type_impl< fhicl::Table< S, KeysToIgnore > >
 
struct  tt::return_type_impl< fhicl::Tuple< ARGS... > >
 
struct  tt::return_type_impl< fhicl::TupleAs< T(ARGS...)> >
 

Namespaces

 fhicl
 
 tt
 

Typedefs

template<bool b, typename T = void>
using tt::disable_if = std::enable_if<!b, T >
 
template<typename T >
using tt::is_numeric = std::is_arithmetic< T >
 
template<typename T >
using tt::is_uint = std::is_unsigned< T >
 
template<typename T , const_flavor C>
using tt::maybe_const_t = typename maybe_const< T, C >::type
 
template<typename T >
using tt::fhicl_type = typename fhicl_type_impl< T >::type
 
template<typename... ARGS>
using tt::return_type = typename return_type_impl< ARGS... >::value_type
 

Enumerations

enum  tt::const_flavor { tt::const_flavor::require_non_const, tt::const_flavor::require_const }