Lumiera  0.pre.03
»edityourfreedom«
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_unrelatedTypesFunHolder
 
typedef lib::InPlaceAnyHolder< sizeof(void *), lib::InPlaceAnyHolder_unrelatedTypesFunPtrHolder
 
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< FUN, enable_if< has_FunctionOperator< FUN > > >
 Specialisation for function objects and lambdas. 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  BuildIdxIter
 build a sequence of index numbers based on a type sequence More...
 
struct  BuildIdxIter< Types< TYPES... > >
 build an index number sequence from a type sequence More...
 
struct  BuildIndexSeq
 build regular sequences of index number e.g. 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...
 
class  has_FunctionOperator
 Trait template to detect presence of a simple function call operator. 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...
 
class  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...
 
class  InstantiateForEach
 Apply a template to a collection of types. More...
 
class  InstantiateForEach< Node< TY, TYPES >, _X_, BASE >
 
class  InstantiateForEach< NullType, _X_, BASE >
 
class  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_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_Subclass
 verify compliance to an interface by subtype check 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  RebindTySeq
 temporary workaround: match and rebind the type sequence from a tuple More...
 
struct  RebindTySeq< std::tuple< TYPES... > >
 
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 >
 
struct  TypeBinding
 Type re-binding helper template for creating nested typedefs for use by custom containers and iterator adapters or similar. More...
 
struct  TypeBinding< TY & >
 
struct  TypeBinding< TY && >
 
struct  TypeBinding< vector< Scope >::const_reverse_iterator >
 this explicit specialisation allows to build a RangeIter to yield const Scope elements, based on the const_reverse_iterator used internally within ScopePath. More...
 
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<>
 
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...
 
struct  ValueTypeBinding
 
struct  ValueTypeBinding< TY, enable_if< use_ValueTypebindings< TY > > >
 specialisation for classes providing STL style type binding definitions 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...
 
template<typename X >
constexpr X const & max (X const &a, X const &b)
 
template<typename X >
constexpr X const & min (X const &a, X const &b)
 
template<size_t idx, typename... ARGS>
constexpr auto pickArg (ARGS &&... args)
 Helper to single out one argument from a variadic argument pack. More...
 
template<size_t idx, typename DEFAULT , typename... ARGS>
constexpr auto pickInit (ARGS &&... args)
 Helper to pick one initialisation argument from a variadic argument pack, falling back to a default constructed element of type DEFAULT in case of insufficient number of variadic arguments. 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

◆ HasUsableHashDefinition

typedef size_t HasUsableHashDefinition

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

◆ FunVoid

typedef function<void(void)> FunVoid

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

◆ FunHolder

◆ FunPtrHolder

◆ Tuple

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 122 of file tuple-helper.hpp.

◆ ExtractArg

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

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

◆ NodeNull

Definition at line 99 of file typelist.hpp.

◆ enable_if

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.

◆ disable_if

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

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

◆ Yes_t

typedef char Yes_t

helper types to detect the overload resolution chosen by the compiler

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

◆ enable_CustomStringConversion

toggle for explicit specialisations

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


Class Documentation

◆ lib::meta::Append

struct lib::meta::Append
Class Members
typedef Node< TY1, typename
Append< TY2, NullType >::List >
List
+ Collaboration diagram for Append< TY1, TY2 >:

◆ lib::meta::Append< Node< TY, TYPES >, NullType >

struct lib::meta::Append< Node< TY, TYPES >, NullType >
Class Members
typedef Node< TY, TYPES > List
+ Collaboration diagram for Append< Node< TY, TYPES >, NullType >:

◆ lib::meta::Append< Node< TY, TYPES >, TAIL >

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 >:

◆ lib::meta::Append< NullType, Node< TY, TYPES > >

struct lib::meta::Append< NullType, Node< TY, TYPES > >
Class Members
typedef Node< TY, TYPES > List
+ Collaboration diagram for Append< NullType, Node< TY, TYPES > >:

