Lumiera  0.pre.03
»edityourfreedom«
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
lib::meta Namespace Reference

Namespaces

 func
 
 test
 

Typedefs

template<class Cond , class T = void>
using disable_if = typename enable_if_c< not Cond::value, T >::type
 
template<typename X >
using enable_CustomStringConversion = enable_if< can_convertToString< X >>
 toggle for explicit specialisations More...
 
template<class Cond , class T = void>
using enable_if = typename enable_if_c< Cond::value, T >::type
 SFINAE helper to control the visibility of specialisations and overloads. More...
 
template<class SRC , class TAR , size_t i>
using ExtractArg = typename ElementExtractor< SRC, TAR >::template Access< i >
 
typedef lib::InPlaceAnyHolder
< sizeof(FunVoid),
lib::InPlaceAnyHolder_unrelatedTypes
FunHolder
 
typedef lib::InPlaceAnyHolder
< sizeof(void
*), lib::InPlaceAnyHolder_unrelatedTypes
FunPtrHolder
 
typedef function< void(void)> FunVoid
 
typedef size_t HasUsableHashDefinition
 
typedef Node< NullType, NullTypeNodeNull
 
template<typename TYPES >
using Tuple = typename BuildTupleType< TYPES >::Type
 Build a std::tuple from types given as type sequence. More...
 
typedef char Yes_t
 helper types to detect the overload resolution chosen by the compiler More...
 

Classes

struct  _Fun
 Helper for uniform access to function signature types. More...
 
struct  _Fun< RET(ARGS...)>
 Specialisation for a bare function signature. More...
 
struct  _Fun< RET(C::*)(ARGS...) const >
 Specialisation to handle member pointer to const function; indirectly this specialisation also handles lambdas, as redirected by the main template (via decltype) More...
 
struct  _Fun< RET(C::*)(ARGS...)>
 Specialisation to deal with member pointer to function. More...
 
struct  _Fun< SIG & >
 Specialisation when using a function reference. More...
 
struct  _Fun< SIG && >
 Specialisation for passing a rvalue reference. More...
 
struct  _Fun< SIG * >
 Specialisation for using a function pointer. More...
 
struct  Append
 append lists-of-types More...
 
struct  Append< Node< TY, TYPES >, NullType >
 
struct  Append< Node< TY, TYPES >, TAIL >
 
struct  Append< NullType, Node< TY, TYPES > >
 
struct  Append< NullType, NullType >
 
struct  Append< NullType, TY2 >
 
struct  Append< TY1, NullType >
 
struct  Apply
 apply a transformation (template) to each type in the list More...
 
struct  Apply< Node< TY, TYPES >, _TRANS_ >
 
struct  BuildConfigFromFlags
 build a configuration type from a list-of-flags More...
 
struct  BuildConfigFromFlags< Node< Flag< Fl >, FLAGS >, CONF >
 
struct  BuildIndexSeq
 build an IndexSeq<0, 1, 2, ..., n-1> More...
 
struct  BuildIndexSeq< 0 >
 
class  BuildTupleAccessor
 Decorating a tuple type with auxiliary data access operations. More...
 
class  BuildTupleAccessor< _X_, Types<>, TUP, i >
 
struct  can_convertToString
 detect possibility of a conversion to string. More...
 
class  can_IterForEach
 Trait template to detect a type usable immediately as "Lumiera Forward Iterator" in a specialised for-each loop This is just a heuristic, based on some common properties of such iterators; it is enough to distinguish it from an STL container, but can certainly be refined. More...
 
struct  can_lexical2string
 types able to be lexically converted to string representation More...
 
class  can_STL_backIteration
 Trait template to detect a type also supporting STL-style backwards iteration. More...
 
class  can_STL_ForEach
 Trait template to detect a type usable with the STL for-each loop. More...
 
struct  can_STL_ForEach< std::unordered_map< KEY, VAL, HASH > >
 the std hashtable(s) are notoriously difficult to handle when it comes to detecting capabilities by metaprogramming, because the're built up from a generic baseclass and especially inherit their iterator-types as template specialisations. More...
 
struct  CartesianProduct
 
class  CloneSupport
 
struct  Combine
 build all possible combinations, based on a enumeration of the basic cases. More...
 
struct  Combine< Node< TY, TYPES >, _ENUM_ >
 
struct  Combine< NullType, _ENUM_ >
 
struct  CombineFlags
 generate all possible on-off combinations of the given flags More...
 
struct  Comparator
 Trait template for invoking equality comparison. More...
 
struct  Comparator< function< SIG > >
 while the boost function implementation doesn't provide comparison, we'll use our private hack, which at least detects equivalence in some cases... More...
 
struct  CondNode
 conditional node: skip an element based on evaluating a predicate More...
 
struct  CondNode< true, T, TAIL >
 
struct  Config
 < distinct type representing a configuration More...
 
struct  ConfigSetFlag
 
struct  ConfigSetFlag< Fl, Config< f1, f2, f3, f4, IGN > >
 set (prepend) the Flag to the given config More...
 
struct  ConstAll
 Build a list of const types from a given typelist. More...
 
struct  ConstAll< Node< TY, TYPES > >
 
struct  ConstAll< NullType >
 
struct  CopySupport
 Policy to pick a suitable implementation of "virtual copy operations". More...
 
struct  CopySupport< X, enable_if< supports_cloning< X > > >
 
struct  CopySupport< X, enable_if< supports_copy_and_assignment< X > > >
 
struct  CopySupport< X, enable_if< supports_only_move< X > > >
 
struct  count
 Metafunction counting the number of Types in the collection. More...
 
struct  count< Node< TY, TYPES > >
 
struct  count< NullType >
 
struct  CountDown
 helper for generating test lists More...
 
struct  CountDown< Num< 0 > >
 
struct  CountDown< Num< I > >
 
struct  DefineConfigByFlags
 create a configuration type for the given list-of-flags More...
 
struct  Dissect
 Allows to access various parts of a given typelist: Start and End, Prefix and Tail... More...
 
struct  Dissect< Node< T, TYPES > >
 
struct  Dissect< NullType >
 
struct  Distribute
 build a list-of lists, where each element of the first arg list gets in turn prepended to all elements of the second arg list. More...
 
struct  Distribute< Node< TY, TYPES >, TAIL >
 
struct  Distribute< NullType, TY >
 
struct  ElementExtractor
 Generic converter to somehow extract values from the "source" type to fill and initialise a tuple of given target type. More...
 