◆ lib::meta::Append< NullType, NullType >

struct lib::meta::Append< NullType, NullType >
Class Members
typedef NullType List
+ Collaboration diagram for Append< NullType, NullType >:

◆ lib::meta::Append< NullType, TY2 >

struct lib::meta::Append< NullType, TY2 >
Class Members
typedef Node< TY2, NullType > List
+ Collaboration diagram for Append< NullType, TY2 >:

◆ lib::meta::Append< TY1, NullType >

struct lib::meta::Append< TY1, NullType >
Class Members
typedef Node< TY1, NullType > List
+ Collaboration diagram for Append< TY1, NullType >:

◆ lib::meta::Apply

struct lib::meta::Apply
Class Members
typedef TY List
+ Collaboration diagram for Apply< TY, _TRANS_ >:

◆ lib::meta::Apply< Node< TY, TYPES >, _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_ >:

◆ lib::meta::BuildConfigFromFlags

struct lib::meta::BuildConfigFromFlags
Class Members
typedef CONF Config
typedef Config Type
+ Inheritance diagram for BuildConfigFromFlags< FLAGS, CONF >:
+ Collaboration diagram for BuildConfigFromFlags< FLAGS, CONF >:

◆ lib::meta::BuildConfigFromFlags< Node< Flag< Fl >, 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 >:

◆ lib::meta::BuildIndexSeq

struct lib::meta::BuildIndexSeq
Class Members
typedef typename BuildIndexSeq
< n-1 >::template AppendElm< n-1 >
Ascending
typedef typename BuildIndexSeq
< n-1 >::template PrependElm
< n-1 >
Descending
typedef typename BuildIndexSeq
< n-1 >::template OffsetBy< d >
::template AppendElm< n-1+d >
OffsetBy
typedef typename BuildIndexSeq
< n-1 >::template FilledWith
< x >::template AppendElm< x >
FilledWith
typedef typename BuildIndexSeq
< min(c, n)>::Ascending
First
typedef typename BuildIndexSeq
<(n >c)? n-c :0 >::template
OffsetBy< c >
After
+ Collaboration diagram for BuildIndexSeq< n >:

◆ lib::meta::BuildIndexSeq< 0 >

struct lib::meta::BuildIndexSeq< 0 >
Class Members
typedef IndexSeq<> Empty
typedef Empty Ascending
typedef Empty Descending
typedef Empty OffsetBy
typedef Empty FilledWith
typedef Empty First
typedef Empty After
+ Collaboration diagram for BuildIndexSeq< 0 >:

◆ lib::meta::BuildTupleAccessor< _X_, Types<>, TUP, i >

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 >:

◆ lib::meta::Combine

struct lib::meta::Combine
Class Members
typedef Distribute< typename
_ENUM_< X >::List, Node
< NullType, NullType > >::List
List
+ Collaboration diagram for Combine< X, _ENUM_ >:

◆ lib::meta::Combine< Node< TY, TYPES >, _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_ >:

◆ lib::meta::Combine< NullType, _ENUM_ >

struct lib::meta::Combine< NullType, _ENUM_ >
Class Members
typedef NodeNull List
+ Collaboration diagram for Combine< NullType, _ENUM_ >:

◆ lib::meta::CombineFlags

struct lib::meta::CombineFlags
Class Members
typedef Combine< FLAGS,
FlagOnOff >::List
List
+ Collaboration diagram for CombineFlags< FLAGS >:

◆ lib::meta::CondNode

struct lib::meta::CondNode
Class Members
typedef TAIL Next
+ Collaboration diagram for CondNode< bool, T, TAIL >:

◆ lib::meta::CondNode< true, T, TAIL >

struct lib::meta::CondNode< true, T, TAIL >
Class Members
typedef Node< T, TAIL > Next
+ Collaboration diagram for CondNode< true, T, TAIL >:

◆ lib::meta::Config

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 >:

◆ lib::meta::ConfigSetFlag

struct lib::meta::ConfigSetFlag
+ Collaboration diagram for ConfigSetFlag< Fl, CONF >:

◆ lib::meta::ConfigSetFlag< Fl, Config< f1, f2, f3, f4, IGN > >

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 > >:

◆ lib::meta::ConstAll

struct lib::meta::ConstAll
+ Collaboration diagram for ConstAll< TYPES >:

◆ lib::meta::ConstAll< Node< TY, 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 > >:

◆ lib::meta::ConstAll< NullType >

struct lib::meta::ConstAll< NullType >
Class Members
typedef NullType List
+ Collaboration diagram for ConstAll< NullType >:

◆ lib::meta::CopySupport

struct lib::meta::CopySupport
Class Members
typedef NoCopyMoveSupport< I,
D, B >
Policy
+ Collaboration diagram for CopySupport< X, SEL >:

◆ lib::meta::CopySupport< X, enable_if< supports_cloning< X > > >

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 > > >:

◆ lib::meta::CopySupport< X, enable_if< supports_copy_and_assignment< 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 > > >:

◆ lib::meta::CopySupport< X, enable_if< supports_only_move< 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 > > >:

◆ lib::meta::count

struct lib::meta::count
+ Collaboration diagram for count< TYPES >:

◆ lib::meta::CountDown

struct lib::meta::CountDown
Class Members
typedef NullType List
+ Collaboration diagram for CountDown< X >:

◆ lib::meta::CountDown< Num< 0 > >

struct lib::meta::CountDown< Num< 0 > >
Class Members
typedef Node< Num< 0 >, NullType > List
+ Collaboration diagram for CountDown< Num< 0 > >:

◆ lib::meta::CountDown< Num< I > >

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 > >:

◆ lib::meta::Dissect

struct lib::meta::Dissect
+ Collaboration diagram for Dissect< TYPES >:

◆ lib::meta::Dissect< Node< T, 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 > >:

◆ lib::meta::Dissect< NullType >

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 >:

◆ lib::meta::Distribute

struct lib::meta::Distribute
Class Members
typedef PrefixAll< TY1, TY2 >::List List
+ Inheritance diagram for Distribute< TY1, TY2 >:
+ Collaboration diagram for Distribute< TY1, TY2 >:

◆ lib::meta::Distribute< Node< TY, TYPES >, TAIL >

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 >:

◆ lib::meta::Distribute< NullType, TY >

struct lib::meta::Distribute< NullType, TY >
Class Members
typedef NullType List
+ Collaboration diagram for Distribute< NullType, TY >:

◆ lib::meta::ElementExtractor

struct lib::meta::ElementExtractor
+ Collaboration diagram for ElementExtractor< SRC, TAR >:

◆ lib::meta::ElementExtractor< lib::diff::Rec, std::tuple< TYPES... > >

struct lib::meta::ElementExtractor< lib::diff::Rec, std::tuple< TYPES... > >
Class Members
TargetType
+ Collaboration diagram for ElementExtractor< lib::diff::Rec, std::tuple< TYPES... > >:

◆ lib::meta::enable_if_c

struct lib::meta::enable_if_c
Class Members
typedef T type
+ Collaboration diagram for enable_if_c< B, T >:

◆ lib::meta::enable_if_c< false, T >

struct lib::meta::enable_if_c< false, T >
+ Collaboration diagram for enable_if_c< false, T >:

◆ lib::meta::Filter

struct lib::meta::Filter
+ Collaboration diagram for Filter< TYPES, _P_ >:

◆ lib::meta::Filter< Node< TY, 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_ >:

◆ lib::meta::Filter< NullType, _P_ >

struct lib::meta::Filter< NullType, _P_ >
Class Members
typedef NullType List
+ Collaboration diagram for Filter< NullType, _P_ >:

◆ lib::meta::Flag

struct lib::meta::Flag
Class Members
typedef Flag ID
+ Collaboration diagram for Flag< bit >:

◆ lib::meta::Flag< 0 >

struct lib::meta::Flag< 0 >
Class Members
typedef NullType ID
+ Collaboration diagram for Flag< 0 >:

◆ lib::meta::FlagInfo

struct lib::meta::FlagInfo
+ Collaboration diagram for FlagInfo< FLAGS >:

◆ lib::meta::FlagOnOff

struct lib::meta::FlagOnOff
Class Members
typedef Node< F, Node
< NullType, NullType > >
List
+ Collaboration diagram for FlagOnOff< F >:

◆ lib::meta::Flags

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 >:

◆ lib::meta::FunctionTypedef

struct lib::meta::FunctionTypedef
+ Collaboration diagram for FunctionTypedef< RET, ARGS >:

◆ lib::meta::FunctionTypedef< RET, Types< A1 > >

struct lib::meta::FunctionTypedef< RET, Types< A1 > >
Class Members
typedef function< RET(A1)> Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types< A1 > >:

◆ lib::meta::FunctionTypedef< RET, Types< A1, A2 > >

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 > >:

◆ lib::meta::FunctionTypedef< RET, Types< A1, A2, A3 > >

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 > >:

◆ lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4 > >

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 > >:

◆ lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5 > >

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 > >:

◆ lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6 > >

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 > >:

◆ lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7 > >

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 > >:

◆ lib::meta::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 > >
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 > >:

◆ lib::meta::FunctionTypedef< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8, A9 > >

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 > >:

◆ lib::meta::FunctionTypedef< RET, Types<> >

struct lib::meta::FunctionTypedef< RET, Types<> >
Class Members
typedef function< RET(void)> Func
typedef RET Sig
+ Collaboration diagram for FunctionTypedef< RET, Types<> >:

◆ lib::meta::IndexSeq

struct lib::meta::IndexSeq
Class Members
AppendElm
PrependElm
+ Collaboration diagram for IndexSeq< idx >:

◆ lib::meta::InstantiateWithIndex

class lib::meta::InstantiateWithIndex
+ Collaboration diagram for InstantiateWithIndex< TYPES, _X_, BASE, i >:

◆ lib::meta::maxSize

struct lib::meta::maxSize
+ Collaboration diagram for maxSize< TYPES >:

◆ lib::meta::No_t

struct lib::meta::No_t
Class Members
char more_than_one[4]
+ Collaboration diagram for No_t:

◆ lib::meta::Node

struct lib::meta::Node
Class Members
typedef Node List
typedef H Head
typedef T Tail
+ Collaboration diagram for Node< H, T >:

◆ lib::meta::NoUsableHashDefinition

struct lib::meta::NoUsableHashDefinition
Class Members
size_t more_than_one[2]
+ Collaboration diagram for NoUsableHashDefinition:

◆ lib::meta::NullType

struct lib::meta::NullType
Class Members
typedef NullType List
+ Collaboration diagram for NullType:

◆ lib::meta::Pick

struct lib::meta::Pick
Class Members
typedef NullType Type
+ Collaboration diagram for Pick< TYPES, i >:

◆ lib::meta::Pick< Node< TY, TYPES >, 0 >

struct lib::meta::Pick< Node< TY, TYPES >, 0 >
Class Members
typedef TY Type
+ Collaboration diagram for Pick< Node< TY, TYPES >, 0 >:

◆ lib::meta::Pick< Node< TY, TYPES >, i >

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 >:

◆ lib::meta::Pick< Types< TYPES... >, i >

struct lib::meta::Pick< Types< TYPES... >, i >
Class Members
Type
+ Collaboration diagram for Pick< Types< TYPES... >, i >:

◆ lib::meta::PickParametersFromSublist

struct lib::meta::PickParametersFromSublist
+ Collaboration diagram for PickParametersFromSublist< _X_ >:

◆ lib::meta::PrefixAll

struct lib::meta::PrefixAll
Class Members
typedef Node< typename Append
< T, TY >::List, NullType >
List
+ Collaboration diagram for PrefixAll< T, TY >:

◆ lib::meta::PrefixAll< T, Node< TY, TYPES > >

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 > >:

◆ lib::meta::PrefixAll< T, NodeNull >

struct lib::meta::PrefixAll< T, NodeNull >
Class Members
typedef Node< typename Append
< T, NodeNull >::List,
NullType >
List
+ Collaboration diagram for PrefixAll< T, NodeNull >:

◆ lib::meta::PrefixAll< T, NullType >

struct lib::meta::PrefixAll< T, NullType >
Class Members
typedef NullType List
+ Collaboration diagram for PrefixAll< T, NullType >:

◆ lib::meta::Prepend

struct lib::meta::Prepend
+ Collaboration diagram for Prepend< T, TYPES >:

◆ lib::meta::Prepend< T, TySeq< TYPES... > >

struct lib::meta::Prepend< T, TySeq< TYPES... > >
Class Members
Seq
List
+ Collaboration diagram for Prepend< T, TySeq< TYPES... > >:

◆ 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 > >

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 > >:

◆ lib::meta::RebindTySeq

struct lib::meta::RebindTySeq
Class Members
Seq
typedef typename List List
+ Collaboration diagram for RebindTySeq< TYPES >:

◆ lib::meta::RebindTySeq< std::tuple< TYPES... > >

struct lib::meta::RebindTySeq< std::tuple< TYPES... > >
Class Members
Seq
typedef typename List List
+ Collaboration diagram for RebindTySeq< std::tuple< TYPES... > >:

◆ lib::meta::RefTraits

struct lib::meta::RefTraits
Class Members
typedef TY * pointer
typedef TY & reference
typedef TY value_type
+ Collaboration diagram for RefTraits< TY >:

◆ lib::meta::RefTraits< TY & >

struct lib::meta::RefTraits< TY & >
Class Members
typedef TY * pointer
typedef TY & reference
typedef TY value_type
+ Collaboration diagram for RefTraits< TY & >:

◆ lib::meta::RefTraits< TY * >

struct lib::meta::RefTraits< TY * >
Class Members
typedef TY * pointer
typedef TY & reference
typedef TY value_type
+ Collaboration diagram for RefTraits< TY * >:

◆ lib::meta::Shifted< TYPES, 0 >

struct lib::meta::Shifted< TYPES, 0 >
Class Members
typedef TYPES Type
typedef Split< Type >::Head Head
+ Collaboration diagram for Shifted< TYPES, 0 >:

◆ lib::meta::Splice

struct lib::meta::Splice
+ Collaboration diagram for Splice< BASE, OVERLAY, i >:

◆ lib::meta::Splice< Node< B, BS >, Node< O, OS >, 0 >

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 >:

◆ lib::meta::Splice< Node< B, BS >, NullType, 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 >:

◆ lib::meta::Splice< Node< B, BS >, OVERLAY, i >

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 >:

◆ lib::meta::Splice< NullType, XX, 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 >:

◆ lib::meta::Split

struct lib::meta::Split
+ Collaboration diagram for Split< TYPES >:

◆ lib::meta::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::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 > >:

◆ lib::meta::SplitLast

struct lib::meta::SplitLast
+ Collaboration diagram for SplitLast< TYPES >:

◆ lib::meta::SplitLast< Node< TY, NullType > >

struct lib::meta::SplitLast< Node< TY, NullType > >
Class Members
typedef TY Type
typedef NullType List
+ Collaboration diagram for SplitLast< Node< TY, NullType > >:

◆ lib::meta::SplitLast< Node< TY, TYPES > >

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 > >:

◆ lib::meta::SplitLast< NullType >