struct  ElementExtractor< lib::diff::Rec, std::tuple< TYPES...> >
 Concrete specialisation to build a std::tuple from a sequence of GenNode elements, with run-time type compatibility check. More...
 
struct  EmptyBase
 
struct  enable_if_c
 
struct  enable_if_c< false, T >
 
struct  Filter
 filter away those types which don't fulfil a predicate metafunction More...
 
struct  Filter< Node< TY, TYPES >, _P_ >
 
struct  Filter< NullType, _P_ >
 
struct  Flag
 
struct  Flag< 0 >
 
struct  FlagInfo
 Helper for calculating values and for invoking runtime code based on a given FlagTuple. More...
 
struct  FlagInfo< Node< CONF, TAIL > >
 
struct  FlagInfo< Node< Flag< ff >, FLAGS > >
 
struct  FlagInfo< NullType >
 
struct  FlagOnOff
 enumeration generator for the Combine metafunction, yielding an "on" and "off" case More...
 
struct  Flags
 
class  FullCopySupport
 
struct  FunctionTypedef
 Build function types from given Argument types. More...
 
struct  FunctionTypedef< RET, Types< A1 > >
 
struct  FunctionTypedef< RET, Types< A1, A2 > >
 
struct  FunctionTypedef< RET, Types< A1, A2, A3 > >
 
struct  FunctionTypedef< RET, Types< A1, A2, A3, A4 > >
 
struct  FunctionTypedef< RET, Types< A1, A2, A3, A4, A5 > >
 
struct  FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6 > >
 
struct  FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7 > >
 
struct  FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8 > >
 
struct  FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >
 
struct  FunctionTypedef< RET, Types<> >
 
struct  FunErasure
 Generic wrapper carrying a function object while hiding the actual function signature. More...
 
struct  IndexIter
 build an index number sequence from a structured reference type More...
 
struct  IndexIter< Types< TYPES...> >
 build an index number sequence from a type sequence More...
 
struct  IndexSeq
 Hold a sequence of index numbers as template parameters. More...
 
struct  InheritFrom
 Helper to just inherit from the given type(s) More...
 
singleton  InstantiateChained
 Build a single inheritance chain of template instantiations. More...
 
class  InstantiateChained< Node< TY, TYPES >, _X_, BASE >
 
class  InstantiateChained< NullType, _X_, BASE >
 
struct  InstantiateChainedCombinations
 Build a Case matrix. More...
 
singleton  InstantiateForEach
 Apply a template to a collection of types. More...
 
class  InstantiateForEach< Node< TY, TYPES >, _X_, BASE >
 
class  InstantiateForEach< NullType, _X_, BASE >
 
singleton  InstantiateWithIndex
 A Variation of InstantiateChained providing an incremented Index value template parameter. More...
 
class  InstantiateWithIndex< Node< TY, TYPES >, _X_, BASE, i >
 
class  InstantiateWithIndex< NullType, _X_, BASE, i >
 
struct  is_basically
 compare unadorned types, disregarding const and references More...
 
struct  is_Functor
 
struct  is_Functor< function< SIG > >
 
struct  is_narrowingInit
 temporary workaround for GCC [Bug-63723], necessary until CGG-5 More...
 
struct  is_narrowingInit< lib::hash::LuidH, TAR >
 
struct  is_nonFloat
 
struct  is_smart_ptr
 detect smart pointers More...
 
struct  is_smart_ptr< std::shared_ptr< T > >
 
struct  is_smart_ptr< std::unique_ptr< T, D > >
 
struct  is_StringLike
 detect various flavours of string / text data More...
 
struct  is_Tuple
 trait to detect tuple types More...
 
struct  is_Tuple< std::tuple< TYPES...> >
 
class  is_Typelist
 Trait template for detecting a typelist type. More...
 
struct  IsInList
 Metafunction to check if a specific type is contained in a given typelist. More...
 
struct  IsInList< TY, Node< TY, TYPES > >
 
struct  IsInList< TY, Node< XX, TYPES > >
 
struct  maxSize
 Metafunction " max( sizeof(T) ) for T in TYPES ". More...
 
struct  maxSize< Node< TY, TYPES > >
 
struct  maxSize< NullType >
 
class  MoveSupport
 
struct  No_t
 
class  NoCopyMoveSupport
 
struct  Node
 
struct  NoInstance
 An Entity never to be instantiated. More...
 
struct  NoUsableHashDefinition
 
struct  NullType
 
struct  Num
 constant-wrapper type for debugging purposes, usable for generating lists of distinguishable types More...
 
struct  Numz
 dummy interface / baseclass for diagnostics More...
 
struct  Pick
 pick the n-th element from a typelist More...
 
struct  Pick< Node< TY, TYPES >, 0 >
 
struct  Pick< Node< TY, TYPES >, i >
 
struct  Pick< Types< TYPES...>, i >
 specialisation: pick n-th element from a type sequence More...
 
struct  PickParametersFromSublist
 
struct  PrefixAll
 prefix each of the elements, yielding a list-of lists-of-types More...
 
struct  PrefixAll< T, Node< TY, TYPES > >
 
struct  PrefixAll< T, NodeNull >
 
struct  PrefixAll< T, NullType >
 
struct  Prepend
 Helper: prepend a type to an existing type sequence, thus shifting all elements within the sequence to the right, eventually dropping the last element. More...
 
struct  Prepend< T, TySeq< TYPES...> >
 temporary workaround: additional specialisation for the template Prepend to work also with the (alternative) variadic TySeq. More...
 
struct  Prepend< T01, Types< T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, IGN > >
 
class  provides_BoostHashFunction
 trait template to detect if some custom type TY provides a boost compliant hash function through ADL More...
 
struct  RefTraits
 Type definition helper for pointer and reference types. More...
 
struct  RefTraits< TY & >
 
struct  RefTraits< TY * >
 
class  Shifted
 Helper: generate a type sequence left shifted by i steps, filling in NullType at the end. More...
 
struct  Shifted< TYPES, 0 >
 
class  SizeTrait
 A collection of constants to describe the expected size of some known classes, without needing to include the respective headers. More...
 
struct  Splice
 splice a typelist like an overlay into an base typelist, starting at given index. More...
 
struct  Splice< Node< B, BS >, Node< O, OS >, 0 >
 
struct  Splice< Node< B, BS >, NullType, 0 >
 
struct  Splice< Node< B, BS >, OVERLAY, i >
 
struct  Splice< NullType, XX, i >
 
struct  Split
 Helper: separate parts of a type sequence. More...
 
struct  Split< Types< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > >
 
struct  SplitLast
 access the last list element More...
 
struct  SplitLast< Node< TY, NullType > >
 
struct  SplitLast< Node< TY, TYPES > >
 
struct  SplitLast< NullType >
 
class  StoreFunction
 Policy for FunErasure: store an embedded std::function Using this policy allows to store arbitrary complex functor objects embedded within a neutral container and retrieving them later type-safe. More...
 
class  StoreFunPtr
 Policy for FunErasure: store a bare function pointer. More...
 
class  StoreUncheckedFunPtr
 Policy for FunErasure: store an unchecked bare function pointer. More...
 
struct  Strip
 Helper for type analysis: tries to strip all kinds of type adornments. More...
 
struct  StripNullType
 temporary workaround: strip trailing NullType entries from a type sequence, to make it compatible with new-style variadic template definitions. More...
 
struct  StripNullType< Types< NullType, TYPES...> >
 
struct  StripNullType< Types< T, TYPES...> >
 
struct  TupleConstructor
 Extensible Adapter to construct a distinct tuple from some arbitrary source type. More...
 
struct  TupleElementDisplayer
 Helper to dump tuple contents. More...
 
struct  TupleElementDisplayer< NullType, TUP, TUP, n >
 
class  Types
 
struct  Types< Node< H, T > >
 Additional specialisation of the basic type sequence type, allowing to re-create a (flat) type sequence from a typelist. More...
 
struct  Types< std::tuple< TYPES...> >
 match and rebind the type sequence from a tuple More...
 
struct  Types<>
 
struct  TySeq
 temporary workaround: alternative definition of "type sequence", already using variadic template parameters. More...
 
struct  UnConst
 strip const from type: naive implementation More...
 
struct  UnConst< const T * >
 
struct  UnConst< const T *const >
 
struct  UnConst< const T >
 
struct  UnConst< T *const >
 
struct  Unwrap
 Helper for type analysis and convenience accessors: attempts to extract a base type from various wrappers. More...
 
struct  Unwrap< boost::reference_wrapper< X > >
 
struct  Unwrap< P< X, B > >
 
struct  Unwrap< std::reference_wrapper< X > >
 
struct  Unwrap< std::shared_ptr< X > >
 
struct  Unwrap< void >
 < More...
 
struct  Unwrap< X * >
 
struct  use_LexicalConversion
 
struct  use_StringConversion4Stream
 when to use custom string conversions for output streams More...
 
class  VirtualCopySupportInterface
 

Functions

template<typename TYPES , class SRC >
Tuple< TYPES > buildTuple (SRC values)
 convenience shortcut to build a tuple from some suitable source data. More...
 
string demangleCxx (Literal rawName)
 Fallback type-ID: More...
 
template<typename... TYPES>
std::string dump (std::tuple< TYPES...> const &tuple)
 convenience function to dump a given tuple's contents. More...
 
template<typename X >
bool equals_safeInvoke (X const &x1, X const &x2)
 
string humanReadableTypeID (lib::Literal)
 pretty-print an internal C++ type representation More...
 
template<typename TY , typename TYPES >
constexpr bool isInList ()
 convenience shortcut: query function More...
 
string primaryTypeComponent (lib::Literal)
 extract core name component from a raw type spec More...
 
string sanitisedFullTypeName (lib::Literal)
 build a sanitised ID from full type name More...
 
string sanitisedSymbol (std::string const &)
 condense a string and retain only valid identifiers More...
 
template<typename TY >
std::string typeStr (TY const *obj=nullptr) noexcept
 failsafe human readable type display More...
 
template<typename TY >
disable_if< std::is_pointer
< TY >, std::string > 
typeStr (TY const &ref) noexcept
 
std::string typeStr (void const *) noexcept
 
template<typename TY >
std::string typeSymbol (TY const *obj=nullptr)
 simple expressive symbol to designate a type More...
 
template<typename TY >
disable_if< std::is_pointer
< TY >, std::string > 
typeSymbol (TY const &ref)
 
template<typename X >
Unwrap< X >::Type & unwrap (X const &wrapped)
 convenience shortcut: unwrapping free function. More...
 

Variables

const string BOOL_FALSE_STR
 
const string BOOL_TRUE_STR
 
const string BOTTOM_INDICATOR
 
const size_t CONFIG_FLAGS_MAX
 
const string FAILURE_INDICATOR
 
const string FUNCTION_INDICATOR
 
NoUsableHashDefinition hash_value (...)
 declared for metaprogramming only, never defined More...
 
const string VOID_INDICATOR
 

Typedef Documentation

typedef size_t HasUsableHashDefinition

Definition at line 83 of file hash-standard.hpp.

typedef function<void(void)> FunVoid

Definition at line 108 of file function-erasure.hpp.

using Tuple = typename BuildTupleType<TYPES>::Type

Build a std::tuple from types given as type sequence.

Remarks
for Lumiera, we deliberately use a dedicated template Types to mark a type sequence of types as such. This allows to pass such a sequence as first-class citizen. The standard library often (ab)uses the std::tuple for this purpose, which is an understandable, yet inferior design choice. We should always favour dedicated types over clever re-use of existing types.

Definition at line 171 of file tuple-helper.hpp.

using ExtractArg = typename ElementExtractor<SRC, TAR>::template Access<i>

Definition at line 310 of file tuple-helper.hpp.

Definition at line 88 of file typelist.hpp.

using enable_if = typename enable_if_c<Cond::value, T>::type

SFINAE helper to control the visibility of specialisations and overloads.

explanation
This template needs to be interspersed somehow into a type expression, which is driven by an external, primary type parameter. Thus, it is possible to use it on an extraneous, possibly default template parameter, or when forming the return type of a function. The purpose is to remove a given definition from sight, unless a boolean condition Cond::value holds true. In the typical usage, this condition is suppled by a metafunction, i.e. a template, which detects some feature or other circumstantial condition with the types involved.
Remarks
this is a widely used facility, available both from boost and from the standard library. For the most common case, we roll our own variant here, which is slightly stripped down and a tiny bit more concise than the boost variant. This way, we can avoid a lot of boost inclusions, which always bear some weight.
See also
std::enable_if

Definition at line 91 of file meta/util.hpp.

using disable_if = typename enable_if_c<not Cond::value, T>::type

Definition at line 94 of file meta/util.hpp.