struct lib::meta::SplitLast< NullType >
Class Members
typedef NullType Type
typedef NullType List
+ Collaboration diagram for SplitLast< NullType >:

◆ lib::meta::Strip

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 >:

◆ lib::meta::StripNullType

struct lib::meta::StripNullType
+ Collaboration diagram for StripNullType< SEQ >:

◆ lib::meta::StripNullType< Types< NullType, TYPES... > >

struct lib::meta::StripNullType< Types< NullType, TYPES... > >
Class Members
typedef TySeq<> Seq
+ Collaboration diagram for StripNullType< Types< NullType, TYPES... > >:

◆ lib::meta::StripNullType< Types< T, 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... > >:

◆ lib::meta::TypeBinding< vector< Scope >::const_reverse_iterator >

struct lib::meta::TypeBinding< vector< Scope >::const_reverse_iterator >
Class Members
typedef const Scope value_type
typedef Scope const & reference
typedef const Scope * pointer
+ Collaboration diagram for TypeBinding< vector< Scope >::const_reverse_iterator >:

◆ lib::meta::Types< Node< H, T > >

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 > >:

◆ lib::meta::Types<>

struct lib::meta::Types<>
Class Members
typedef NullType List
typedef Types<> Seq
+ Collaboration diagram for Types<>:

◆ lib::meta::TySeq

struct lib::meta::TySeq
Class Members
typedef TySeq Seq
List
+ Collaboration diagram for TySeq< TYPES >:

◆ lib::meta::UnConst

struct lib::meta::UnConst
Class Members
typedef T Type
+ Collaboration diagram for UnConst< T >:

◆ lib::meta::UnConst< const T * >

struct lib::meta::UnConst< const T * >
Class Members
typedef T * Type
+ Collaboration diagram for UnConst< const T * >:

◆ lib::meta::UnConst< const T *const >

struct lib::meta::UnConst< const T *const >
Class Members
typedef T * Type
+ Collaboration diagram for UnConst< const T *const >:

◆ lib::meta::UnConst< const T >

struct lib::meta::UnConst< const T >
Class Members
typedef T Type
+ Collaboration diagram for UnConst< const T >:

◆ lib::meta::UnConst< T *const >

struct lib::meta::UnConst< T *const >
Class Members
typedef T * Type
+ Collaboration diagram for UnConst< T *const >:

◆ lib::meta::Unwrap< void >

struct lib::meta::Unwrap< void >
Class Members
typedef void Type
+ Collaboration diagram for Unwrap< void >:

◆ lib::meta::ValueTypeBinding

struct lib::meta::ValueTypeBinding
Class Members
typedef TY value_type
typedef TY & reference
typedef TY * pointer
+ Inheritance diagram for ValueTypeBinding< TY, SEL >:
+ Collaboration diagram for ValueTypeBinding< TY, SEL >:

◆ lib::meta::ValueTypeBinding< TY, enable_if< use_ValueTypebindings< TY > > >

struct lib::meta::ValueTypeBinding< TY, enable_if< use_ValueTypebindings< TY > > >
Class Members
typedef value_type value_type
typedef reference reference
typedef pointer pointer
+ Collaboration diagram for ValueTypeBinding< TY, enable_if< use_ValueTypebindings< TY > > >:

Function Documentation

◆ demangleCxx()

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 157 of file format-obj.cpp.

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

+ Here is the caller graph for this function:

◆ humanReadableTypeID()

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 188 of file format-obj.cpp.

References demangleCxx(), and TYP_EXP.

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ primaryTypeComponent()

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 259 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:

◆ sanitisedFullTypeName()

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

build a sanitised ID from full type name

Definition at line 297 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:

◆ sanitisedSymbol()

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 304 of file format-obj.cpp.

Referenced by TypeDisplay_test::run().

+ Here is the caller graph for this function:

◆ equals_safeInvoke()

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()

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 210 of file trait.hpp.

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

+ Here is the caller graph for this function:

◆ buildTuple()

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 233 of file tuple-helper.hpp.

◆ dump()

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 356 of file tuple-helper.hpp.

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

+ Here is the caller graph for this function:

◆ isInList()

constexpr bool lib::meta::isInList ( )

convenience shortcut: query function

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

◆ typeStr() [1/3]

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 scene, 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 272 of file meta/util.hpp.

References FAILURE_INDICATOR, and humanReadableTypeID().

Referenced by VariadicArgumentPicker_test::check_pickInit(), Symbol_test::checkLiteral(), SimpleAllocator< TYPES, COUNTER >::destroy(), TypedAllocationManager::destroyElement(), _Fmt::format(), ClassLock< X, CONF >::getPerClassMonitor(), StringConv< std::tuple< TYPES... > >::invoke(), lumiera::error::lumiera_unexpectedException(), 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(), typeSymbol(), IterTreeExplorer_test::verify_combinedExpandTransform(), MetaUtils_test::verify_genericTypeDisplay(), and DigxelConfigurations_test::verifyConfiguration().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ typeStr() [2/3]

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

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

References typeStr().

+ Here is the call graph for this function:

◆ typeStr() [3/3]

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

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

References VOID_INDICATOR.

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

+ Here is the caller graph for this function:

◆ typeSymbol() [1/2]

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 304 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(), and TypeDisplay_test::run().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ typeSymbol() [2/2]

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

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

References BOTTOM_INDICATOR, FAILURE_INDICATOR, and typeStr().

+ Here is the call graph for this function:

◆ max()

◆ min()

constexpr X const& lib::meta::min ( X const &  a,
X const &  b 
)
inline

Definition at line 136 of file variadic-helper.hpp.

Referenced by audio_init(), TimeBasics_test::checkBasics(), TimeValue_test::checkBasicTimeValues(), TimeBasics_test::checkComparisons(), proc::mobject::session::commonPrefix(), UICoord::getComp(), gui::draw::rects_overlap(), TimelineViewWindow::set_time_scale(), TEST(), and TimeControl_test::verifyBasics().

+ Here is the caller graph for this function:

◆ pickArg()

constexpr auto lib::meta::pickArg ( ARGS &&...  args)
inline

Helper to single out one argument from a variadic argument pack.

Template Parameters
idxthe index number (zero based) of the argument to select
Remarks
typically this function is used "driven" by an likewise variadic index sequence, where the index sequence itself is picked up by a pattern match; this usage pattern allows arbitrarily to handle some of the arguments of a variable argument list, as determined by the index sequence passed in.

Definition at line 321 of file variadic-helper.hpp.

Referenced by Extension::resizeTo().

+ Here is the caller graph for this function:

◆ pickInit()

constexpr auto lib::meta::pickInit ( ARGS &&...  args)
inline

Helper to pick one initialisation argument from a variadic argument pack, falling back to a default constructed element of type DEFAULT in case of insufficient number of variadic arguments.

Template Parameters
idxthe index number (zero based) of the argument to select
DEFALUTtype of the default element to construct as fallback

Definition at line 337 of file variadic-helper.hpp.

Referenced by Extension::resizeTo().

+ Here is the caller graph for this function:

Variable Documentation

◆ BOTTOM_INDICATOR

◆ FAILURE_INDICATOR

◆ VOID_INDICATOR

const std::string VOID_INDICATOR

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

Referenced by primaryTypeComponent(), and typeStr().

◆ FUNCTION_INDICATOR

const std::string FUNCTION_INDICATOR

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

◆ BOOL_FALSE_STR

const std::string BOOL_FALSE_STR

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

Referenced by util::showBool().

◆ BOOL_TRUE_STR

const std::string BOOL_TRUE_STR

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

Referenced by util::showBool().

◆ hash_value

◆ CONFIG_FLAGS_MAX

const size_t CONFIG_FLAGS_MAX

Definition at line 58 of file configflags.hpp.