typedef char Yes_t

helper types to detect the overload resolution chosen by the compiler

Definition at line 103 of file meta/util.hpp.

toggle for explicit specialisations

Definition at line 129 of file meta/util.hpp.


Class Documentation

struct lib::meta::_Fun
+ Inheritance diagram for _Fun< FUN >:
+ Collaboration diagram for _Fun< FUN >:
struct lib::meta::Append
Class Members
typedef Node< TY1, typename
Append< TY2, NullType >::List >
List
+ Collaboration diagram for Append< TY1, TY2 >:
struct lib::meta::Append< Node< TY, TYPES >, NullType >
Class Members
typedef Node< TY, TYPES > List
+ Collaboration diagram for Append< Node< TY, TYPES >, NullType >:
struct lib::meta::Append< Node< TY, TYPES >, TAIL >
Class Members
typedef Node< TY, typename
Append< TYPES, TAIL >::List >
List
+ Collaboration diagram for Append< Node< TY, TYPES >, TAIL >:
struct lib::meta::Append< NullType, Node< TY, TYPES > >
Class Members
typedef Node< TY, TYPES > List
+ Collaboration diagram for Append< NullType, Node< TY, TYPES > >:
struct lib::meta::Append< NullType, NullType >
Class Members
typedef NullType List
+ Collaboration diagram for Append< NullType, NullType >:
struct lib::meta::Append< NullType, TY2 >
Class Members
typedef Node< TY2, NullType > List
+ Collaboration diagram for Append< NullType, TY2 >:
struct lib::meta::Append< TY1, NullType >
Class Members
typedef Node< TY1, NullType > List
+ Collaboration diagram for Append< TY1, NullType >:
struct lib::meta::Apply
Class Members
typedef TY List
+ Collaboration diagram for Apply< TY, _TRANS_ >:
struct lib::meta::Apply< Node< TY, TYPES >, _TRANS_ >
Class Members
typedef Node< typename _TRANS_
< TY >::Type, typename Apply
< TYPES, _TRANS_ >::List >
List
+ Collaboration diagram for Apply< Node< TY, TYPES >, _TRANS_ >:
struct lib::meta::BuildConfigFromFlags
Class Members
typedef CONF Config
typedef Config Type
+ Inheritance diagram for BuildConfigFromFlags< FLAGS, CONF >:
+ Collaboration diagram for BuildConfigFromFlags< FLAGS, CONF >:
struct lib::meta::BuildConfigFromFlags< Node< Flag< Fl >, FLAGS >, CONF >
Class Members
typedef ConfigSetFlag< Fl,
typename BuildConfigFromFlags
< FLAGS, CONF >::Config >
::Config
Config
typedef Config Type
+ Collaboration diagram for BuildConfigFromFlags< Node< Flag< Fl >, FLAGS >, CONF >:
struct lib::meta::BuildIndexSeq
Class Members
typedef typename BuildIndexSeq
< n-1 >::template AppendElm< n-1 >
Ascending
typedef typename BuildIndexSeq
< n-1 >::template FilledWith
< i >::template AppendElm< i >
FilledWith
+ Collaboration diagram for BuildIndexSeq< n >:
struct lib::meta::BuildIndexSeq< 0 >
Class Members
typedef IndexSeq<> Ascending
typedef IndexSeq<> FilledWith
+ Collaboration diagram for BuildIndexSeq< 0 >:
class lib::meta::BuildTupleAccessor< _X_, Types<>, TUP, i >
Class Members
typedef _X_< NullType, TUP,
TUP, i >
Product
+ Collaboration diagram for BuildTupleAccessor< _X_, Types<>, TUP, i >:
struct lib::meta::can_STL_ForEach< std::unordered_map< KEY, VAL, HASH > >
Class Members
__unnamed__
+ Collaboration diagram for can_STL_ForEach< std::unordered_map< KEY, VAL, HASH > >:
struct lib::meta::Combine
Class Members
typedef Distribute< typename
_ENUM_< X >::List, Node
< NullType, NullType > >::List
List
+ Collaboration diagram for Combine< X, _ENUM_ >:
struct lib::meta::Combine< Node< TY, TYPES >, _ENUM_ >
Class Members
typedef Distribute< typename
_ENUM_< TY >::List, typename
Combine< TYPES, _ENUM_ >::List >
::List
List
+ Collaboration diagram for Combine< Node< TY, TYPES >, _ENUM_ >:
struct lib::meta::Combine< NullType, _ENUM_ >
Class Members
typedef NodeNull List
+ Collaboration diagram for Combine< NullType, _ENUM_ >:
struct lib::meta::CombineFlags
Class Members
typedef Combine< FLAGS,
FlagOnOff >::List
List
+ Collaboration diagram for CombineFlags< FLAGS >:
struct lib::meta::CondNode
Class Members
typedef TAIL Next
+ Collaboration diagram for CondNode< bool, T, TAIL >:
struct lib::meta::CondNode< true, T, TAIL >
Class Members
typedef Node< T, TAIL > Next
+ Collaboration diagram for CondNode< true, T, TAIL >:
struct lib::meta::Config
Class Members
typedef Flags< f1, f2, f3, f4,
f5 >::Tuple
Flags
typedef Flags List
+ Collaboration diagram for Config< f1, f2, f3, f4, f5 >:
struct lib::meta::ConfigSetFlag
+ Collaboration diagram for ConfigSetFlag< Fl, CONF >:
struct lib::meta::ConfigSetFlag< Fl, Config< f1, f2, f3, f4, IGN > >
Class Members
typedef Config< Fl, f1, f2, f3,
f4 >
Config
+ Collaboration diagram for ConfigSetFlag< Fl, Config< f1, f2, f3, f4, IGN > >:
struct lib::meta::ConstAll
+ Collaboration diagram for ConstAll< TYPES >:
struct lib::meta::ConstAll< Node< TY, TYPES > >
Class Members
typedef Node< const TY,
typename ConstAll< TYPES >
::List >
List
+ Collaboration diagram for ConstAll< Node< TY, TYPES > >:
struct lib::meta::ConstAll< NullType >
Class Members
typedef NullType List
+ Collaboration diagram for ConstAll< NullType >:
struct lib::meta::CopySupport
Class Members
typedef NoCopyMoveSupport< I,
D, B >
Policy
+ Collaboration diagram for CopySupport< X, SEL >:
struct lib::meta::CopySupport< X, enable_if< supports_cloning< X > > >
Class Members
typedef CloneSupport< I, D, B > Policy
+ Collaboration diagram for CopySupport< X, enable_if< supports_cloning< X > > >:
struct lib::meta::CopySupport< X, enable_if< supports_copy_and_assignment< X > > >
Class Members
typedef FullCopySupport< I, D, B > Policy
+ Collaboration diagram for CopySupport< X, enable_if< supports_copy_and_assignment< X > > >:
struct lib::meta::CopySupport< X, enable_if< supports_only_move< X > > >
Class Members
typedef MoveSupport< I, D, B > Policy
+ Collaboration diagram for CopySupport< X, enable_if< supports_only_move< X > > >:
struct lib::meta::count
+ Collaboration diagram for count< TYPES >:
struct lib::meta::count< Node< TY, TYPES > >
Class Members
__unnamed__
+ Collaboration diagram for count< Node< TY, TYPES > >:
struct lib::meta::count< NullType >
Class Members
__unnamed__
+ Collaboration diagram for count< NullType >:
struct lib::meta::CountDown
Class Members
typedef NullType List
+ Collaboration diagram for CountDown< X >:
struct lib::meta::CountDown< Num< 0 > >
Class Members
typedef Node< Num< 0 >, NullType > List
+ Collaboration diagram for CountDown< Num< 0 > >:
struct lib::meta::CountDown< Num< I > >
Class Members
typedef Node< Num< I >
, typename CountDown< Num< I-1 >
>::List >
List
+ Collaboration diagram for CountDown< Num< I > >:
struct lib::meta::Dissect
+ Collaboration diagram for Dissect< TYPES >:
struct lib::meta::Dissect< Node< T, TYPES > >
Class Members
typedef Node< T, TYPES > List the complete list
typedef T Head first element
typedef Node< T, NullType > First a list containing the first element
typedef TYPES Tail remainder of the list starting with the second elm.
typedef SplitLast< List >::List Prefix all of the list, up to but excluding the last element
typedef SplitLast< List >::Type End the last element
typedef Node< End, NullType > Last a list containing the last element
+ Collaboration diagram for Dissect< Node< T, TYPES > >:
struct lib::meta::Dissect< NullType >
Class Members
typedef NullType List
typedef NullType Head
typedef NullType First
typedef NullType Tail
typedef NullType Prefix
typedef NullType End
typedef NullType Last
+ Collaboration diagram for Dissect< NullType >:
struct lib::meta::Distribute
Class Members
typedef PrefixAll< TY1, TY2 >::List List
+ Inheritance diagram for Distribute< TY1, TY2 >:
+ Collaboration diagram for Distribute< TY1, TY2 >:
struct lib::meta::Distribute< Node< TY, TYPES >, TAIL >
Class Members
typedef Append< typename
PrefixAll< TY, TAIL >::List,
typename Distribute< TYPES,
TAIL >::List >::List
List
+ Collaboration diagram for Distribute< Node< TY, TYPES >, TAIL >:
struct lib::meta::Distribute< NullType, TY >
Class Members
typedef NullType List
+ Collaboration diagram for Distribute< NullType, TY >:
struct lib::meta::ElementExtractor
+ Collaboration diagram for ElementExtractor< SRC, TAR >:
struct lib::meta::ElementExtractor< lib::diff::Rec, std::tuple< TYPES...> >
Class Members
TargetType
+ Collaboration diagram for ElementExtractor< lib::diff::Rec, std::tuple< TYPES...> >:
struct lib::meta::EmptyBase
+ Collaboration diagram for EmptyBase:
struct lib::meta::enable_if_c
Class Members
typedef T type
+ Collaboration diagram for enable_if_c< B, T >:
struct lib::meta::enable_if_c< false, T >
+ Collaboration diagram for enable_if_c< false, T >:
struct lib::meta::Filter
+ Collaboration diagram for Filter< TYPES, _P_ >:
struct lib::meta::Filter< Node< TY, TYPES >, _P_ >
Class Members
typedef CondNode< _P_< TY >
::value, TY, typename Filter
< TYPES, _P_ >::List >::Next
List
+ Collaboration diagram for Filter< Node< TY, TYPES >, _P_ >:
struct lib::meta::Filter< NullType, _P_ >
Class Members
typedef NullType List
+ Collaboration diagram for Filter< NullType, _P_ >:
struct lib::meta::Flag
Class Members
typedef Flag ID
+ Collaboration diagram for Flag< bit >:
struct lib::meta::Flag< 0 >
Class Members
typedef NullType ID
+ Collaboration diagram for Flag< 0 >:
struct lib::meta::FlagInfo
+ Collaboration diagram for FlagInfo< FLAGS >:
struct lib::meta::FlagInfo< Node< Flag< ff >, FLAGS > >
Class Members
__unnamed__
+ Collaboration diagram for FlagInfo< Node< Flag< ff >, FLAGS > >:
struct lib::meta::FlagOnOff
Class Members
typedef Node< F, Node
< NullType, NullType > >
List
+ Collaboration diagram for FlagOnOff< F >:
struct lib::meta::Flags
Class Members
typedef Types< typename Flag
< f1 >::ID, typename Flag< f2 >
::ID, typename Flag< f3 >::ID,
typename Flag< f4 >::ID,
typename Flag< f5 >::ID >
::List
Tuple
typedef Tuple List
+ Collaboration diagram for Flags< f1, f2, f3, f4, f5 >:
struct lib::meta::FunctionTypedef
+ Collaboration diagram for FunctionTypedef< RET, ARGS >:
struct lib::meta::FunctionTypedef< RET, Types< A1 > >
Class Members
typedef function< RET(A1)> Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2 > >
Class Members
typedef function< RET(A1, A2)> Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2, A3 > >
Class Members
typedef function< RET(A1, A2, A3)> Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2, A3 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4 > >
Class Members
typedef function< RET(A1, A2,
A3, A4)>
Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2, A3, A4 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5 > >
Class Members
typedef function< RET(A1, A2,
A3, A4, A5)>
Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2, A3, A4, A5 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6 > >
Class Members
typedef function< RET(A1, A2,
A3, A4, A5, A6)>
Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7 > >
Class Members
typedef function< RET(A1, A2,
A3, A4, A5, A6, A7)>
Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8 > >
Class Members
typedef function< RET(A1, A2,
A3, A4, A5, A6, A7, A8)>
Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8 > >:
struct lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >
Class Members
typedef function< RET(A1, A2,
A3, A4, A5, A6, A7, A8, A9)>
Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >:
struct lib::meta::FunctionTypedef< RET, Types<> >
Class Members
typedef function< RET(void)> Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types<> >:
struct lib::meta::IndexIter
+ Collaboration diagram for IndexIter< REF >:
struct lib::meta::IndexIter< Types< TYPES...> >
Class Members
typedef typename BuildIndexSeq
< SIZ >::Ascending
Seq
Class Members
__unnamed__
+ Collaboration diagram for IndexIter< Types< TYPES...> >:
struct lib::meta::IndexSeq
Class Members
AppendElm
+ Collaboration diagram for IndexSeq< idx >:
singleton lib::meta::InstantiateWithIndex
+ Collaboration diagram for InstantiateWithIndex< TYPES, _X_, BASE, i >:
struct lib::meta::IsInList
Class Members
__unnamed__
+ Collaboration diagram for IsInList< TY, TYPES >:
struct lib::meta::IsInList< TY, Node< TY, TYPES > >
Class Members
__unnamed__
+ Collaboration diagram for IsInList< TY, Node< TY, TYPES > >:
struct lib::meta::IsInList< TY, Node< XX, TYPES > >
Class Members
__unnamed__
+ Collaboration diagram for IsInList< TY, Node< XX, TYPES > >:
struct lib::meta::maxSize
+ Collaboration diagram for maxSize< TYPES >:
struct lib::meta::No_t
Class Members
char more_than_one[4]
+ Collaboration diagram for No_t:
struct lib::meta::Node
Class Members
typedef Node List
typedef H Head
typedef T Tail
+ Collaboration diagram for Node< H, T >:
struct lib::meta::NoUsableHashDefinition
Class Members
size_t more_than_one[2]
+ Collaboration diagram for NoUsableHashDefinition:
struct lib::meta::NullType
Class Members
typedef NullType List
+ Collaboration diagram for NullType:
struct lib::meta::Pick
Class Members
typedef NullType Type
+ Collaboration diagram for Pick< TYPES, i >:
struct lib::meta::Pick< Node< TY, TYPES >, 0 >
Class Members
typedef TY Type
+ Collaboration diagram for Pick< Node< TY, TYPES >, 0 >:
struct lib::meta::Pick< Node< TY, TYPES >, i >
Class Members
typedef Pick< TYPES, i-1 >::Type Type
+ Collaboration diagram for Pick< Node< TY, TYPES >, i >:
struct lib::meta::Pick< Types< TYPES...>, i >
Class Members
Type
+ Collaboration diagram for Pick< Types< TYPES...>, i >:
struct lib::meta::PickParametersFromSublist
+ Collaboration diagram for PickParametersFromSublist< _X_ >:
struct lib::meta::PrefixAll
Class Members
typedef Node< typename Append
< T, TY >::List, NullType >
List
+ Collaboration diagram for PrefixAll< T, TY >:
struct lib::meta::PrefixAll< T, Node< TY, TYPES > >
Class Members
typedef Node< typename Append
< T, TY >::List, typename
PrefixAll< T, TYPES >::List >
List
+ Collaboration diagram for PrefixAll< T, Node< TY, TYPES > >:
struct lib::meta::PrefixAll< T, NodeNull >
Class Members
typedef Node< typename Append
< T, NodeNull >::List,
NullType >
List
+ Collaboration diagram for PrefixAll< T, NodeNull >:
struct lib::meta::PrefixAll< T, NullType >
Class Members
typedef NullType List
+ Collaboration diagram for PrefixAll< T, NullType >:
struct lib::meta::Prepend
+ Collaboration diagram for Prepend< T, TYPES >:
struct lib::meta::Prepend< T, TySeq< TYPES...> >
Class Members
Seq
List
+ Collaboration diagram for Prepend< T, TySeq< TYPES...> >:
struct lib::meta::Prepend< T01, Types< T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, IGN > >
Class Members
typedef Types< T01, T02, T03,
T04, T05, T06, T07, T08, T09,
T10, T11, T12, T13, T14, T15,
T16, T17, T18, T19, T20 >
Seq
typedef List List
+ Collaboration diagram for Prepend< T01, Types< T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, IGN > >:
struct lib::meta::RefTraits
Class Members
typedef TY * pointer
typedef TY & reference
typedef TY value_type
+ Collaboration diagram for RefTraits< TY >:
struct lib::meta::RefTraits< TY & >
Class Members
typedef TY * pointer
typedef TY & reference
typedef TY value_type
+ Collaboration diagram for RefTraits< TY & >:
struct lib::meta::RefTraits< TY * >
Class Members
typedef TY * pointer
typedef TY & reference
typedef TY value_type
+ Collaboration diagram for RefTraits< TY * >:
struct lib::meta::Shifted< TYPES, 0 >
Class Members
typedef TYPES Type
typedef Split< Type >::Head Head
+ Collaboration diagram for Shifted< TYPES, 0 >:
struct lib::meta::Splice
+ Collaboration diagram for Splice< BASE, OVERLAY, i >:
struct lib::meta::Splice< Node< B, BS >, Node< O, OS >, 0 >
Class Members
typedef Node< O, typename
Splice< BS, OS, 0 >::List >
List
typedef NullType Front
typedef Splice< BS, OS, 0 >::Back Back
+ Collaboration diagram for Splice< Node< B, BS >, Node< O, OS >, 0 >:
struct lib::meta::Splice< Node< B, BS >, NullType, 0 >
Class Members
typedef Node< B, BS > List
typedef NullType Front
typedef Node< B, BS > Back
+ Collaboration diagram for Splice< Node< B, BS >, NullType, 0 >:
struct lib::meta::Splice< Node< B, BS >, OVERLAY, i >
Class Members
typedef Node< B, typename
Splice< BS, OVERLAY, i-1 >
::List >
List
typedef Node< B, typename
Splice< BS, OVERLAY, i-1 >
::Front >
Front
typedef Splice< BS, OVERLAY, i-1 >
::Back
Back
+ Collaboration diagram for Splice< Node< B, BS >, OVERLAY, i >:
struct lib::meta::Splice< NullType, XX, i >
Class Members
typedef NullType List
typedef NullType Front
typedef NullType Back
+ Collaboration diagram for Splice< NullType, XX, i >:
struct lib::meta::Split
+ Collaboration diagram for Split< TYPES >:
struct lib::meta::Split< Types< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > >
Class Members
typedef Types< T01, T02, T03,
T04, T05, T06, T07, T08, T09,
T10, T11, T12, T13, T14, T15,
T16, T17, T18, T19, T20 >
::List
List
typedef T01 Head
typedef Types< T01 > First
typedef Types< T02, T03, T04,
T05, T06, T07, T08, T09, T10,
T11, T12, T13, T14, T15, T16,
T17, T18, T19, T20 >
Tail
typedef SplitLast< List >::List PrefixList
typedef List TailList
typedef Types< PrefixList >::Seq Prefix
typedef SplitLast< List >::Type End
typedef Types< End > Last
+ Collaboration diagram for Split< Types< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > >:
struct lib::meta::SplitLast
+ Collaboration diagram for SplitLast< TYPES >:
struct lib::meta::SplitLast< Node< TY, NullType > >
Class Members
typedef TY Type
typedef NullType List
+ Collaboration diagram for SplitLast< Node< TY, NullType > >:
struct lib::meta::SplitLast< Node< TY, TYPES > >
Class Members
typedef SplitLast< TYPES >::Type Type
typedef Append< TY, typename
SplitLast< TYPES >::List >
::List
List
+ Collaboration diagram for SplitLast< Node< TY, TYPES > >:
struct lib::meta::SplitLast< NullType >
Class Members
typedef NullType Type
typedef NullType List
+ Collaboration diagram for SplitLast< NullType >:
struct lib::meta::Strip
Class Members
typedef remove_cv< X >::type TypeUnconst
typedef remove_reference
< TypeUnconst >::type
TypeReferred
typedef remove_pointer
< TypeReferred >::type
TypePointee
typedef remove_cv< TypePointee >
::type
TypePlain
typedef Unwrap< TypePlain >::Type Type
+ Collaboration diagram for Strip< X >:
struct lib::meta::StripNullType
+ Collaboration diagram for StripNullType< SEQ >:
struct lib::meta::StripNullType< Types< NullType, TYPES...> >
Class Members
typedef TySeq<> Seq
+ Collaboration diagram for StripNullType< Types< NullType, TYPES...> >:
struct lib::meta::StripNullType< Types< T, TYPES...> >
Class Members
TailSeq
typedef typename Prepend< T,
TailSeq >::Seq
Seq
+ Collaboration diagram for StripNullType< Types< T, TYPES...> >:
struct lib::meta::Types< Node< H, T > >
Class Members
typedef Node< H, T > List
typedef Prepend< H, typename
Types< T >::Seq >::Seq
Seq
+ Collaboration diagram for Types< Node< H, T > >:
struct lib::meta::Types< std::tuple< TYPES...> >
Class Members
Seq
typedef typename List List
+ Collaboration diagram for Types< std::tuple< TYPES...> >:
struct lib::meta::Types<>
Class Members
typedef NullType List
typedef Types<> Seq
+ Collaboration diagram for Types<>:
struct lib::meta::TySeq
Class Members
typedef TySeq Seq
List
+ Collaboration diagram for TySeq< TYPES >:
struct lib::meta::UnConst
Class Members
typedef T Type
+ Collaboration diagram for UnConst< T >:
struct lib::meta::UnConst< const T * >
Class Members
typedef T * Type
+ Collaboration diagram for UnConst< const T * >:
struct lib::meta::UnConst< const T *const >
Class Members
typedef T * Type
+ Collaboration diagram for UnConst< const T *const >:
struct lib::meta::UnConst< const T >
Class Members
typedef T Type
+ Collaboration diagram for UnConst< const T >:
struct lib::meta::UnConst< T *const >
Class Members
typedef T * Type
+ Collaboration diagram for UnConst< T *const >:
struct lib::meta::Unwrap< void >
Class Members
typedef void Type
+ Collaboration diagram for Unwrap< void >:

Function Documentation

std::string demangleCxx ( Literal  rawName)

Fallback type-ID:

reverse the effect of C++ name mangling.

Returns
unaltered internal type-ID
string in language-level form of a C++ type or object name, or a string with the original input if demangling fails.
Warning
implementation relies on the cross vendor C++ ABI in use by GCC and compatible compilers, so portability is limited. The implementation is accessed through libStdC++ Name representation in emitted object code and type IDs is essentially an implementation detail and subject to change.

Definition at line 156 of file format-obj.cpp.

Referenced by humanReadableTypeID(), primaryTypeComponent(), and TypeDemangling_test::run().

+ Here is the caller graph for this function:

std::string humanReadableTypeID ( Literal  rawType)

pretty-print an internal C++ type representation

implementation notes
  • we do not strip type adornments like const, & or *, however, the typical usage from within util::typeStr() is arranged in a way to absorb these adornments by the way the template signatures are defined
  • we do simplify the type display and strip some obnoxious namespace prefixes with the help of std::regex_replace
  • we perform those simplifying rewrites in place thus overwriting the result string. This exploits the fact that the replacements are always shorter than what is being replaced (beware).
  • standard regular expressions can be assumed to be threadsafe. Thus, we're able to build an embedded shared static variable on demand and use the performance optimisation offered by the standard library
  • performance wise we'll assume the transformation happens within the cache, so it doesn't make much of a difference if we scan the same comparatively short string multiple times
See also
format-obj.cpp implementation

Definition at line 187 of file format-obj.cpp.

References demangleCxx(), and TYP_EXP.

Referenced by TypeDisplay_test::run(), sanitisedFullTypeName(), and typeStr().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::string primaryTypeComponent ( Literal  rawType)

extract core name component from a raw type spec

implementation notes
We want to get at the name of the most relevant type entity. This in itself is a heuristic. But we can work on the assumption, that we get a sequence of nested namespaces and type names, and we'll be interested in the last, the innermost of these types. In the most general case, each type could be templated, and thus will be followed by parameter specs enclosed in angle braces. Behind this spec, only type adornments will follow. Thus we'll inspect the string from the back side, skipping over all type parameter contents, until we reach brace level zero again. From this point, we have to search backwards to the first namespace separator ::
Warning
we acknowledge this function can fail in various ways, some of which will be indicated by returning the string "void". But it may well happen that the returned string contains whitespace, superfluous punctuation or even the whole demangled type specification as is.
Returns
simple identifier possibly "the" type
Warning
implemented lexically, not necessarily correct!

Definition at line 258 of file format-obj.cpp.

References demangleCxx(), util::isnil(), util::removeSuffix(), typeStr(), and VOID_INDICATOR.

Referenced by TypeDisplay_test::run(), lib::idi::typeSymbol(), and typeSymbol().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::string sanitisedFullTypeName ( lib::Literal  rawName)

build a sanitised ID from full type name

Definition at line 296 of file format-obj.cpp.

References humanReadableTypeID(), and util::sanitise().

Referenced by TypeDisplay_test::run(), and lib::idi::typeFullID().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::string sanitisedSymbol ( std::string const &  )

condense a string and retain only valid identifiers

Returns
string starting with letter, followed by letters, digits and underscore

Definition at line 303 of file format-obj.cpp.

Referenced by TypeDisplay_test::run().

+ Here is the caller graph for this function:

bool lib::meta::equals_safeInvoke ( X const &  x1,
X const &  x2 
)
inline

Definition at line 74 of file maybe-compare.hpp.

References Comparator< X >::equals().

+ Here is the call graph for this function:

Unwrap<X>::Type& lib::meta::unwrap ( X const &  wrapped)

convenience shortcut: unwrapping free function.

Returns
reference to the bare element.
Warning
this function is dangerous: it strips away any managing smart-ptr and any const! You might even access and return a reference to an anonymous temporary.

Definition at line 207 of file trait.hpp.

References Unwrap< X >::extract().

Referenced by util::and_all(), util::first(), util::for_each(), util::has_any(), and util::last().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Tuple<TYPES> lib::meta::buildTuple ( SRC  values)

convenience shortcut to build a tuple from some suitable source data.

For this to work, there needs to be a partial specialisation for (ElementExtractor) to deal with the concrete source type given.

Note
we provide such a specialisation for Record<GenNode>, which allows us to fill an (argument) tuple from a sequence of generic data values, with run-time type compatibility check.
See also
tuple-record-init.hpp

Definition at line 324 of file tuple-helper.hpp.

std::string lib::meta::dump ( std::tuple< TYPES...> const &  tuple)
inline

convenience function to dump a given tuple's contents.

Using the BuildTupleAccessor, we layer a stack of Instantiations of the TupleElementDisplayer temporarily on top of the given tuple, just to invoke a recursive call chain through this layers and get a string representation of each element in the tuple.

Definition at line 447 of file tuple-helper.hpp.

Referenced by ParamAccessor< TY, BASE, TUP, idx >::dump(), _Fmt::Converter< VAL * >::dump(), TupleElementDisplayer< TY, BASE, TUP, idx >::dump(), StringConv< std::tuple< TYPES...> >::invoke(), and Index< POA >::Cluster::operator string().

+ Here is the caller graph for this function:

constexpr bool lib::meta::isInList ( )

convenience shortcut: query function

Definition at line 118 of file typelist-util.hpp.

std::string lib::meta::typeStr ( TY const *  obj = nullptr)
inlinenoexcept

failsafe human readable type display

Returns
string representing the C++ type.
Remarks
the purpose of this function is diagnostics and unit-testing. When possible, RTTI is exposed, otherwise the implementation falls back on the static type as seen by the compiler on usage site. An attempt is made to de-mangle and further simplify the type string, leaving out some common (hard wired) namespace prefixes, and stripping typical adornments like const, * and &
almost all calls will enter through the const& variant of this function, since C++ considers this best match in template substitution. Thus, we deliberately force calls with pointer to enter here, since we do want the pointer itself (and not a pointer to the pointer). We then pass the "object" as so called "glvalue" to the typeid() function, so to get the evaluation of RTTI, when applicable.
Warning
this function does string transformations behind the scenes, and thus should not be used in performance critical context. Moreover, the returned type string is not necessarily exact and re-parsable.

Definition at line 248 of file meta/util.hpp.

References humanReadableTypeID().

Referenced by Symbol_test::checkLiteral(), lumiera::error::default_usermsg(), SimpleAllocator< TYPES, COUNTER >::destroy(), TypedAllocationManager::destroyElement(), StringConv< std::tuple< TYPES...> >::invoke(), ElementExtractor< lib::diff::Rec, std::tuple< TYPES...> >::Access< i >::operator TargetType< i >(), primaryTypeComponent(), TypeDisplay_test::run(), FunctionSignature_test::run(), lib::test::showSizeof(), lib::test::showVariadicTypes(), TreeMutator_test::simpleAttributeBinding(), TreeMutator_test::simpleCollectionBinding(), util::typedString(), typeStr(), MetaUtils_test::verify_genericTypeDisplay(), and DigxelConfigurations_test::verifyConfiguration().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

disable_if<std::is_pointer<TY>, std::string > lib::meta::typeStr ( TY const &  ref)
inlinenoexcept

Definition at line 260 of file meta/util.hpp.

References typeStr().

+ Here is the call graph for this function:

std::string lib::meta::typeStr ( void const *  )
inlinenoexcept

Definition at line 266 of file meta/util.hpp.

References VOID_INDICATOR.

Referenced by StringConv< X, COND >::invoke(), util::showPtr(), and util::showSmartPtr().

+ Here is the caller graph for this function:

std::string lib::meta::typeSymbol ( TY const *  obj = nullptr)
inline

simple expressive symbol to designate a type

Returns
single word identifier, derived from the full type name, not necessarily correct or unique

Definition at line 280 of file meta/util.hpp.

References primaryTypeComponent().

Referenced by _Fmt::Converter< SP, lib::meta::enable_if< _shall_show_smartWrapper< SP > > >::dump(), StringConv< SP, show_SmartPointer< SP > >::invoke(), TypeDisplay_test::run(), and typeSymbol().

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

disable_if<std::is_pointer<TY>, std::string > lib::meta::typeSymbol ( TY const &  ref)
inline

Definition at line 290 of file meta/util.hpp.

References typeSymbol().

+ Here is the call graph for this function:

Variable Documentation

const std::string FAILURE_INDICATOR

Definition at line 219 of file meta/util.hpp.

Referenced by CommandImpl::operator string().

const std::string VOID_INDICATOR

Definition at line 221 of file meta/util.hpp.

Referenced by primaryTypeComponent(), and typeStr().

const std::string FUNCTION_INDICATOR

Definition at line 218 of file meta/util.hpp.

const std::string BOOL_FALSE_STR

Definition at line 223 of file meta/util.hpp.

Referenced by util::showBool().

const std::string BOOL_TRUE_STR

Definition at line 224 of file meta/util.hpp.

Referenced by util::showBool().

const size_t CONFIG_FLAGS_MAX

Definition at line 58 of file configflags.hpp.