 |
Lumiera
0.pre.03
»edit your freedom«
|
|
Lumiera
0.pre.03
»edit your freedom«
|
| ►Nboost | |
| Creference_wrapper | |
| ►NBuildhelper | |
| CRecord | |
| ►Nlib | Implementation namespace for support and library code |
| ►Nallo | |
| CAllocationPolicy | Policy Mix-In used to adapt to the ElementFactory and Allocator |
| CElementFactory | Generic factory to manage objects within an ArrayBucket storage, delegating to a custom allocator ALO for memory handling |
| Cis_Stateless | Metafunction: probe if the given base factory is possibly monostate |
| ►COwnUniqueAdapter | Adapter to use a generic factory FAC for creating managed object instances with unique ownership |
| CStatefulDeleter | < |
| ►CSetupSeveral | Extension point: how to configure the SeveralBuilder to use an allocator ALO, initialised by ARGS |
| CPolicy | |
| CSetupSeveral< ALO > | Specialisation: use a monostate allocator type ALO |
| ►CSetupSeveral< ALO, ALO< X > > | Specialisation: store a C++ standard allocator instance, which can be used to allocate objects of type X |
| CPolicy | |
| CSetupSeveral< std::void_t, lib::AllocationCluster & > | Specialisation to use lib::Several with storage managed by an AllocationCluster instance, which must be provided as argument |
| CStdFactory | < Concepts and Adaptors for custom memory management |
| ►Nanonymous_namespace{allocation-cluster.cpp} | |
| CPolicyInvokeDtor | Special allocator-policy for lib::LinkedElements |
| ►Nanonymous_namespace{iter-explorer.hpp} | |
| C_BaseDetector | Detect or otherwise add BaseAdapter |
| C_BaseDetector< SRC, std::void_t< typename SRC::TAG_IterExplorer_BaseAdapter > > | |
| C_DecoratorTraits | |
| C_DecoratorTraits< ISO &, enable_if< is_base_of< IterSource< typename ISO::value_type >, ISO > > > | |
| C_DecoratorTraits< ISO *&, enable_if< is_base_of< IterSource< typename ISO::value_type >, ISO > > > | |
| C_DecoratorTraits< ISO *, enable_if< is_base_of< IterSource< typename ISO::value_type >, ISO > > > | |
| C_DecoratorTraits< SRC, enable_if< is_StateCore< SRC > > > | |
| C_DecoratorTraits< SRC, enable_if< shall_use_Lumiera_Iter< SRC > > > | |
| C_DecoratorTraits< SRC, enable_if< shall_wrap_STL_Iter< SRC > > > | |
| C_ExpanderTraits | Helper to derive a suitable common type when expanding children |
| C_PipelineDetector | Detect if given source was already built by IterExplorer; |
| C_PipelineDetector< SRC, std::void_t< typename SRC::TAG_IterExplorer_Src > > | |
| C_UnstripAdapter | Detect and remove typical adapter layers added by a preceding IterExplorer usage |
| C_UnstripAdapter< COR, std::void_t< typename COR::TAG_CheckedCore_Raw > > | |
| Cshall_use_Lumiera_Iter | |
| Cshall_wrap_STL_Iter | |
| ►Nanonymous_namespace{random.cpp} | |
| CEntropyNucleus | |
| CEternalNucleus | |
| ►Ncon | |
| CExtension | Heap-allocated extension storage for an immutable sequence of literal strings |
| ►Ndiff | |
| ►Nanonymous_namespace{mutation-message.hpp} | |
| CDiffSnapshot | "materialised view" of the diff sequence |
| CMaterialisedDiffBuffer | Decorator to be layered transparently on top of MutationMessage |
| ►Nanonymous_namespace{test-mutation-target.hpp} | |
| CTestWireTap | |
| ►Nanonymous_namespace{tree-mutator-attribute-binding.hpp} | |
| CAttributeBindingBase | Generic behaviour of any binding to object fields (attributes) |
| CChangeOperation | |
| CMutationOperation | |
| ►Nanonymous_namespace{tree-mutator-collection-binding.hpp} | |
| C_DefaultBinding | Starting point for configuration of a binding to STL container |
| C_DefaultBinding< ELM, enable_if< can_wrap_in_GenNode< ELM > > > | |
| C_DefaultBinding< GenNode > | Standard configuration to deal with GenNode collections |
| C_EmptyBinding | |
| CChildCollectionMutator | Attach to collection: Building block for a concrete TreeMutator |
| CCollectionBinding | Attach to collection: Concrete binding setup |
| CCollectionBindingBuilder | Nested DSL to define the specifics of a collection binding |
| CContainerTraits | Helper for uniform treatment of various STL containers |
| CContainerTraits< M, IF_is_map< M > > | |
| CContainerTraits< V, IF_is_vector< V > > | |
| ►Nanonymous_namespace{tree-mutator-diffmutable-binding.hpp} | |
| C_AccessID | Metaprogramming helper to retrieve the object identity, whenever the target object for the diff defines a getID() function |
| C_AccessID< ELM, enable_if< Can_access_ID< ELM > > > | |
| C_DefaultBinding< ELM, enable_if< can_recursively_bind_DiffMutable< ELM > > > | Entry Point: Specialisation of the collection binding to work on a collection of DiffMutable objects, either embedded directly, or attached via smart-ptr |
| CCan_access_ID | |
| Ccan_recursively_bind_DiffMutable | |
| ►CCan_retrieve_and_compare_ID | Metaprogramming helper to detect if the given target class allows us to build a default »Matcher« automatically |
| CProbe | |
| CIs_DiffMutable | < Metafunction: does the target implement the DiffMutable interface? |
| CIs_wrapped_DiffMutable | < Metafunction: is this a DiffMutable wrapped into a smart-ptr? |
| ►Nanonymous_namespace{tree-mutator-gen-node-binding.hpp} | |
| CObjectTypeHandler | Helper to deal with the magic "object type" attribute |
| ►Nanonymous_namespace{tree-mutator-listener-binding.hpp} | |
| CDetector4StructuralChanges | Decorator for TreeMutator bindings, to fire a listener function when the applied diff describes a relevant change |
| ►Nanonymous_namespace{tree-mutator-noop-binding.hpp} | |
| CBlackHoleMutation | Diff binding for black holes, happily accepting anything |
| ►Nanonymous_namespace{tree-mutator.hpp} | |
| CBuilder | Builder-DSL to create and configure a concrete TreeMutator |
| ►Ntest | |
| ►Nanonymous_namespace{diff-complex-application-test.cpp} | |
| COpaque | Opaque private data structure to apply the diff |
| CDiffComplexApplication_test | |
| CDiffIgnoreChanges_test | |
| CDiffIndexTable_test | |
| CDiffListApplication_test | |
| CDiffListGeneration_test | |
| CDiffTreeApplication_test | |
| CDiffTreeApplicationSimple_test | |
| CDiffTreeMutationListener_test | |
| CGenericRecord_test | |
| CGenNode_test | |
| CMutationMessage_test | |
| CTreeMutator_test | |
| CTreeMutatorBinding_test | |
| Ccan_wrap_in_GenNode | Metafunction to detect types able to be wrapped into a GenNode |
| ►CDataCap | |
| CLocator | |
| Cdefines_custom_BufferSize | |
| CDiffApplicationStrategy | Extension point: define how a specific diff language can be applied to elements in a concrete container |
| CDiffApplicationStrategy< TAR, enable_if< TreeDiffTraits< TAR > > > | Interpreter for the tree-diff-language to work on arbitrary opaque target data structures |
| CDiffApplicationStrategy< vector< E, ARGS... > > | Concrete strategy to apply a list diff to a target sequence given as vector |
| CDiffApplicator | Generic builder to apply a diff description to a given target data structure |
| ►CDiffDetector | Detect and describe changes in a monitored data sequence |
| CDiffFrame | A diff generation process is built on top of an "old" reference point and a "new" state of the underlying sequence |
| ►CDiffLanguage | Definition frame for a language to describe differences in data structures |
| CDiffStep | |
| CDiffMutable | Marker or capability interface: an otherwise not further disclosed data structure, which can be transformed through "tree diff messages" |
| CDiffStepBuilder | Generator to produce specific language tokens |
| Cexposes_MutatorBuilder | Helper to detect presence of a TreeMutator builder function |
| ►CGenNode | Generic data element node within a tree |
| CID | |
| CIDComparator | Allow for storage in ordered containers, ordering based on the human-readable ID within the GenNode |
| CScopeExplorer | Building block for monad-like depth-first expansion of a GenNode |
| CScopeExplorerIterator | |
| CIndexTable | Data snapshot and lookup table |
| CInterpreterScheme | < base case is to expect typedef I::Val |
| CInterpreterScheme< HandlerFun< I, E > > | < alternatively derive value and interpreter from a Handler binding |
| CInterpreterScheme< IP< E > > | < alternatively, the interpreter value type can be templated |
| CListDiffInterpreter | Interpreter interface to define the operations ("verbs"), which describe differences or changes in a given list of data elements |
| CListDiffLanguage | |
| CMutationMessage | Opaque message to effect a structural change on a target, which is likewise only known in an abstract way, as being specifically structured |
| ►CRecord | Object-like record of data |
| CMutator | |
| CRecordRef | Wrapped record reference |
| CRecordSetup | |
| CRecordSetup< GenNode > | Define actual data storage and access types used |
| CRecordSetup< string > | Type configuration (extension point) |
| CRef | Constructor for a specially crafted 'ref GenNode' |
| CScopeManager | Management interface to deal with storage for TreeMutators dedicated to nested scopes |
| CStackScopeManager | Typical standard implementation of the ScopeManager |
| CTestMutationTarget | Test adapter to watch and verify how the TreeMutator binds to custom tree data structures |
| CTreeDiffInterpreter | Interpreter interface to define the operations ("verbs"), which describe differences or changes in hierarchical data structure |
| CTreeDiffLanguage | |
| CTreeDiffMutatorBinding | Implementation of the tree-diff-language to work on arbitrary tree-like data |
| CTreeDiffTraits | |
| ►CTreeDiffTraits< TAR, enable_if< exposes_MutatorBuilder< TAR > > > | |
| CWrapper | |
| CTreeDiffTraits< TAR, enable_if< is_base_of< DiffMutable, TAR > > > | |
| CTreeMutator | Customisable intermediary to abstract mutating operations on arbitrary, hierarchical object-like data |
| CTreeMutatorSizeTraits | Heuristics to guide the allocation for nested TreeMutator |
| CTreeMutatorSizeTraits< TAR, enable_if< defines_custom_BufferSize< TAR > > > | |
| ►Ndot_gen | |
| CCode | Markup to generate a piece of code |
| CDotOut | Helper to collect DOT-Graphviz code for output |
| CNode | Generate a Node name or a node_statement defining attributes of that node |
| CScope | Accumulator to collect nodes grouped into a scope |
| CSection | Accumulator to collect lines of DOT code |
| ►Nfactory | |
| ►CBuild | Policy: use a custom functor to finish the generated product |
| CWrapper | |
| CBuildRefcountPtr | Wrapper taking ownership, by wrapping into smart-ptr |
| CFab | Table of registered production functions for MultiFact |
| CFabConfig | |
| CFabConfig< RET(ARGS...), Wrapper > | |
| ►CMultiFact | Factory for creating a family of objects by ID |
| CSingleton | Convenience shortcut for automatically setting up a production line, to fabricate a singleton instance of the given implementation target type (IMP) |
| CPassAsIs | Dummy "wrapper", to perform the fabrication and return the unaltered product |
| ►Ngnuplot_gen | |
| ►Nhash | Hash implementations usable for the HashIndexed mixin as well as key within std::unordered_map |
| CLuidH | Hash implementation based on a lumiera unique object id (LUID) When invoking the default ctor, a new LUID is generated |
| CPlain | Simple Hash implementation directly incorporating the hash value |
| ►Nidi | Identification Schemes |
| ►Ntest | |
| ►Nanonymous_namespace{entry-id-test.cpp} | |
| CDummy | |
| ►Nanonymous_namespace{generic-id-function-test.cpp} | |
| CSome | |
| CThing | |
| CEntryID_test | |
| CGenericIdFunction_test | |
| CTypedID_test | |
| ►CBareEntryID | Type erased baseclass for building a combined hash and symbolic ID |
| CUseEmbeddedHash | Using BareEntryID derived objects as keys within std::unordered_map |
| CEntryID | Typed symbolic and hash ID for asset-like position accounting |
| CRandID | Entry-ID with a symbolic tag but just a plain random hash part |
| ►Niter | |
| ►Nanonymous_namespace{iter-chain-search.hpp} | |
| C_IterChainSetup | |
| ►Ntest | |
| CIterChainSearch_test | |
| CCursorGear | |
| CIndexAccessCore | Implementation of a »IterStateCore« to access the container through an embedded index variable |
| CIterChainSearch | Iterator based linear search mechanism, with the ability to perform consecutive search with backtracking |
| CIterDequeStorage | Wrapper to mark a std::deque instance for use as "state core" within lib::IterStateWrapper |
| CProductCore | Building block for a tupeled-iterator |
| ►Niter_explorer | |
| ►C_FunTraits | |
| CArgAdapter | Adapt to a functor, which accesses the source iterator or embedded "state core" |
| CArgAdapter< IT, enable_if< __and_< is_base_of< IterSource< typename IT::value_type >, typename IT::Source >, is_base_of< IterSource< typename IT::value_type >, remove_reference_t< Arg > > > > > | Adapt to a functor collaborating with an IterSource based iterator pipeline |
| CArgAdapter< IT, enable_if< __and_< is_convertible< iter::Yield< IT >, Arg >, __not_< is_convertible< IT, Arg > > > > > | Adapt to a functor, which accepts the value type of the source sequence ("monadic" usage pattern) |
| CFunDetector | Handle all regular "function-like" entities |
| CFunDetector< F, disable_if< _Fun< F > > > | Handle a generic lambda, accepting a reference to the SRC iterator |
| C_ReduceTraits | |
| CAutoExpander | |
| CBaseAdapter | |
| CChildExpandableSource | Interface to indicate and expose the ability for child expansion |
| CExpander | |
| CFilter | |
| CGroupAggregator | |
| ►CGrouping | |
| CBuffer | |
| CIterSourceIter | Adapt an IterSource to make it iterable |
| CMutableFilter | |
| CPackagedIterExplorerSource | |
| CScheduledExpander | |
| CStlRange | Adapt STL compliant container |
| CStlRange< CON & > | |
| CStlRange< const CON > | |
| CStopTrigger | |
| CTransformer | |
| ►Niter_source | |
| ►Nanonymous_namespace{iter-source.hpp} | |
| C_IterT | |
| C_MapT | |
| C_PairIterT | |
| C_RangeT | |
| C_SeqT | |
| C_TransformIterT | |
| ►Niter_stl | |
| ►Nanonymous_namespace{iter-adapter-stl.hpp} | |
| C_MapIterT | |
| C_MapSubSelector | Helper to access the parts of the pair values correctly.. |
| C_MapSubSelector< IT, SEL const & > | Especially for const iterators we need to use const& and const* |
| C_MapT | |
| C_MapTypeSelector | |
| C_MapTypeSelector< const MAP > | |
| C_SeqT | |
| C_SeqT< const SEQ > | |
| CDistinctIter | Helper to filter repeated values from a wrapped iterator (both STL or Lumiera) |
| CIterSnapshot | Materialised iterator contents |
| CWrapped_Identity | Wrapped-Iter-Policy: forwarding directly with typing retained unaltered |
| CWrapped_PickConstVal | |
| CWrapped_PickKey | Wrapped-Iter-Policy: picking the key part of a pair iterator (map or multimap) |
| CWrapped_PickVal | Wrapped-Iter-Policy: picking the value part of a pair iterator (map or multimap) |
| CWrappedStlIter | Helper baseclass to simplify defining customised wrapped STL iterators |
| ►Nlinked_elements | |
| CNoOwnership | Policy for LinkedElements: never create or destroy any elements, only allow to add already existing nodes |
| COwningAllocated | < allocation policies for the LinkedElements list container |
| ►Nmeta | |
| ►Nanonymous_namespace{configflags.hpp} | |
| CmaxC | Helper comparing enum values and flags |
| ►Nanonymous_namespace{function.hpp} | |
| C_DetectSingleArgFunction | |
| ►Nanonymous_namespace{tuple-helper.hpp} | |
| CBuildTupleType | |
| CBuildTupleType< Node< H, TAIL > > | |
| CBuildTupleType< NullType > | |
| CBuildTupleType< Types< TYPES... > > | Temporary workaround: strip trailing NullType entries prior to rebinding to the std::tuple type |
| CBuildTupleType< TySeq< TYPES... > > | |
| ►Nanonymous_namespace{tuple-record-init.hpp} | |
| ►CGenNodeAccessor | |
| Callow_Conversion | |
| CConverter | |
| CConverterBase | |
| ►Nanonymous_namespace{util.hpp} | |
| C_DetectNested_TypeResult | |
| C_ExtractFirst | |
| C_ExtractFirst< X, XS... > | |
| ►Nanonymous_namespace{value-type-binding.hpp} | |
| ►Chas_nested_ValueTypeBindings | |
| CProbe | |
| Cuse_ValueTypebindings | |
| ►Nanonymous_namespace{variadic-helper.hpp} | |
| CSelectOrInit | |
| CSelectOrInit< false, DEFAULT, idx > | |
| CSelectVararg | |
| CSelectVararg< 0 > | |
| ►Nanonymous_namespace{virtual -copy-support.hpp} | |
| Csupports_cloning | |
| Csupports_copy_and_assignment | |
| Csupports_only_move | |
| ►Nfunc | |
| ►Nanonymous_namespace{function-closure.hpp} | |
| C_Chain | |
| C_Clo | |
| C_PapE | |
| C_PapS | |
| C_Sig | |
| CApply | This Helper with repetitive specialisations for up to nine arguments is used either to apply a function to arguments given as a tuple, or to create the actual closure (functor) over all function arguments |
| CApply< 0 > | < Apply function without Arguments |
| CApply< 1 > | < Apply function with 1 Argument |
| CApply< 2 > | < Apply function with 2 Arguments |
| CApply< 3 > | < Apply function with 3 Arguments |
| CApply< 4 > | < Apply function with 4 Arguments |
| CApply< 5 > | < Apply function with 5 Arguments |
| CApply< 6 > | < Apply function with 6 Arguments |
| CApply< 7 > | < Apply function with 7 Arguments |
| CApply< 8 > | < Apply function with 8 Arguments |
| CApply< 9 > | < Apply function with 9 Arguments |
| ►CPartiallyInitTuple | Builder for a tuple instance, where only some ctor parameters are supplied, while the remaining arguments will be default constructed |
| CIndexMapper | |
| CIndexMapper< idx, false > | |
| CPlaceholderTuple | Build a list of standard function argument placeholder types |
| CPlaceholderTuple< Node< X, TAIL >, i > | |
| CPlaceholderTuple< NullType, i > | |
| CBindToArgument | Bind a specific argument to an arbitrary value |
| CFunctionClosure | Closing a function over its arguments |
| CPApply | Partial function application Takes a function and a value tuple, using the latter to close function arguments either from the front (left) or aligned to the end of the function argument list |
| CTupleApplicator | Closure-creating template |
| ►Ntest | |
| ►Nanonymous_namespace{config-flags-test.cpp} | |
| CIndeed | |
| CMaybe | Type which is only partially defined, for some configs |
| CMaybe< Conf1 > | |
| CMaybe< Conf3 > | |
| CMaybe< Config< TWO, Fl > > | |
| ►Nanonymous_namespace{duck-detector-extension-test.cpp} | |
| CCheesy | |
| CFishy | |
| ►Nanonymous_namespace{duck-detector-test.cpp} | |
| CPropaganda | |
| CPropperGander | |
| ►Nanonymous_namespace{function-signature-test.cpp} | |
| CFunctor | |
| ►Nanonymous_namespace{generator-combinations-test.cpp} | |
| CTestCase | A Test-Template to be instantiated for all possible combinations of the {Types1} x {Types2} |
| CTestCase< void, void, NullType > | |
| ►Nanonymous_namespace{iterable-classification-test.cpp} | |
| CTestSource | |
| ►Nanonymous_namespace{type-display-test.cpp} | |
| ►COuter | |
| CInner | |
| CSpace | |
| ►Nanonymous_namespace{typelist-diagnostics.hpp} | |
| CNullP | |
| CPrinter | Debugging template, printing the "number" used for instantiation on ctor call |
| CPrinter< Config< f1, f2, f3, f4, f5 >, BASE > | |
| CPrinter< Flag< Fl >, BASE > | < display the presence of a Flag in the typelist |
| CPrinter< int, BASE > | < display the presence of a plain int in the typelist |
| CPrinter< Node< TY, TYPES >, BASE > | Specialisation for debug-printing of a nested sublist |
| CPrinter< NullType, BASE > | |
| CPrinter< Num< I >, BASE > | < display the presence of a Num instance in the typelist |
| ►Nanonymous_namespace{value-type-binding-test.cpp} | |
| ►COuter | |
| CInner | |
| CSpace | |
| ►Nanonymous_namespace{variadic-argument-picker-test.cpp} | |
| CN | |
| ►Nanonymous_namespace{virtual -copy-support-test.cpp} | |
| CCopyInterface | Interface for the Virtual copy operations |
| CInterface | The official Interface for our test class hierarchy |
| CNoncopyable | |
| COnlyMovable | |
| COpaque | |
| CRegular | |
| CSub | Implementation class with "special" memory layout |
| CUnAssignable | |
| CBaseImpl | |
| CBlock | Template for generating lots of different test types |
| CBuildEmptyFunctor | |
| CBuildEmptyFunctor< Efun > | |
| CChain | |
| CChain< Node< H, T >, P > | |
| ►CConfigFlags_test | |
| CTestFactory | |
| CTestVisitor | |
| CDoIt | Use this building block for chaining corresponding implementation classes |
| CDuckDetector_test | |
| CDuckDetectorExtension_test | |
| CFunctionClosure_test | |
| CFunctionComposition_test | |
| CFunctionErasure_test | |
| CFunctionSignature_test | |
| CGeneratorCombinations_test | |
| CIterableClassification_test | |
| CLateBindInstance_test | |
| ►CMetaUtils_test | |
| CSomehowStringy | |
| CSomehowSubSub | |
| CSomehowSubtle | |
| CSomething | |
| CSubString | |
| ►COuter | |
| CInner | |
| CSpace | |
| CTakeIt | Use this building block for assembling an abstract interface |
| CTupleHelper_test | |
| CTupleRecordInit_test | |
| CTypeDemangling_test | |
| CTypeDisplay_test | |
| CTypeList_test | |
| CTypeListGenerator_test | |
| ►CTypeListManip_test | |
| CAddConst2 | |
| CAddConst2< Num< I > > | |
| CIsEven | |
| CIsEven< Num< I > > | |
| CTypeListUtil_test | |
| CTypeSeqManipl_test | |
| CValueTypeBinding_test | |
| CVariadicArgumentPicker_test | |
| CVirtualCopySupport_test | |
| CZero | |
| C_Fun | Helper for uniform access to function signature types |
| C_Fun< FUN(C::*)> | Allow also to probe plain member fields, which may hold a functor |
| C_Fun< FUN, enable_if< has_FunctionOperator< FUN > > > | Specialisation for function objects and lambdas |
| C_Fun< RET(ARGS...) noexcept > | Specialisation to strip noexcept from the signature |
| C_Fun< RET(ARGS...)> | Specialisation for a bare function signature |
| C_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) |
| C_Fun< RET(C::*)(ARGS...) noexcept > | Specialisation to deal with member pointer to noexcept function |
| C_Fun< RET(C::*)(ARGS...)> | Specialisation to deal with member pointer to function |
| C_Fun< SIG & > | Specialisation when using a function reference |
| C_Fun< SIG && > | Specialisation for passing a rvalue reference |
| C_Fun< SIG * > | Specialisation for using a function pointer |
| C_Fun< SIG const & > | Specialisation to strip spurious const for type analysis |
| CAppend | Append lists-of-types |
| CAppend< Node< TY, TYPES >, NullType > | |
| CAppend< Node< TY, TYPES >, TAIL > | |
| CAppend< NullType, Node< TY, TYPES > > | |
| CAppend< NullType, NullType > | |
| CAppend< NullType, TY2 > | |
| CAppend< TY1, NullType > | |
| CApply | Apply a transformation (template) to each type in the list |
| CApply< Node< TY, TYPES >, _TRANS_ > | |
| CBuildConfigFromFlags | Build a configuration type from a list-of-flags |
| CBuildConfigFromFlags< Node< Flag< Fl >, FLAGS >, CONF > | |
| CBuildFunType | Build function types from given Argument types |
| CBuildFunType< RET, Types< A1 > > | |
| CBuildFunType< RET, Types< A1, A2 > > | |
| CBuildFunType< RET, Types< A1, A2, A3 > > | |
| CBuildFunType< RET, Types< A1, A2, A3, A4 > > | |
| CBuildFunType< RET, Types< A1, A2, A3, A4, A5 > > | |
| CBuildFunType< RET, Types< A1, A2, A3, A4, A5, A6 > > | |
| CBuildFunType< RET, Types< A1, A2, A3, A4, A5, A6, A7 > > | |
| CBuildFunType< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8 > > | |
| CBuildFunType< RET, Types< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > | |
| CBuildFunType< RET, Types<> > | |
| CBuildIdxIter | Build a sequence of index numbers based on a type sequence |
| CBuildIdxIter< Types< TYPES... > > | Build an index number sequence from a type sequence |
| CBuildIndexSeq | Build regular sequences of index number e.g |
| CBuildIndexSeq< 0 > | |
| CBuildTupleAccessor | Decorating a tuple type with auxiliary data access operations |
| CBuildTupleAccessor< _X_, Types<>, TUP, i > | |
| ►Ccan_convertToString | Detect possibility of a conversion to string |
| CProbe | |
| Ccan_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 |
| Ccan_lexical2string | Types able to be lexically converted to string representation |
| Ccan_StandIn | Verify the first (special) type can stand-in for the second |
| ►Ccan_STL_backIteration | Trait template to detect a type also supporting STL-style backwards iteration |
| Cis_backIterable | |
| Cis_const_backIterable | |
| Cis_const_noexcept_backIterable | |
| Cis_noexcept_backIterable | |
| ►Ccan_STL_ForEach | Trait template to detect a type usable with the STL for-each loop |
| Cis_const_iterable | |
| Cis_const_noexcept_iterable | |
| Cis_iterable | |
| Cis_noexcept_iterable | |
| Ccan_STL_ForEach< std::unordered_map< KEY, VAL, HASH > > | 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 |
| CCartesianProduct | |
| CCloneSupport | |
| CCombine | Build all possible combinations, based on a enumeration of the basic cases |
| CCombine< Node< TY, TYPES >, _ENUM_ > | |
| CCombine< NullType, _ENUM_ > | |
| CCombineFlags | Generate all possible on-off combinations of the given flags |
| CCommonResultYield | Decision helper to select between returning results by value or reference |
| CCommonResultYield< T1, T2, true > | |
| CComparator | Trait template for invoking equality comparison |
| CCondNode | Conditional node: skip an element based on evaluating a predicate |
| CCondNode< true, T, TAIL > | |
| CConfig | < distinct type representing a configuration |
| CConfigSetFlag | |
| CConfigSetFlag< Fl, Config< f1, f2, f3, f4, IGN > > | Set (prepend) the Flag to the given config |
| CConstAll | Build a list of const types from a given typelist |
| CConstAll< Node< TY, TYPES > > | |
| CConstAll< NullType > | |
| CCopySupport | Policy to pick a suitable implementation of "virtual copy operations" |
| CCopySupport< X, enable_if< supports_cloning< X > > > | |
| CCopySupport< X, enable_if< supports_copy_and_assignment< X > > > | |
| CCopySupport< X, enable_if< supports_only_move< X > > > | |
| Ccount | Metafunction counting the number of Types in the collection |
| Ccount< Node< TY, TYPES > > | |
| Ccount< NullType > | |
| CCountDown | Helper for generating test lists |
| CCountDown< Num< 0 > > | |
| CCountDown< Num< I > > | |
| CDefineConfigByFlags | Create a configuration type for the given list-of-flags |
| CDissect | Allows to access various parts of a given typelist: Start and End, Prefix and Tail.. |
| CDissect< Node< T, TYPES > > | |
| CDissect< NullType > | |
| CDistribute | 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 |
| CDistribute< Node< TY, TYPES >, TAIL > | |
| CDistribute< NullType, TY > | |
| CElementExtractor | Generic converter to somehow extract values from the "source" type to fill and initialise a tuple of given target type |
| ►CElementExtractor< 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 |
| CAccess | |
| CEmptyBase | |
| Cenable_if_c | |
| Cenable_if_c< false, T > | |
| CFilter | Filter away those types which don't fulfil a predicate metafunction |
| CFilter< Node< TY, TYPES >, _P_ > | |
| CFilter< NullType, _P_ > | |
| CFlag | |
| CFlag< 0 > | |
| CFlagInfo | Helper for calculating values and for invoking runtime code based on a given FlagTuple |
| CFlagInfo< Node< CONF, TAIL > > | |
| CFlagInfo< Node< Flag< ff >, FLAGS > > | |
| CFlagInfo< NullType > | |
| CFlagOnOff | Enumeration generator for the Combine metafunction, yielding an "on" and "off" case |
| CFlags | |
| CFullCopySupport | |
| CFunErasure | Generic wrapper carrying a function object while hiding the actual function signature |
| ►Chas_FunctionOperator | Trait template to detect presence of a simple function call operator |
| CProbe | |
| Chas_Sig | Meta-function to check that some function like entity offers the expected signature |
| Chas_Sig< FUN, X, false > | Catch-all to prevent compilation failure for anything not function-like |
| Chas_TypeResult | Helper to check if another metafunction produced a result type |
| CIndexSeq | Hold a sequence of index numbers as template parameters |
| CInheritFrom | Helper to just inherit from the given type(s) |
| CInstancePlaceholder | Placeholder marker for a special argument position to be supplied later |
| CInstantiateChained | Build a single inheritance chain of template instantiations |
| CInstantiateChained< Node< TY, TYPES >, _X_, BASE > | |
| CInstantiateChained< NullType, _X_, BASE > | |
| CInstantiateChainedCombinations | Build a Case matrix |
| CInstantiateForEach | Apply a template to a collection of types |
| CInstantiateForEach< Node< TY, TYPES >, _X_, BASE > | |
| CInstantiateForEach< NullType, _X_, BASE > | |
| CInstantiateWithIndex | A Variation of InstantiateChained providing an incremented Index value template parameter |
| CInstantiateWithIndex< Node< TY, TYPES >, _X_, BASE, i > | |
| CInstantiateWithIndex< NullType, _X_, BASE, i > | |
| Cis_basically | Compare for unadorned base type, disregarding const and references |
| Cis_basicallySame | Compare unadorned types, disregarding const and references |
| Cis_narrowingInit | Temporary workaround for GCC [Bug-63723], necessary until CGG-5 |
| Cis_narrowingInit< lib::hash::LuidH, TAR > | |
| Cis_nonFloat | |
| Cis_smart_ptr | Detect smart pointers |
| Cis_smart_ptr< std::shared_ptr< T > > | |
| Cis_smart_ptr< std::unique_ptr< T, D > > | |
| Cis_StateCore | Trait template to detect a type exposing a »state core« API |
| Cis_StreamSource | |
| Cis_StringLike | Detect various flavours of string / text data |
| Cis_Subclass | Verify compliance to an interface by subtype check |
| Cis_Tuple | Trait to detect tuple types |
| Cis_Tuple< const std::tuple< TYPES... > > | |
| Cis_Tuple< std::tuple< TYPES... > > | |
| Cis_Typelist | Trait template for detecting a typelist type |
| CIsInList | Metafunction to check if a specific type is contained in a given typelist |
| CIsInList< TY, Node< TY, TYPES > > | |
| CIsInList< TY, Node< XX, TYPES > > | |
| CMarked | Metaprogramming helper to mark some arbitrary base type by subclassing |
| CmaxAlign | Metafunction " max( alignof(T) ) for T in TYPES " |
| CmaxAlign< Node< TY, TYPES > > | |
| CmaxAlign< NullType > | |
| CmaxSize | Metafunction " max( sizeof(T) ) for T in TYPES " |
| CmaxSize< Node< TY, TYPES > > | |
| CmaxSize< NullType > | |
| CMoveSupport | |
| CNo_t | |
| CNoCopyMoveSupport | |
| CNode | |
| CNoInstance | An Entity never to be instantiated |
| CNoUsableHashDefinition | |
| CNullType | |
| CNum | Constant-wrapper type for debugging purposes, usable for generating lists of distinguishable types |
| CNumz | Dummy interface / baseclass for diagnostics |
| CPick | Pick the n-th element from a typelist |
| CPick< Node< TY, TYPES >, 0 > | |
| CPick< Node< TY, TYPES >, i > | |
| CPick< Types< TYPES... >, i > | Specialisation: pick n-th element from a type sequence |
| ►CPickParametersFromSublist | |
| CSingleCaseInstantiation | |
| CPrefixAll | Prefix each of the elements, yielding a list-of lists-of-types |
| CPrefixAll< T, Node< TY, TYPES > > | |
| CPrefixAll< T, NodeNull > | |
| CPrefixAll< T, NullType > | |
| CPrepend | Helper: prepend a type to an existing type sequence, thus shifting all elements within the sequence to the right, eventually dropping the last element |
| CPrepend< T, TySeq< TYPES... > > | Temporary workaround: additional specialisation for the template Prepend to work also with the (alternative) variadic TySeq |
| CPrepend< T01, Types< T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, IGN > > | |
| Cprovides_BoostHashFunction | Trait template to detect if some custom type TY provides a boost compliant hash function through ADL |
| CRebindTupleTypes | Temporary workaround: match and rebind the type sequence from a tuple |
| CRebindTupleTypes< std::tuple< TYPES... > > | |
| CRebindVariadic | Metaprogramming helper to transfer variadic arguments |
| CRebindVariadic< X, U< ARGS... > > | |
| CRefTraits | Type definition helper for pointer and reference types |
| CRefTraits< TY & > | |
| CRefTraits< TY && > | |
| CRefTraits< TY * > | |
| CShifted | Helper: generate a type sequence left shifted by i steps, filling in NullType at the end |
| CShifted< TYPES, 0 > | |
| ►CSizeTrait | A collection of constants to describe the expected size of some known classes, without needing to include the respective headers |
| CBasicAltstringbuf | |
| CBasicStringbuf | |
| CBoostFormat | |
| CCompatAllocator | |
| CLocale | |
| COptional | |
| CSplice | Splice a typelist like an overlay into an base typelist, starting at given index |
| CSplice< Node< B, BS >, Node< O, OS >, 0 > | |
| CSplice< Node< B, BS >, NullType, 0 > | |
| CSplice< Node< B, BS >, OVERLAY, i > | |
| CSplice< NullType, XX, i > | |
| CSplit | Helper: separate parts of a type sequence |
| CSplit< Types< T01, T02, T03, T04, T05, T06, T07, T08, T09, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 > > | |
| CSplitLast | Access the last list element |
| CSplitLast< Node< TY, NullType > > | |
| CSplitLast< Node< TY, TYPES > > | |
| CSplitLast< NullType > | |
| CStoreFunction | 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 |
| CStoreFunPtr | Policy for FunErasure: store a bare function pointer |
| CStoreUncheckedFunPtr | Policy for FunErasure: store an unchecked bare function pointer |
| CStrip | Helper for type analysis: tries to strip all kinds of type adornments |
| CStripNullType | Temporary workaround: strip trailing NullType entries from a type sequence, to make it compatible with new-style variadic template definitions |
| CStripNullType< Types< NullType, TYPES... > > | |
| CStripNullType< Types< T, TYPES... > > | |
| CTupleConstructor | Extensible Adapter to construct a distinct tuple from some arbitrary source type |
| CTupleElementDisplayer | Helper to dump tuple contents |
| CTupleElementDisplayer< NullType, TUP, TUP, n > | |
| CTypes | |
| CTypes< Node< H, T > > | Additional specialisation of the basic type sequence type, allowing to re-create a (flat) type sequence from a typelist |
| CTypes<> | |
| CTySeq | Temporary workaround: alternative definition of "type sequence", already using variadic template parameters |
| CUnwrap | Helper for type analysis and convenience accessors: attempts to extract a base type from various wrappers |
| CUnwrap< boost::reference_wrapper< X > > | |
| CUnwrap< P< X, B > > | |
| CUnwrap< std::reference_wrapper< X > > | |
| CUnwrap< std::shared_ptr< X > > | |
| CUnwrap< std::unique_ptr< X, D > > | |
| CUnwrap< void > | < |
| CUnwrap< X * > | |
| Cuse_LexicalConversion | |
| Cuse_StringConversion4Stream | When to use custom string conversions for output streams |
| CValueTypeBinding | Type re-binding helper template for creating nested typedefs usable by custom containers and iterator adapters or similar |
| CValueTypeBinding< TY, enable_if< use_ValueTypebindings< TY > > > | Specialisation for classes providing STL style type binding definitions |
| CValueTypeBinding< 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 |
| CVirtualCopySupportInterface | |
| ►Npolyvalue | |
| Callow_Clone_but_no_Copy | Helper to detect if the API supports only copy construction, but no assignment |
| CAssignmentPolicy | Policy class for invoking the assignment operator |
| CAssignmentPolicy< API, enable_if< allow_Clone_but_no_Copy< API > > > | Special case when the embedded payload objects permit copy construction, but no assignment to existing instances |
| CCloneValueSupport | A variation for limited copy support |
| CCopySupport | Interface for active support of copy operations by the embedded client objects |
| CEmptyBase | |
| Cexposes_CloneFunction | Helper to detect presence of a function to support clone operations |
| CTrait | Trait template to deal with different ways to support copy operations |
| CTrait< TY, enable_if< exposes_CloneFunction< TY > > > | Special case when the embedded types support copying on the API level, e.g |
| ►Nquery | |
| ►Ntest | |
| CQueryUtils_test | |
| CThing | |
| ►Nrandom_draw | |
| CLimitedRandomGenerate | Default policy for RandomDraw: generate limted-range random numbers |
| ►Nseveral | |
| CArrayBucket | Metadata record placed immediately before the data storage |
| CSelfDestructor | |
| ►Nsplitsplice | |
| ►CAlgo | Implementation of »SplitSplice« algorithm |
| CSegBounds | |
| ►Nstat | |
| ►Ntest | |
| ►Nanonymous_namespace{data-csv-test.cpp} | |
| CTableForm | Define the layout of a data row |
| CDataCSV_test | |
| CFileSupport_test | |
| CStatistic_test | |
| CColumn | Descriptor and Accessor for a data column within a DataTable table |
| CCSVData | Wrapper to simplify notation in tests |
| CCSVLine | A string with the ability to construct or append the CSV-rendering of data fields |
| CCsvParser | Parser to split one line of CSV data into fields |
| CDataSpan | Read-only view into a segment within a sequence of data |
| CDataTable | Table with data values, stored persistently as CSV file |
| CRegressionPoint | Single data point used for linear regression |
| ►Nsync | Helpers and building blocks for Monitor based synchronisation |
| CCondition | |
| CMonitor | Object Monitor for synchronisation and waiting |
| CNoLocking | |
| ►Ntest | |
| ►Nanonymous_namespace{allocation-cluster-test.cpp} | |
| CDummy | |
| ►Nanonymous_namespace{builder-qualifier-support-test.cpp} | |
| CExampleStrategy | Example "strategy" class, which can be configured with additional qualifiers at construction |
| ►Nanonymous_namespace{call-queue-test.cpp} | |
| CDummy | |
| ►Nanonymous_namespace{del-stash-test.cpp} | |
| CProbe | |
| ►Nanonymous_namespace{dependency-configuration-test.cpp} | |
| CDum | |
| CDummy | |
| ►Nanonymous_namespace{dependency-factory-test.cpp} | |
| CSub | |
| CSubSub | |
| CSubSubDub | |
| CSubSubSub | |
| ►Nanonymous_namespace{iter-adapter-test.cpp} | |
| CTestContainer | Example of a more elaborate custom container exposing an iteration API |
| CWrappedVector | Example of simply wrapping an STL container and exposing a range as Lumiera Forward Iterator |
| ►Nanonymous_namespace{iter-core-adapter-test.cpp} | |
| CStepDown | A test »*State Core*« which steps down a number to zero |
| ►Nanonymous_namespace{iter-explorer-test.cpp} | |
| CCountDown | This iteration _"state core" type_ describes a descending sequence of numbers yet to be delivered |
| CNumberSequence | A straight descending number sequence as basic test iterator |
| CRandomSeq | Another iteration _"state core"_ to produce a sequence of random numbers |
| ►Nanonymous_namespace{iter-source-test.cpp} | |
| CTestSource | Explicit implementation of the IterSource interface (test dummy) Creates a random string and chops off a character on each iteration |
| CWrappedList | Test dummy: simply wrapping an STL container and exposing a range as Lumiera Forward Iterator |
| ►Nanonymous_namespace{itertools-test.cpp} | |
| CTestSource | |
| ►Nanonymous_namespace{linked-elements-test.cpp} | |
| CNum | To demonstrate holding subclasses |
| CNummy | Test-Element, supporting intrusive linked list storage |
| CNummyGenerator | Helper to produce a pre-determined series of objects to populate a LinkedElements list |
| CPopulator | Iterator-Frontend to generate this series of objects |
| ►Nanonymous_namespace{multifact-argument-test.cpp} | |
| CNum | |
| ►Nanonymous_namespace{multifact-singleton-test.cpp} | |
| CImplementation | |
| CInterface | |
| ►Nanonymous_namespace{multifact-test.cpp} | |
| CImplementation | |
| CInterface | |
| ►Nanonymous_namespace{null-value-test.cpp} | |
| CDummyType | Test dummy to track ctor call |
| ►Nanonymous_namespace{opaque-holder-test.cpp} | |
| CBase | |
| CDD | |
| CSpecial | |
| ►Nanonymous_namespace{opaque-unchecked-buffer-test.cpp} | |
| CBase | |
| CD42Sub | |
| CDD | |
| CKiller | |
| ►Nanonymous_namespace{polymorphic-value-test.cpp} | |
| CImp | Template to generate concrete implementation classes |
| CInterface | |
| ►Nanonymous_namespace{random-draw-test.cpp} | |
| ►CSymmetricFive | |
| CAdaptor | Adaptor to handle further mapping functions |
| CAdaptor< RES(size_t, double)> | Inject external contextual state into a mapping function |
| CAdaptor< RES(uint, uint)> | Allow a mapping function rely on quantisation cycles |
| ►Nanonymous_namespace{ref-array-test.cpp} | |
| CI | |
| CSub1 | |
| CSub2 | |
| CSub3 | |
| ►Nanonymous_namespace{scoped-collection-test.cpp} | |
| CSubDummy | |
| ►Nanonymous_namespace{scoped-holder-transfer-test.cpp} | |
| CFixedDummy | |
| CTable | |
| ►Nanonymous_namespace{several-builder-test.cpp} | |
| CNum | Instance tracking sub-dummy |
| CShortBlocker | A non-copyable struct with 16bit alignment |
| ►Nanonymous_namespace{simple-allocator-test.cpp} | |
| CDummyObj | Yet-another ctor/dtor-tracking test dummy object... |
| ►Nanonymous_namespace{split-splice-test.cpp} | |
| CSeg | Test Dummy: a "segment" representing an integer interval |
| CSegL | Test-Segmentation comprised of a sequence of Seg entries |
| ►Nanonymous_namespace{sync-barrier-performance-test.cpp} | |
| CFakeBarrier | Empty placeholder implementation |
| CMonitorSync | A Monitor based reference implementation, using Mutex + Condition Variable for sleeping wait |
| ►Nanonymous_namespace{sync-barrier-test.cpp} | |
| CTestThread | A test thread to perform a summation protocol including synchronisation points |
| ►Nanonymous_namespace{sync-locking-test.cpp} | |
| CChecker | Helper to verify a contended chain calculation |
| ►Nanonymous_namespace{sync-waiting-test.cpp} | |
| CSyncOnBool | Demonstrates how to wait on a simple boolean flag |
| ►Nanonymous_namespace{test-helper.hpp} | |
| CTypeDiagnostics | |
| CTypeDiagnostics< const X * > | |
| CTypeDiagnostics< const X *const > | |
| CTypeDiagnostics< const X > | |
| CTypeDiagnostics< X & > | |
| CTypeDiagnostics< X && > | |
| CTypeDiagnostics< X * > | |
| CTypeDiagnostics< X *const * > | |
| CTypeDiagnostics< X *const > | |
| CTypeDiagnostics< X const & > | |
| CTypeDiagnostics< X const && > | |
| ►Nanonymous_namespace{tracking-allocator.cpp} | |
| CPoolRegistry | Keep track of any distinct memory pools used |
| ►Nanonymous_namespace{typed-allocation-manager-test.cpp} | |
| CDummyObj | Yet-another ctor/dtor-tracking test dummy object... |
| ►Nanonymous_namespace{vector-transfer-test.cpp} | |
| CTransDummy | |
| ►Nanonymous_namespace{verb-function-dispatch-test.cpp} | |
| CReceiver | "visitor" interface to invoke |
| CRecollectingReceiver | Statefull receiver of verb-tokens |
| CVerboseRenderer | Receiver of verb-tokens, which renders them verbosely |
| ►Nanonymous_namespace{verb-visitor-dispatch-test.cpp} | |
| CDiagnosticRenderer | Another concrete receiver to report any invocation with arguments |
| CReceiver | "visitor" interface used by all VerbPacks in this test |
| CVerboseRenderer | Concrete receiver of verb-tokens, which renders them verbosely |
| ►Nmicrobenchmark | |
| CAdaptor | |
| CAdaptor< ON(IN), enable_if< __and_< is_arithmetic< IN >, __not_< is_same< IN, size_t > >, is_arithmetic< ON >, __not_< is_same< ON, size_t > > > > > | |
| CAdaptor< ON(void), enable_if< __and_< is_arithmetic< ON >, __not_< is_same< ON, size_t > > > > > | |
| CAdaptor< size_t(size_t)> | |
| CAdaptor< void(IN), enable_if< __and_< is_arithmetic< IN >, __not_< is_same< IN, size_t > > > > > | |
| CAdaptor< void(void)> | |
| ►Ntest | |
| ►Nanonymous_namespace{test-helper-variadic-test.cpp} | |
| CImpl | |
| CInterface | |
| CEventLog_test | |
| CMurpf | |
| CTempDir_test | |
| CTestHelper_test | Verifies the proper working of helper functions frequently used within the Lumiera testsuite |
| CTestHelperVariadic_test | |
| CTestTracking_test | |
| CWrmrmpft | |
| CAllocationCluster_test | |
| CBuilderQualifierSupport_test | |
| ►CCallQueue_test | |
| CWorker | |
| CCmdlineWrapper_test | |
| CCustomSharedPtr_test | |
| CDelStash_test | |
| CDependencyConfiguration_test | |
| CDependencyFactory_test | |
| ►CDiagnosticContext_test | |
| CTestThread | Build a call stack within separate thread and capture diagnostics |
| CDummy | A Dummy object for tests |
| CDummyAncestor | |
| CEventLog | Helper to log and verify the occurrence of events |
| CEventMatch | |
| CExpectString | Helper to produce better diagnostic messages when comparing to an expected result string |
| CGnuplotGen_test | |
| CHashGenerator_test | |
| CHashIndexed_test | |
| CHashStandardToBoostBridge_test | |
| CHeteroData_test | |
| CImpl | |
| CImpl_XXX | |
| CIncidenceCount_test | |
| CIndexIter_test | |
| CInterface | Target object to be instantiated as Singleton Allocates a variable amount of additional heap memory and prints diagnostic messages |
| CIterAdapter_test | |
| CIterAdapterSTL_test | |
| CIterCoreAdapter_test | |
| CIterCursor_test | |
| ►CIterExplorer_test | |
| CMagicTestRubbish | Demo of a custom processing layer interacting directly with the iteration mechanism |
| CIterQueue_test | |
| CIterSource_test | |
| CIterStack_test | |
| CIterTools_test | |
| CIterZip_test | |
| ►CLazyInit_test | |
| CLazyDemo | Elaborate setup used for integration test |
| ►CLinkedElements_test | |
| CUseAllocationCluster | Policy to use an Allocation cluster, but also to invoke all object destructors |
| ►CMemoryPool | |
| CAllocation | Registration entry to maintain a single allocation |
| CLocationHash | |
| CMock_1 | Mock-1 to replace the Client Class.. |
| CMock_2 | Mock-2 to replace the Client Class.. |
| CMultiFact_test | |
| CMultiFactArgument_test | |
| CMultiFactSingleton_test | |
| CNullValue_test | |
| COpaqueHolder_test | |
| COpaqueUncheckedBuffer_test | |
| COptionalRef_test | |
| CPathArray_test | |
| CPolymorphicValue_test | |
| CQueryText_test | |
| CRandom_test | |
| ►CRandomConcurrent_test | |
| CExperiment | Research setup to investigate concurrent access to a random generator |
| CRandomDraw_test | |
| ►CRefArray_test | |
| CFac | < fabricating a series of subclass instances with varying ctor parameter |
| CResult_test | |
| CS | Custom-Datatype 1: uses std::hash extension point |
| ►CScopedCollection_test | |
| CManagerDemo | |
| CPopulator | Functor to populate the Collection |
| CScopedHolder_test | |
| CScopedHolderTransfer_test | |
| CScopedPtrVect_test | |
| CSearchPathSplitter_test | |
| CSeveralBuilder_test | |
| CSimpleAllocator_test | |
| CSingleton_test | |
| CSingletonSubclass_test | |
| CSingletonTestMock_test | |
| CSplitSplice_test | |
| ►CSubID_test | |
| CHashTable | |
| CSymbol_test | |
| CSymbolHashtable_test | |
| CSyncBarrier_test | |
| CSyncBarrierPerformance_test | |
| CSyncClasslock_test | |
| CSyncLocking_test | |
| CSyncTimedwait_test | |
| CSyncWaiting_test | |
| CTargetObj | Target object to be instantiated as Singleton Allocates a variable amount of additional heap memory and prints diagnostic messages |
| CTempDir | A RAII style temporary directory |
| CTestB | |
| CTestDA | |
| CTestDB | |
| CTestSingO | Client Class normally to be instantiated as Singleton |
| CTestTargetObj | Target object to be created by Test-Factories or as Singleton |
| CTextTemplate_test | |
| CThreadWrapper_test | |
| CThreadWrapperAutonomous_test | |
| CThreadWrapperJoin_test | |
| CThreadWrapperLifecycle_test | |
| CThreadWrapperSelfRecognitionTest_test | |
| CTimeBasics_test | |
| CTrackAlloc | C++ standard compliant custom allocator adapter backed by the TrackingAllocator and the MemoryPool denoted at construction |
| CTracker | A tracking Dummy object for tests |
| CTrackingAllocator | Generic low-level allocator attached to tracking MemoryPool |
| CTrackingFactory | Generic object factory backed by TrackingAllocator |
| CTransiently | Token to capture a value and restore original when leaving scope |
| CTransiently< void(void)> | Variation where manipulation is done by λ |
| CTypedAllocationManager_test | |
| ►CTypedCounter_test | |
| CDummy | Parametrised marker type to designate a counter to be incremented |
| CTypeDebugger | Helper to show types involved in metaprogramming |
| CTypedFamilyMemberID_test | |
| CUniqueMallocOwner_test | |
| CUnrelated | |
| CV | Custom-Datatype 2: uses boost::hash extension point |
| CVariant_test | |
| CVectorTransfer_test | |
| CVerbFunctionDispatch_test | |
| CVerbVisitorDispatch_test | |
| CX | |
| CXX | |
| CZombieCheck_test | |
| ►Ntext_template | |
| CDataSource< diff::GenNode > | Data-binding for a tree of GenNode data (ETD) |
| CTagSyntax | |
| ►Nthread | |
| CPolicyLaunchOnly | Thread Lifecycle Policy: |
| CPolicyLifecycleHook | Thread Lifecycle Policy Extension: invoke user-provided callbacks from within thread lifecycle |
| CPolicyResultJoin | Thread Lifecycle Policy: |
| ►CThreadLifecycle | Policy-based configuration of thread lifecycle |
| CLaunch | Configuration builder to define the operation running within the thread, and possibly configure further details, depending on the actual Policy used |
| CThreadWrapper | |
| ►Ntime | |
| ►Nanonymous_namespace{quantiser.hpp} | |
| CValTrait | |
| CValTrait< double > | |
| CValTrait< int > | |
| ►Ndigxel | |
| CCountFormatter | |
| CFormatter | Default configured Formatter implementations for some of the basic numeric types |
| CFormatter< double > | |
| CFormatter< int > | |
| CHexaFormatter | |
| CHourFormatter | |
| CPrintfFormatter | Default / base implementation for Digxel formatting |
| CSexaFormatter | |
| CSignFormatter | |
| ►Nformat | |
| ►Ntest | |
| CFormatSupport_test | |
| CFrames | Frame count as timecode format |
| CHms | The informal hours-minutes-seconds-millisecond timecode |
| CSeconds | Simple timecode specification as fractional seconds |
| CSmpte | Widely used standard media timecode format |
| CSupported | Descriptor to denote support for a specific (timecode) format |
| CSupportStandardTimecode | Predefined standard configuration: Descriptor for supporting all the classical timecode formats |
| CTraits | |
| CTraits< Frames > | |
| CTraits< Hms > | |
| CTraits< Seconds > | |
| CTraits< Smpte > | |
| ►Nmutation | |
| ►Nanonymous_namespace{control-policy.hpp} | |
| CcanMutateDuration | |
| CcanReceiveDuration | |
| CBuilder | Implementation policy: how to build a new notification value of type TI, given a target time value entity of type TAR |
| CBuilder< TimeSpan, Duration > | |
| CBuilder< TimeSpan, TAR > | |
| CBuilder< TimeSpan, TimeSpan > | |
| CLink | Policy to tie the various detail policies together for providing actual value change operations |
| CMutator | Implementation building block: impose changes to a Time element |
| CPolicy | Policy how to impose changes onto a connected target time value entity This policy will be parametrised with the concrete time entity types involved in the usage situation of time::Control |
| CPolicy< Duration, typename disable_if< canReceiveDuration< TAR >, Duration >::type, TAR > | Special case: a Duration change value can't be imposed to a plain time value |
| CPolicy< TI, Duration, TimeSpan > | |
| CPolicy< TI, SRC, typename disable_if< canMutateDuration< SRC >, Duration >::type > | Special case: a Duration target value can't be changed by plain time values |
| CPolicy< TI, TimeSpan, Duration > | |
| CPolicy< TimeSpan, TimeSpan, TimeSpan > | |
| CPropagator | Implementation building block: propagate changes to listeners |
| ►Ntest | |
| ►Nanonymous_namespace{digxel-test.cpp} | |
| CVerySpecialFormat | |
| ►Nanonymous_namespace{time-control-test.cpp} | |
| CIterationEnd | |
| CTestCase | |
| CTestChange | |
| CTestChange< QuTime > | |
| CTestChange< TimeSpan > | |
| CTestListener | Mock object to receive change notifications |
| CTestTarget | |
| CTestTarget< QuTime > | |
| CTestTarget< TimeSpan > | |
| ►Nanonymous_namespace{time-parsing-test.cpp} | |
| CParsing | Expression builder for writing time value parsing tests |
| CDigxel_test | |
| CDigxelConfigurations_test | |
| ►CQuantiserBasics_test | |
| CTestQuant | Test Quantiser allowing to use plain numbers |
| CTimeControl_test | |
| CTimeFormats_test | |
| ►CTimeMutation_test | |
| CTestValues | |
| CTimeParsing_test | |
| CTimeQuantisation_test | |
| CTimeValue_test | |
| CControl | Frontend/Interface: controller-element to retrieve and change running time values |
| CDigxel | A number element for building structured numeric displays |
| CDuration | Duration is the internal Lumiera time metric |
| CFixedFrameQuantiser | Simple stand-alone Quantiser implementation based on a constant sized gird |
| CFrameNr | A frame counting timecode value |
| CFrameRate | Framerate specified as frames per second |
| CGrid | Abstraction of a value alignment grid |
| CHmsTC | |
| CImposeOffsetMutation | Concrete time value mutation: adjust the given time entity by an offset amount |
| CMaterialiseIntoTarget | Concrete time value mutation: make the grid aligned time value explicit, and impose the resulting value to the given time points (or start points) |
| CMutation | Interface: an opaque change imposed onto some time value |
| CNaturalNudgeMutation | Concrete time value mutation: nudge based on a implicit grid, which is either a quantised target value's own grid, or a natural grid |
| CNudgeMutation | Concrete time value mutation: nudge target value by the given number of 'steps', relative to the given grid |
| COffset | Offset measures a distance in time |
| CQuantiser | Facility to create grid-aligned time values |
| CQuTime | Grid aligned time specification, referring to a specific scale |
| CSecs | |
| CSetNewDuration | Concrete time value mutation: set a new overall duration for an extended timespan |
| CSetNewStartTimeMutation | Concrete time value mutation: impose fixed new start time |
| CSignum | Special Digxel to show a sign |
| CSmpteTC | Classical Timecode value reminiscent to SMPTE format |
| CTCode | Interface: fixed format timecode specification |
| CTime | Lumiera's internal time value datatype |
| CTimeSpan | A time interval anchored at a specific point in time |
| CTimeValue | Basic constant internal time value |
| CTimeVar | Mutable time value, behaving like a plain number, allowing copy and re-accessing |
| ►Nvariant | |
| CCanBuildFrom | |
| CCanBuildFrom< const char [len], Node< string, TYPES > > | < esp. allow to build string from char literal |
| CCanBuildFrom< const X, Node< X, TYPES > > | |
| CCanBuildFrom< diff::MakeRec, Node< Rec, TYPES > > | Specialisation allowing to build a GenNode with a nested record from a Record::Mutator (aka MakeRec) |
| CCanBuildFrom< X, Node< T, TYPES > > | |
| CCanBuildFrom< X, Node< X, TYPES > > | |
| CCanBuildFrom< X, NullType > | |
| CFirstMatchingType | Helper to pick the first type from a type sequence, which fulfils the predicate (meta function) given as template |
| CFirstMatchingType< Node< T, TYPES >, _P_ > | |
| CFirstMatchingType< Types< TYPES... >, _P_ > | |
| ►CHolder | Internal helper used to build a variant storage wrapper |
| CBuffer | Storage to hold the actual value |
| CCasePrepare | Initialise the dispatcher (trampoline) for the case of accessing type T |
| CCaseSelect | Provide a dispatcher table based visitation mechanism |
| CDeleter | |
| CPlacementAdapter | |
| CIdentity | |
| ►CVFunc | |
| CValueAcceptInterface | How to treat one single type in visitation |
| ►Nvisitor | |
| ►Ntest1 | |
| CBabbler | |
| CBigBoss | |
| CBoss | |
| CHomoSapiens | |
| CLeader | |
| CVerboseVisitor | |
| CVisionary | |
| CVisitingTool_test | |
| ►Ntest2 | |
| CBabbler | |
| CBigBoss | |
| CBlatherer | Hastalavista-Visiting-Tool tailored for the Chief hierarchy |
| CBoss | |
| CCatched | Defines an catch-all-function instead of the silent default error handler |
| CHomoSapiens | |
| CLeader | Now mixing the two hierarchies.. |
| CVerboseVisitor | |
| CVisionary | |
| CVisitingToolExtended_test | |
| CApplicable | Marker template to declare that some "visiting tool" wants to treat a set of concrete Visitable classes |
| CApplicable< TOOLImpl, typelist::Node< TAR, TYPES >, BASE > | |
| CApplicable< TOOLImpl, typelist::NullType, BASE > | |
| CDispatcher | For each possible call entry point via some subclass of the visitable hierarchy, we maintain a dispatcher table to keep track of all concrete tool implementations able to receive and process calls on objects of this subclass |
| CTag | Type tag for concrete visiting tool classes |
| CTagTypeRegistry | |
| CThrowException | Policy to throw when encountering an unknown visiting tool |
| CTool | Marker interface / base class for all "visiting tools" |
| CUseDefault | Policy returning just the default return value in case of encountering an unknown Visitor (typically caused by adding a new class to the visitable hierarchy) |
| CVisitable | Marker interface or base class for all "Visitables" |
| ►Nwrapper | |
| ►Ntest | |
| ►Nanonymous_namespace{item-wrapper-test.cpp} | |
| CTracker | |
| ►Nanonymous_namespace{replaceable-item-test.cpp} | |
| CNonAssign | |
| CTracker | |
| CItemWrapper_test | |
| CReplaceableItem_test | |
| CFunctionResult | Extension of ItemWrapper: a function remembering the result of the last invocation |
| Cis_assignable_value | |
| CItemWrapper | Universal value/ref wrapper accessible similar to a pointer |
| CItemWrapper< TY & > | Specialisation of the ItemWrapper to deal with references, as if they were pointer values |
| CItemWrapper< void > | Fallback-specialisation for ItemWrapper<void> |
| CReplaceableItem | Adapter container to take snapshots from non-assignable values |
| CReplaceableItem< X, meta::enable_if< is_assignable_value< X > > > | Simple delegating implementation to use for regular cases |
| CReplaceableItem< X, meta::enable_if< std::is_reference< X > > > | Disallow embedding references |
| CReturnRef | Reference wrapper implemented as constant function, returning the (fixed) reference on invocation |
| CAddressExposingIter | Wrapper for an existing Iterator type to expose the address of each value yielded |
| ►CAllocationCluster | A pile of objects sharing common allocation and lifecycle |
| CAllocationWithDestructor | |
| CAllocator | |
| CDestructor | |
| CStorage | Maintaining the Allocation |
| ►CStorageManager | An overlay view for the AllocationCluster to add functionality for adding / clearing extents and registering optional deleter functions |
| CExtent | Block of allocated storage |
| CManagementView | |
| ►CAllocator_TransferNoncopyable | Addendum to scoped-holder.hpp for transferring the lifecycle management to another instance |
| Crebind | |
| ►CAllocatorHandle | Placeholder implementation for a custom allocator |
| CAllocation | |
| CAutoRegistered | Helper mixin template for implementing a type intended to participate in automatic element tracking |
| ►CBuilderQualifierSupport | Mix-in to accept and apply an arbitrary sequence of qualifier functors |
| CQualifier | |
| CCallQueue | A threadsafe queue for bound void(void) functors |
| CCappedGen | Adapter to protect against data corruption caused by concurrent access |
| CCheckedCore | Adapter to add sanity checks to a »state core« |
| ►CClassLock | A synchronisation protection guard employing a lock scoped to the parameter type as a whole, not an individual instance |
| CPerClassMonitor | |
| CCmdline | Abstraction of the usual int argc, int** argv-Commandline, to be able to treat it as a vector of strings |
| CConstIter | Wrapper to expose values as const |
| CContainerCore | Adapter to »piggy-back« a STL iterable container inline and expose it as »state core« |
| CCustomAllocator | Policy: use just plain heap allocations whenever you define a specialisation, you are responsible for proper alignment |
| ►CDelStash | Manage a collection of deleter functions |
| CKiller | |
| CDepend | Access point to singletons and other kinds of dependencies designated by type |
| ►CDependencyFactory | Helper to abstract creation and lifecycle of a dependency |
| CcanDefaultConstruct | Metafunction: can we instantiate the desired object here? |
| ►CDependInject | This framework allows to (re)configure the lib::Depend front-end for dependency-injection |
| CLocal | Configuration handle for temporarily shadowing a dependency by a test mock instance |
| CServiceInstance | Configuration handle to expose a service implementation through the Depend<SRV> front-end |
| CSubclassFactoryType | |
| CDiagnosticContext | Diagnostic data frame to collect specific information concerning a scope |
| CElementTracker | Registry for tracking object instances |
| CEmptyBase | |
| CExtendedSubId | |
| CExtensibleFilterIter | Additional capabilities for FilterIter, allowing to extend the filter condition underway |
| CFamilyMember | Utility to produce member IDs for objects belonging to a "Family", as defined by a distinguishing type |
| CFilterCore | Implementation of the filter logic |
| CFilterIter | Iterator tool filtering pulled data according to a predicate |
| CHandle | Generic opaque reference counting handle, for accessing a service and managing its lifecycle |
| ►CHashIndexed | A Mixin to add a private ID type to the target class, together with storage to hold an instance of this ID, getter and setter, and a templated version of the ID type which can be used to pass specific subclass type info |
| CId | Hash based ID, typed to a specific subclass of BA |
| CID | Generic hash based ID, corresponding to the base class BA |
| CUseEmbeddedHash | Enables use of BA objects as keys within std::unordered_map |
| CUseHashID | Trivial hash functor using the ID as hash |
| CHeteroData | A setup with chained data tuples residing in distributed storage |
| ►CHeteroData< meta::Node< StorageFrame< seg, DATA... >, TAIL > > | |
| CAccessor | Accessor-functor to get at the data residing within some tuple element Using the enclosing typed scope to ensure safe storage access |
| CChain | Constructor-functor to build an extra data segment, which can then be linked to the chain |
| CHeteroData< meta::NullType > | |
| CIdentityCore | A neutral identity-function core, also serving as point-of reference how any core is intended to work |
| ►CIncidenceCount | A recorder for concurrent incidences |
| CInc | |
| CStatistic | |
| CIndexIter | Subscript-index based access to a container, packaged as iterator |
| ►CInPlaceAnyHolder | Inline buffer to hold and own an object while concealing the concrete type |
| CBuff | Concrete subclass to manage a specific kind of contained object |
| CBuffer | Inner capsule managing the contained object (interface) |
| CEmptyBuff | Special case: no stored object |
| CInPlaceAnyHolder_unrelatedTypes | Alternative policy for accessing the contents without a common interface; use this policy if the intention is to use OpaqueHolder with a family of similar classes, without requiring all of them to be derived from a common base class |
| CInPlaceAnyHolder_useCommonBase | Standard policy for accessing the contents via a common base class interface |
| ►CInPlaceBuffer | Buffer to place and maintain an object instance privately within another object |
| CTypeTag | |
| CIterableDecorator | Decorator-Adapter to make a »*State Core*« iterable as Lumiera Forward Iterator |
| CIterAdapter | Adapter for building an implementation of the »Lumiera Forward Iterator« concept |
| CIterCursor | A cursor-like iterator with the ability to switch iteration direction |
| CIterExplorer | Adapter to build a demand-driven tree expanding and exploring computation based on a custom opaque state core |
| CIterExploreSource | Iterator front-end to manage and operate a IterExplorer pipeline opaquely |
| ►CIterQueue | A Queue which can be pulled by iterating |
| CBuilder | Adapter for use as opaque sequence |
| ►CIterSource | Iteration source interface to abstract a data source, which then can be accessed through IterAdapter as a frontend, allowing to pull individual elements until exhaustion |
| Citerator | |
| CIterStack | A Stack which can be popped by iterating |
| CIterStateCore | Adapter to dress up an existing »Lumiera Forward Iterator« as »state core« |
| CIterStateWrapper | Another Lumiera Forward Iterator building block, based on incorporating a state type as »*State Core*«, right into the iterator |
| CIterTool | Standard functionality to build up any iterator tool |
| CIterType | Helper for type rewritings: get the element type for an iterator like entity |
| ►CIterType< Iter< TY, CON > > | |
| CSimilarIter | < rebind to a similarly structured Iterator with value type T2 |
| ►CIterType< RangeIter< IT > > | |
| CSimilarIter | < rebind to rewritten Iterator wrapped into RangeIter |
| ►CLazyInit | Mix-in for lazy/delayed initialisation of an embedded functor |
| CMarkDisabled | |
| CLimited | A Result Value confined into fixed bounds |
| ►CLinkedElements | Intrusive single linked list, possibly taking ownership of node elements |
| CIterationState | Iteration is just following the single linked list |
| CLiteral | Inline string literal This is a marker type to indicate that |
| CNobugResourceHandleContext | Disabled placeholder for the Diagnostic context, not used in release builds |
| CNoInstantiationCount | Policy: no additional instantiation accounting |
| CNullValue | Singleton holder for NIL or default value objects |
| CNumIter | Enumerate all "numbers" within a range |
| COpaqueHolder | Inline buffer to hold and own an object while concealing the concrete type |
| COptionalRef | Optional or switchable link to an existing object |
| CP | Customised refcounting smart pointer template, built upon std::shared_ptr, but forwarding type relationships and ordering operators to the pointee objects |
| ►CPathArray | Abstraction for path-like topological coordinates |
| CSplit | |
| CPlantingHandle | A handle to allow for safe »remote implantation« of an unknown subclass into a given opaque InPlaceBuffer, without having to disclose the concrete buffer type or size |
| ►CPolymorphicValue | Template to build polymorphic value objects |
| CAdapter | Implementation Helper: add support for copy operations |
| CPtrDerefIter | Wrapper for an existing Iterator type, automatically dereferencing the output of the former |
| CQueryText | Syntactical query representation |
| CRandomDraw | A component and builder to draw limited parameter values based on some source of randomness (or hash input) |
| ►CRandomSequencer | Access point to a selection of random number sources |
| CSeed | |
| CRangeIter | Accessing a STL element range through a Lumiera forward iterator, An instance of this iterator adapter is completely self-contained and allows to iterate once over the range of elements, until pos==end |
| CRefArray | Abstraction: Array of const references |
| CRefArrayTable | RefArray implementation based on a fixed size array, i.e |
| CRefArrayVector | This variation of the wrapper actually is a vector, but can act as a RefArray |
| CRefArrayVectorWrapper | Wrap a vector holding objects of a subtype and provide array-like access using the interface type |
| CResult | Representation of the result of some operation, EITHER a value or a failure |
| CResult< void > | The base case is just to capture success or failure, without returning any value result |
| ►CScopedCollection | A fixed collection of non-copyable polymorphic objects |
| CElementHolder | Storage Frame to hold one Child object |
| CFillAll | |
| CFillWith | Fills the ScopedCollection with default constructed I-instances |
| CPullFrom | Fills the ScopedCollection with default constructed TY-instances |
| CScopedHolder | Inline buffer holding and owning an object similar to unique_ptr |
| CScopedPtrHolder | Extension to std::unique_ptr, allowing copy operations on empty pointers (i.e |
| CScopedPtrVect | Simple vector based collection of pointers, managing lifecycle of the pointed-to objects |
| CSearchPathSplitter | Helper: Access a path Specification as a sequence of filesystem Paths |
| CSeedNucleus | Establishes a seed point for any instance or performance |
| CSeveral | Abstraction: Fixed array of elements |
| CSeveralBuilder | Builder to create and populate a lib::Several<I> |
| CSimpleAllocator | Frontend for explicit allocations, using a custom allocator |
| CSingleValCore | Implementation of a singleton value holder, which discards the contained value once "iterated" |
| CSingleValIter | Pseudo-Iterator to yield just a single value |
| CSkipRepetition | Helper: predicate returning true whenever the argument value changes during a sequence of invocations |
| CStorageFrame | Individual storage frame in a chain, holding a data tuple |
| CStorageLoc | Linked list of StorageFrame elements |
| CSubID | |
| CSubId | |
| CSymbol | Token or Atom with distinct identity |
| CSymbolTable | Table for automatically interned strings |
| ►CSync | Facility for monitor object based locking |
| CLock | Scoped guard to control the actual locking |
| CSyncBarrier | A one time N-fold mutual synchronisation barrier |
| CThread | A thin convenience wrapper to simplify thread-handling |
| CThreadHookable | Extended variant of the standard case, allowing to install callbacks (hook functions) to be invoked during thread lifecycle: |
| CThreadJoinable | Variant of the standard case, requiring to wait and join() on the termination of this thread |
| CTransformingCore | Implementation of custom processing logic |
| CTransformIter | Iterator tool treating pulled data by a custom transformation (function) |
| CTrojanFun | »Trojan Function« builder |
| ►CTypedAllocationManager | Foundation for a custom allocation manager, tracking the created objects by smart-ptrs |
| CKiller | Opaque link to the manager, to be used by handles and smart-ptrs to trigger preconfigured destruction |
| CSlot | Token representing a newly opened slot capable for holding an object of type XOX |
| ►CTypedContext | Provide type-IDs for a specific context |
| CID | Type-ID |
| CTypedCounter | Utility providing a set of counters, each tied to a specific type |
| CUninitialisedDynBlock | Managed uninitialised Heap-allocated storage with array like access |
| CUninitialisedStorage | Block of raw uninitialised storage with array like access |
| CUniqueMallocOwner | Ownership token for a piece of heap memory allocated in plain-C style |
| CUseInstantiationCounting | Policy: maintain explicit per type instance count |
| ►CVariant | Typesafe union record |
| CBuff | Concrete inner capsule specialised for a given type |
| CBuffer | Inner capsule managing the contained object (interface) |
| CPredicate | |
| CRenderer | |
| CVisitor | To be implemented by the client for visitation |
| CVariantO | A variant wrapper (typesafe union) capable of holding a value of any of a bounded collection of types |
| CVerbHolder | |
| CVerbHolder< REC, RET(ARGS...)> | Building block: actual storage for a "verb" (function pointer), together with the pre-bound invocation arguments for this specific operation |
| CVerbInvoker | Building block: the Interface to cause the invocation |
| ►CVerbPack | A self-contained token to embody a specific yet abstracted operation, together with a concrete set of suitable arguments |
| CHandlerTypeDetector | |
| CHandlerTypeDetector< RET(REC::*)(ARGS...)> | |
| CVerbToken | Action token implemented by double dispatch to a handler function, as defined in the "receiver" interface (parameter REC) |
| CVerbToken< REC, RET(ARGS...)> | |
| CWrappedLumieraIter | Standard implementation of the IterSource interface: a wrapped "Lumiera Forward Iterator" |
| CZombieCheck | Automatic lifecycle tracker, to produce an alarm when accessing objects after deletion |
| ►Nlumiera | Lumiera public interface |
| ►Nadvice | |
| ►Nanonymous_namespace{advice.cpp} | |
| CAdviceSystem | System-wide service to support the implementation of advice collaborations |
| ►Nanonymous_namespace{index.hpp} | |
| CSelfCheckFailure | |
| ►Ntest | |
| ►Nanonymous_namespace{advice-basics-test.cpp} | |
| CTheAdvised | |
| CTheAdvisor | |
| ►Nanonymous_namespace{advice-binding-pattern-test.cpp} | |
| CDummyAdvice | |
| ►Nanonymous_namespace{advice-index-test.cpp} | |
| CTestPOA | Test dummy record, representing either a provision or an request |
| CAdviceBasics_test | |
| CAdviceBindingPattern_test | |
| CAdviceConfiguration_test | |
| CAdviceIndex_test | |
| CAdviceMultiplicity_test | |
| CAdviceSituations_test | |
| CActiveProvision | Piece of Advice as incorporated into the AdviceSystem |
| CAdviceLink | Advice Collaboration partner, internally connected to the AdviceSystem |
| ►CBinding | Conjunction of predicates to be matched against a collaboration partner for establishing an Advice connection |
| CAtom | Single predicate as part of an advice binding pattern |
| CMatcher | Functor object for matching against another Binding |
| ►CIndex | Index datastructure for organising advice solutions |
| CCluster | |
| CEntry | |
| CProvisionCluster | |
| CRequestCluster | |
| CPointOfAdvice | Basic (abstracted) view of an advice collaboration partner, as used internally by the AdviceSystem to manage the participants |
| CProvision | Access point for the advising entity (server) |
| CRequest | Access point for the advised entity (client) |
| ►Nerror | |
| CLumieraError | Derived specific exceptions within Lumiera's exception hierarchy |
| ►Nfacade | |
| CBinding | Implementation Base for building Facade Proxy implementations |
| CBinding< InstanceHandle< I, FA > > | |
| CLink | |
| CLink< I, I > | |
| CProxy | To be specialised and implemented for each individual interface and facade interface |
| CProxy< IHandle > | |
| ►Nquery | |
| ►Nimpl | |
| ►CDefsRegistry | |
| CIter | Used for enumerating solutions |
| ►CRecord | Holding a single "default object" entry |
| CSearch | < Functor searching for a specific object |
| CSlot | Every new kind of object (Type) creates a new slot in the main Table holding all registered default objects |
| CTableEntry | |
| ►Ntest | |
| ►Nanonymous_namespace{defs-registry-impl-test.cpp} | |
| CDummy | Template for generating some different test types |
| CDefsRegistryImpl_test | |
| CConfigRules | Generic query interface for retrieving objects matching some capability query |
| CDefsManager | Organise a collection of preconfigured default objects |
| CPred | |
| CQueryHandler | "front side" interface: the Steam-Layer code can use this QueryHandler to retrieve instances of the type TY fulfilling the given Query |
| CResolver | |
| CTypeHandler | "back side" interface towards the classes participating in the configuration system (the config system will be delivering instances of these classes for a given query) |
| CTypeHandlerXX | Adapter for using this type as a primary type within Lumiera's Steam-Layer |
| CTypeHandlerXX< steam::mobject::session::test::DummyEntity > | Adapter for using mobject::session::test::DummyEntity as a primary type with the TypedID registration service |
| ►Ntest | |
| ►Nanonymous_namespace{query-resolver-test.cpp} | |
| CDummyResultSet | Concrete "resolution" of the query is a set of "solutions", which can be explored by iteration |
| CDummySolutions | Sequence of "solutions" to be "found" |
| CDummySolutions< int > | |
| CDummySolutions< string > | |
| CDummyTypedSolutionProducer | (dummy) concrete query resolution facility |
| ►Nanonymous_namespace{subsystem-runner-test.cpp} | |
| CMockSys | A simulated "Lumiera Subsystem" |
| CAppconfig_test | |
| ►CExceptionError_test | Some aspects of C++ exception handling |
| CSpecificError | Very specific Exception class local to this scope and with additional behaviour |
| CHelloBug_test | |
| CHelloWorld_test | Hellooooooo the world is just a test |
| CLifeCycle_test | |
| CQueryResolver_test | |
| CSubsystemRunner_test | |
| ►Nvisitor_concept_draft | |
| ►Ntest | |
| CBabbler | |
| CBigBoss | |
| CBoss | |
| CHomoSapiens | |
| CLeader | |
| CVerboseVisitor | |
| CVisionary | |
| CVisitingTool_concept | |
| CApplicable | Any concrete visiting tool implementation has to inherit from this class for each kind of calls it wants to get dispatched, Allowing us to record the type information |
| CDispatcher | For each possible call entry point via some subclass of the visitable hierarchy, we maintain a dispatcher table to keep track of all concrete tool implementations able to receive and process calls on objects of this subclass |
| CTag | |
| CTagTypeRegistry | |
| CTool | Marker interface "visiting tool" |
| CToolType | Mixin for attaching a type tag to the concrete tool implementation |
| CVisitable | Marker interface "visitable object" |
| CAppState | The Lumiera Application state and basic initialisation |
| CBasicSetup | Represents the elementary self-configuration of a running Lumiera application instance |
| CConfig | C++ wrapper for convenient access to the Lumiera config system |
| ►CDisplay | Interface for outputting frames to an (already allocated) viewer or display |
| CSink | Functor for pushing frames to the display |
| ►CDummyPlayer | Experimental Interface Steam-Layer (or maybe the vault?): Global access point for starting a dummy playback, generating some test image data for the GUI to display in a viewer window |
| CProcess | Playback process, front-end to be used by client code |
| CProcessImplementationLink | Mediator to allow the client to communicate with the Process implementation via the Process handle, without having to map each implementation-level function into the dummy player interface |
| CError | Interface and Base definition for all Lumiera Exceptions |
| CFrameID | Identification tuple for addressing frames unambiguously |
| ►CGoal | Query ABC: unspecific goal for resolution or retrieval |
| CQueryID | |
| CResult | Single Solution, possibly part of a result set |
| CInstanceHandle | Handle tracking the registration of an interface, deregistering it on deletion |
| CLifecycleHook | Define and register a callback for a specific lifecycle event |
| CLifecycleRegistry | Registry of callback functions accessible by a label (ID) provided at registration |
| CNodeID | Identification tuple for denoting render nodes unambiguously |
| COption | Frontend for handling the Lumiera application commandline arguments |
| ►CPlay | Interface to the Player subsystem of Lumiera (Steam-Layer) |
| CController | Continuous playback process, which has been hooked up and started with a fixed set of output slots |
| ►CQuery | Generic interface to express a query for specifically typed result elements exposing some capabilities or fulfilling some properties |
| CBuilder | Helper for establishing, reworking and remolding queries |
| CCursor | |
| CQueryDispatcher | PImpl of the generic QueryResolver |
| CQueryKey | Wrapper for indexing and ordering |
| CQueryResolver | Interface: a facility for resolving (some kind of) queries A concrete subclass has the ability to create Resolution instances in response to specific queries of some kind, if applicable |
| CResolution | ABC representing the result set of an individual query resolution |
| CSubsys | Dependencies and lifecycle of a partially independent Subsystem of the Application |
| CSubsystemRunner | Implementation helper for managing execution of a collection of subsystems, which may depend on one another and execute in parallel |
| ►NLumieraEnvironment | |
| CLumieraConfigContext | |
| CLumieraEnvironment | |
| CLumieraExeBuilder | |
| CLumieraModuleBuilder | |
| CLumieraPluginBuilder | |
| CWrappedStandardExeBuilder | |
| ►Nstage | Lumiera GTK UI implementation root |
| ►Nanonymous_namespace{gtk-lumiera.cpp} | |
| CGtkLumiera | Implement the necessary steps for actually making the Lumiera UI available |
| ►Nanonymous_namespace{guifacade.cpp} | |
| CGuiSubsysDescriptor | |
| ►Ncontroller | |
| CController | |
| ►Nctrl | Backbone of the Lumiera GTK UI |
| ►Ntest | |
| CStateMapGroupingStorage_test | |
| CActions | A helper class which registers global user actions and populates the main menu and toolbar |
| CApplicationBase | Framework initialisation base |
| CBusTerm | Connection point at the UI-Bus |
| CCoreService | Attachment point to »central services« within the UI-Bus |
| CElemAccessDir | Low-level service to navigate the internals of the Lumiera GTK UI |
| CFacade | A context to hold and manage the implementation of all UI facade interfaces |
| CGlobalCtx | A global circle of top-level UI management facilities |
| CNexus | Central hub of the UI-Bus |
| CNotificationHub | Service to receive and display error, warning and notification messages |
| CPanelLocator | Service to access, locate or place panels within top-level windows Access- and query front-end to the individual panel managers, which are located within the top-level windows |
| CPlaybackController | |
| CStateManager | Interface: handling of persistent interface state |
| CStateMapGroupingStorage | Map storage for captured presentation state information |
| CStateRecorder | Simple map based implementation of the PresentationStateManager interface |
| CUiDispatcher | Helper to dispatch code blocks into the UI event thread for execution |
| CUiManager | The Lumiera UI framework and backbone object |
| CUiState | Store and manage persistent interface state |
| CWindowLocator | A centralised manager of all top level application windows |
| ►Ndialog | Dialog box classes |
| CFrameBox | Building block for a segment within a dialog page |
| CNameChooser | The name chooser dialog is a modal dialog box that prompts the user to choose a string name |
| CNotebook | Helper widget to simplify construction and wiring of a [Notebook] widget |
| CPage | Explicitly named shortcut for the typical dialog page content holder |
| CPreferencesDialog | |
| CRender | A dialog to choose render output format and name |
| ►CTestControl | A complex, tabbed-notebook-style non-modal dialog window, dedicated to development, diagnostics and experimentation |
| CPage1 | Ticket #1099 : perform a dummy round-trip to verify Steam-Stage integration |
| CPage2 | Ticket #1014 : populate the Timeline in the GUI |
| ►Ndraw | Display and drawing helpers and utilities |
| CCairoUtil | |
| ►Nidi | Generic definitions for element ID and access |
| CDescriptor | Generic Component View descriptors |
| CDescriptor< ErrorLogView > | Descriptor for error log display within the UI |
| CDescriptor< test::DummyView > | |
| CDescriptor< TimelineView > | Descriptor for the Timeline UI |
| ►Ninteract | UI interaction control |
| ►Nanonymous_namespace{ui-coord-resolver.cpp} | |
| CPathManipulator | Special UI-Coordinate builder to define the solution path step by step while we recurse down into the reference tree |
| ►Ntest | |
| CCmdContext_test | |
| CUICoord_test | |
| CUICoordResolver_test | |
| CUILocationSolver_test | |
| CViewSpecDSL_test | |
| CAllocSpec | A specification to describe the strategy for allocating (placing, retrieving) a component view |
| ►CCmdContext | Builder to define a binding to relate some entity or place within the UI with a specific from of interaction gesture or context dependent command invocation |
| CResolver | Helper for dynamic command argument resolution |
| CDragRelocateController | Gesture controller for dragging objects within the Timeline display |
| CFocusTracker | Helper to pick up typical focus/activity changes, for the purpose of keeping a coherent system of WorkSite locations and a global "Spot" of activity in sync with spontaneous jumps to some arbitrary widget within the UI |
| ►CGenNodeLocationQuery | Test/Diagnostics: implementation of the LocationQuery-API based on a abstract topological structure given as Record<GenNode> ("GenNode tree") |
| CGenNodeNavigator | Helper to navigate a tree topology represented as GenNode tree |
| CGestureObserver | Collaboration interface for tracking the formation of a gesture |
| CGestureState | Holder for InteractionState dedicated to UI gestures and complex interactions |
| CInactiveObserver | »Null Object« when no gesture is being tracked currently |
| CInteractionDirector | Top-level controller to establish a link between the model and transient user interaction state (focus, current window) |
| CInteractionState | Abstract foundation for context dependent UI interactions |
| CLocationClause | A single location specification to be matched and fulfilled |
| CLocationQuery | Interface to discover a backing structure for the purpose of path navigation and resolution |
| CLocationRule | A rule to determine some location by matching against the UI-tree |
| CLocatorSpec | A specification to describe the desired location of a component view within the Lumiera UI |
| CNavigator | Global cross-cutting navigation within user interface space |
| CSpotLocator | Control and navigate the global centre of activity |
| CSubject | Role-Interface: the Subject of Interaction |
| CTreeStructureNavigator | Interface to locate and move within a tree shaped structure |
| ►CUICoord | Describe a location within the UI through structural/topological coordinates |
| CBuilder | |
| ►CUICoordResolver | Query and mutate UICoord specifications in relation to actual UI topology |
| CResolution | |
| CUILocationSolver | Service to determine the location of an UI component view |
| CViewLocator | Access or allocate a UI component view |
| CWizard | Global cross-cutting navigation in interface space, foundation to implement user assistance and context sensitive help |
| CWorkSite | A clustering of information and bindings, related to a "location" where the user is about to do ongoing editing work |
| CWorkSiteTrail | Establish and manage a history of recent work sites |
| ►Nmodel | The Lumiera GTK-GUI uses a thin proxy layer data model on top of the actual "high-level-model", which lives in the Steam-Layer below |
| ►Ntest | |
| ►Nanonymous_namespace{canvas-hook-test.cpp} | |
| CDummyWidget | |
| ►CFakeCanvas | |
| CAttachment | |
| ►Nanonymous_namespace{view-hook-test.cpp} | |
| CDummyWidget | |
| CFakeCanvas | |
| ►Nanonymous_namespace{w-link-test.cpp} | |
| CDummyWidget | |
| CAbstractTangible_test | |
| CBusTerm_test | |
| CCanvasHook_test | |
| CElementAccess_test | |
| CViewHook_test | |
| CWLink_test | |
| CZoomWindow_test | |
| ►CCanvasHook | Interface to represent _"some presentation layout entity",_ with the ability to place widgets (managed elsewhere) onto it, as well as to relocate those widgets to another position |
| CPos | |
| CCanvasHooked | A widget attached onto a display canvas or similar central presentation context |
| CController | |
| CDisplayMetric | Mix-in interface to allow for concrete CanvasHooked widgets to adapt themselves to the metric currently employed on the canvas |
| ►CElementAccess | Interface: access UI elements by navigating the UI topology |
| CTypeConverter | |
| CExpander | Functor component to support the default implementation of expanding/collapsing |
| CFlashDeco | Decorator for a Gtk::Widget to add a visual flash action |
| CRevealer | Functor component to support the default implementation of revealing an UI-Element |
| CTangible | Interface common to all UI elements of relevance for the Lumiera application |
| CViewHook | Interface to represent _"some presentation layout entity",_ with the ability to attach widgets (managed elsewhere), and to re-establish a different sequence of the widgets (whatever this means) |
| CViewHooked | A widget attached onto a display canvas or similar central presentation context |
| CWidget | |
| CWLink | Managed link to a sigc::trackable UI widget, without taking ownership |
| CZoomMetric | Mix-In to implement the DisplayMetric interface on top of a ZoomWindow component, directly embedded here and thus also accessible downstream |
| CZoomWindow | A component to ensure uniform handling of zoom scale and visible interval on the timeline |
| ►Noutput | Video output implementation |
| CDisplayer | A Displayer is a class which is responsible for rendering an image in some way (ie: Xvideo, GDK, OpenGL etc) |
| CGdkDisplayer | GdkDisplayer is a class which is responsible for rendering a video image via GDK |
| CXvDisplayer | XvDisplayer is a class which is responsible for rendering a video image via XVideo |
| ►Npanel | Docking panel classes |
| CAssetsPanel | |
| CInfoBoxPanel | |
| CPanel | The base class for all dockable panels |
| CTimelinePanel | Dockable panel to hold timeline widget(s) |
| CViewerPanel | A panel to display the video output |
| ►Nsetting | The asset management, configuration and project settings |
| CAssetController | Top level controller for the asset management section in the UI |
| ►Ntest | |
| ►Nanonymous_namespace{test-nexus.cpp} | |
| CSimulatedCommandHandler | Compact diagnostic dummy command handler |
| CSimulatedStateManager | |
| CTestNexus | |
| CZombieNexus | |
| CDummyTab | |
| CDummyView | |
| CDummyWidget | |
| CMockElm | Mock UI element or controller |
| CNexus | Mock UI backbone for unit testing |
| CPlaceholderCommand | Set of stub command operations |
| CTestElementAccess | Mock implementation of the model::ElementAccess interface for testing without actual UI |
| ►Ntimeline | The timeline display and editing operations |
| ►Nanonymous_namespace{body-canvas-widget.cpp} | |
| CAbstractTrackRenderer | |
| CTrackGroundingRenderer | |
| CTrackOverlayRenderer | |
| ►Nanonymous_namespace{clip-widget.cpp} | |
| CClipData | |
| CClipWidget | |
| CDormantClip | A Clip not directly mapped into presentation, yet present as entity within the timeline framework |
| CBodyCanvasWidget | Presentation of the timeline workspace by custom drawing on a canvas |
| CClipDelegate | |
| ►CClipPresenter | A View-Model entity to represent a clip within the timeline-UI |
| CDragRelocateObserver | |
| CDecoration | Configure additional vertical padding for the decorations added through CSS |
| CDisplayEvaluation | Visitor and state holder for a collaborative layout adjustment pass |
| CDisplayFrame | Reference frame to organise the presentation related to a specific Track in the Timeline-GUI |
| CDisplayManager | Interface for coordination of the overall timeline display |
| CDisplayViewHooks | Interface: a compound of anchoring facilities |
| CHeadControlArea | |
| CHeaderPaneWidget | |
| CLayoutElement | |
| CMarkerWidget | |
| CNavigatorWidget | |
| CPatchbayWidget | Header pane control area corresponding to a fork of nested tracks |
| CPipeWidget | |
| CPixSpan | |
| CProfileInterpreter | |
| CRelativeCanvasHook | Special CanvasHook decorator to apply a (dynamic) offset when attaching or moving Widgets on the shared canvas |
| CRulerScale | |
| CRulerTrack | Helper to organise and draw the time or content overview ruler at the top of the timeline track display |
| CRulerWidget | |
| CStaveBracketWidget | Helper widget to handle display of the structure of track nesting in the timeline header pane |
| CTimelineCanvas | |
| CTimelineController | Controller to supervise the timeline display |
| CTimelineGui | Smart-Handle as anchor point for "the UI representation" of a timeline |
| CTimelineLayout | Top-level anchor point for the timeline display (widgets) |
| CTimelinePage | Interface: GUI page holding a timeline display |
| CTimelineWidget | Core timeline display (custom widget) |
| CTimelineWidgetEmpty | Placeholder to show when no actual Timeline is present |
| CTrackBody | Helper to organise and draw the space allocated for a fork of sub-tracks |
| CTrackHeadWidget | Header pane control area corresponding to a Track with nested child Tracks |
| CTrackPresenter | A View-Model entity to represent a timeline track in the UI |
| CTrackProfile | Description of the structure and arrangement of tracks for display in the UI |
| CTransitionWidget | |
| ►Nwidget | Lumiera custom widgets |
| ►Ntimeline | |
| CSelectionListener | SelectionListener is a template class which emits a signal when the value is changed by it's associated time::Control object |
| CTimelineState | TimelineState is a container for the state data for TimelineWidget |
| CTimelineViewWindow | |
| CTimelineZoomScale | |
| CBinWidget | |
| CButtonBar | A modified toolbar widget for use in dialogs |
| ►CElementBoxWidget | A basic building block of the Lumiera UI |
| CConfig | |
| CStrategy | |
| CErrorLogDisplay | Widget to display log and error messages |
| CIDLabel | Widget arrangement to represent an entity for manipulation |
| CMenuButton | A button that displays a menu when clicked on |
| CMiniWrapper | A wrapper for ToolButton-like Button widgets |
| CMixerWidget | |
| CPanelBar | A container widget for widgets to be displayed on GDL panels grips |
| CPlayerWidget | |
| CSwitchboardWidget | |
| CTimeCode | Widget for timecode input and display |
| CVideoDisplayWidget | |
| ►Nworkspace | The global workspace with top-level windows |
| ►CDockArea | A class to manage DockItem objects for WorkspaceWindow |
| CPanel | A helper class that will create PanelDescription objects |
| CPanelDescription | A class to describe and instantiate Panel types |
| ►CPanelManager | A class to manage DockItem objects for WorkspaceWindow |
| CPanel | A helper class that will create PanelDescription objects |
| CPanelDescription | A class to describe and instantiate Panel types |
| CUiStyle | Manage global concerns regarding a coherent user interface |
| CWorkspaceWindow | The main Lumiera workspace window |
| CDisplayerSlot | Actual implementation of a single displayer slot |
| CDisplayService | Actual implementation of the DisplayService |
| CGuiFacade | Global access point for loading and starting up the Lumiera GTK GUI and for controlling the GUI lifecycle |
| CGuiNotification | Global access point to push state update and notification of events from the lower layers into the Lumiera GUI |
| CGuiRunner | Load and start the GUI as a plugin |
| CNotificationService | Actual implementation of the GuiNotification service within the Lumiera GTK GUI |
| CUiBus | Backbone of the Lumiera GTK GUI |
| ►Nstd | STL namespace |
| C__hash_base | |
| C_Hash_impl | |
| C_HashImplementationSelector | |
| C_HashImplementationSelector< TY, std::enable_if_t< lib::meta::provides_BoostHashFunction< TY >::value > > | Specialisation: Bridge from std::hash to boost::hash |
| Cbasic_filebuf | |
| Cchar_traits | |
| Chash | Primary class template for std::hash |
| Chash< S > | |
| Chash< steam::mobject::PlacementMO::ID > | |
| Creference_wrapper | |
| Cshared_ptr | |
| Ctuple_element< I, lib::HeteroData< DATA... > > | Expose the type of the I-th element of a HeteroData chain |
| Ctuple_element< I, lib::HeteroData< lib::meta::NullType > > | |
| Ctuple_element< I, lib::StorageFrame< seg, DATA... > > | Delegate to the type access of a StorageFrame's underlying tuple |
| Ctuple_size< lib::HeteroData< DATA... > > | Determine compile-time fixed size of a HeteroData |
| Ctuple_size< lib::StorageFrame< seg, DATA... > > | Determine compile-time fixed size of a StorageFrame |
| ►Nsteam | Steam-Layer implementation namespace root |
| ►Nasset | The asset subsystem of the Steam-Layer |
| ►Nidi | |
| CStructTraits | |
| CStructTraits< const ProcPatt > | |
| CStructTraits< meta::TimeGrid > | |
| CStructTraits< mobject::session::Clip > | |
| CStructTraits< mobject::session::Fork > | |
| CStructTraits< Pipe > | |
| CStructTraits< Sequence > | |
| CStructTraits< steam::StreamType > | |
| CStructTraits< Timeline > | |
| ►Nmeta | |
| ►Ntest | |
| CTimeGridBasics_test | |
| CBuilder | Building and configuring a meta asset |
| CBuilder< ErrorLog > | |
| CBuilder< TimeGrid > | |
| CDescriptor | Interface: the unspecific, reflective base of meta assets |
| CErrorLog | Receive, collect, filter and possibly persist incident records |
| CSimpleTimeGrid | TimeGrid implementation: a trivial time grid, starting at a given point in time and using a constant grid spacing |
| CTimeGrid | Interface: a grid and scale definition for time quantisation |
| ►Ntest | |
| CAssetCategory_test | |
| CBasicPipe_test | |
| CCompoundMedia_test | Verifying the special operations available for compound media assets comprised of several elementary media assets |
| CCreateAsset_test | |
| CDeleteAsset_test | |
| CDependentAssets_test | |
| CIdentityOfAssets_test | |
| CMakeClip_test | |
| CMediaStructureQuery_test | This test documents the Interface used by MediaFactory when loading media files for querying Lumiera's vault layer for information on how the media file is structured |
| COrderingOfAssets_test | |
| CTestAsset | Test(mock) asset subclass usable for hijacking a given asset class (template parameter) and subsequently accessing internal facilities for writing unit tests |
| ►CAsset | Superinterface describing especially bookkeeping properties |
| CIdent | POD comprised of all the information sufficiently identifying any given Asset |
| CAssetManager | Facade for the Asset subsystem |
| CBuildInstruct | (Interface) building instructions to be executed by the Builder on the render node network under construction |
| CCategory | Tree like classification of Assets |
| CClip | Bookkeeping (Asset) view of a media clip |
| CCodec | Description of some media data decoder or encoder facility |
| CCompoundMedia | Compound of several elementary media tracks, e.g |
| CDataset | Meta asset describing a collection of control data |
| CDB | Implementation of the registry holding all Asset instances known to the Asset Manager subsystem |
| CDoAttach | |
| CDoConditional | |
| CDoRecurse | |
| CEffect | Effect or media processing component |
| CID | Thin wrapper around a size_t hash ID used as primary key for all Asset objects |
| CID< Media > | |
| CID< Meta > | |
| CID< Pipe > | |
| CID< Proc > | |
| CID< Struct > | |
| CIdentityHash | Trivial hash functor returns any hash value unmodified |
| CIDErr | AssetManager error responses, caused by querying invalid Asset IDs from the internal DB |
| CInventory | TypedID registration group exposed as meta asset |
| Cis_pAsset | Type trait for detecting a shared-ptr-to-asset |
| Cis_pAsset< shared_ptr< A > > | |
| CMedia | Key abstraction: media-like assets |
| CMediaFactory | Factory specialised for creating Media Asset objects |
| CMeta | Key abstraction: metadata, parametrisation, customisation and similar organisational traits |
| CMetaFactory | Factory specialised for creating Metadata Asset objects |
| CPipe | Structural asset corresponding to the part of the model forming a processing pipe for generating media output |
| CPreview | Special placeholder denoting an alternative version of the media data, typically with lower resolution ("proxy media") |
| CProc | Key abstraction: data processing asset |
| CProcFactory | Factory specialised for creating Processor Asset objects |
| CProcPatt | "Processing Pattern" is a structural Asset representing information how to build some part of the render engine's processing nodes network |
| CSequence | TODO type comment |
| CStruct | Key abstraction: structural asset Created automatically as a sideeffect of building the structure of the high-level-model (session contents), thus providing IDs for later referral, search and attachment of metadata |
| CStructFactory | Factory specialised for creating Structural Asset objects |
| CStructFactoryImpl | Implementation details, especially concerning how configuration queries are resolved and when to create new objects automatically |
| CTestClipAsset | An asset::Media instance Test Clip for checking various Asset operations and for creating dependent Clip-MObjects |
| CTimeline | |
| ►CTypedID | |
| CLink | Mixin for automatic TypedID registration |
| CUnknown | Placeholder Asset for unknown or unavailable media source |
| CUnknownID | |
| CViewer | TODO type comment |
| CWrongKind | |
| ►Ncmd | |
| ►Ntest | |
| CCommandSetup_test | |
| ►Ncontrol | Steam-Layer dispatcher, controller and administrative facilities |
| ►Nanonymous_namespace{handling-patterns.hpp} | |
| CBasicHandlingPattern | Handling Pattern Foundation: invoke command directly and without any external intervention |
| CInvokeAsync | Handling Pattern: just schedule command to be invoked asynchronously |
| CInvokeSyncNoThrow | Handling Pattern: invoke blocking, translate exceptions into an error state |
| CInvokeSyncThrow | Handling Pattern: invoke blocking, propagating any exceptions immediately |
| ►Nbind_arg | |
| C_Type | |
| C_Type< std::tuple< TYPES... > > | |
| CAcceptAnyBind | |
| CAcceptArgs | |
| CAcceptArgs< TAR, BA, RET, Types< T1 > > | < Accept binding for 1 Argument |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2 > > | < Accept binding for 2 Arguments |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2, T3 > > | < Accept binding for 3 Arguments |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2, T3, T4 > > | < Accept binding for 4 Arguments |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2, T3, T4, T5 > > | < Accept binding for 5 Arguments |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6 > > | < Accept binding for 6 Arguments |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6, T7 > > | < Accept binding for 7 Arguments |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6, T7, T8 > > | < Accept binding for 8 Arguments |
| CAcceptArgs< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | < Accept binding for 9 Arguments |
| CAcceptArgs< TAR, BA, RET, Types<> > | < Accept dummy binding (0 Arguments) |
| CAcceptBind | |
| CAcceptBind< TAR, BA, RET, Types< T1 > > | < Accept binding for 1 Argument |
| CAcceptBind< TAR, BA, RET, Types< T1, T2 > > | < Accept binding for 2 Arguments |
| CAcceptBind< TAR, BA, RET, Types< T1, T2, T3 > > | < Accept binding for 3 Arguments |
| CAcceptBind< TAR, BA, RET, Types< T1, T2, T3, T4 > > | < Accept binding for 4 Arguments |
| CAcceptBind< TAR, BA, RET, Types< T1, T2, T3, T4, T5 > > | < Accept binding for 5 Arguments |
| CAcceptBind< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6 > > | < Accept binding for 6 Arguments |
| CAcceptBind< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6, T7 > > | < Accept binding for 7 Arguments |
| CAcceptBind< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6, T7, T8 > > | < Accept binding for 8 Arguments |
| CAcceptBind< TAR, BA, RET, Types< T1, T2, T3, T4, T5, T6, T7, T8, T9 > > | < Accept binding for 9 Arguments |
| CAcceptBind< TAR, BA, RET, Types<> > | < Accept dummy binding (0 Arguments) |
| CDummy | |
| ►Ncom | |
| C_DefineBindFunc | < Steam-Layer command implementation details |
| CCommandInvoker | |
| CRuntimeCheckedCommandInvoker | |
| ►Nimpl | |
| CCloneContext | < Interface and empty state |
| CClonedContext | |
| ►Nstage | |
| CBasicDefinition | |
| CBuildUndoDefType | Type re-binding helper: create a suitable UndoDefinition type, based on the UndoSignature template instance given as parameter |
| CCompletedDefinition | |
| CUndoDefinition | |
| ►Ntest | |
| ►Nanonymous_namespace{argument-tuple-accept-test.cpp} | |
| C_Tup | |
| CTestClass | |
| ►Nanonymous_namespace{command-argument-test.cpp} | |
| CSint5 | Dummy custom memento datatype |
| CTracker | Watching the instance creation of some parameter values |
| ►Nanonymous_namespace{command-instance-manager-test.cpp} | |
| CFixture | |
| ►Nanonymous_namespace{dispatcher-looper-test.cpp} | |
| CSetup | Setup for testing the Looper |
| ►Nanonymous_namespace{handling-pattern-basics-test.cpp} | |
| CCustomHandler | |
| CArgumentTupleAccept_test | |
| CCommandArgument_test | |
| CCommandBasic_test | |
| CCommandBinding_test | |
| CCommandCloneBuilder_test | |
| CCommandEquality_test | |
| CCommandInstanceManager_test | |
| CCommandMessageBinding_test | |
| CCommandMutation_test | Verify the behaviour of the type erased closure, which is used by Steam-Layer commands to implement the capturing and later re-invocation of a function |
| CCommandQueue_test | |
| CCommandRegistry_test | |
| CCommandUse1_test | |
| CCommandUse2_test | |
| CCommandUse3_test | |
| CDispatcherLooper_test | |
| CHandlingPatternBasics_test | |
| CHandlingPatternStandardImpl_test | |
| CMementoTie_test | |
| CSessionCommandFunction_test | |
| CAcceptAnyBinding | Helper Template for control::Command, mix-in complete set of bind(...) functions |
| CAcceptArgumentBinding | Helper Template for Steam-Layer control::Command : mix in a bind(...) function |
| CAcceptArgumentBindingRet | Variation of AcceptArgumentBinding, allowing to control the return type of the generated bind(...) functions independently from SIG |
| CAcceptArgumentTuple | Helper Template for building a Functor or function-like class: Mix in a function call operator, which mimics the specified signature SIG |
| CArguments | |
| CCmdClosure | Interface |
| CCommand | Handle object representing a single Command instance to be used by client code |
| CCommandDef | Helper class used solely for defining a Command-Object |
| CCommandDispatch | Interface of a service to perform Commands on the session |
| ►CCommandImpl | Steam-Layer Command implementation |
| C_Type | |
| CCommandImplCloneBuilder | Visitor to support creating a CommandImpl clone |
| CCommandInstanceManager | Maintain a current command instance for parametrisation |
| CCommandQueue | Implementation of the Session's command queue |
| CCommandRegistry | Registry managing command implementation objects (Singleton) |
| CCommandSetup | Marker and Helper for writing Steam-Layer Command definitions |
| CCommandSignature | Metaprogramming helper for building Command function signatures |
| CDispatcherLoop | PImpl within SteamDispatcher to implement the Session Loop Thread. During the lifetime of this object.. |
| CExecResult | Result (Status) of command execution |
| CHandlingPattern | Interface: Operation Skeleton how to invoke or undo a command |
| CLooper | Encapsulated control logic for the session thread loop |
| CMediaImplLib | |
| CMementoTie | Binding together state capturing and execution of the undo operation |
| CMutation | Unspecific command functor for implementing Steam-Layer Command |
| COpClosure | Closure to deal with the actual command operation |
| Corder_by_impl | Helper for building a std::map with Command* as keys |
| CParamAccessor | Helper for accessing an individual function parameter |
| CParamAccessor< NullType, TUP, TUP, n > | < used for recursion end of implementation functions |
| CPathManager | While building a render engine, this Strategy class decides on the actual render strategy in accordance to the current controller settings (system state) |
| CSessionCommand | Global access point to invoke commands and cause edit operations within the Session |
| CSessionCommandService | Actual implementation of the SessionCommand service within the Lumiera Session subsystem |
| CSimpleClosure | Dummy / proof-of-concept implementation of CmdClosure |
| CSteamDispatcher | Guard to manage processing commands to operate on the session |
| CStorageHolder | This is "the" top level CmdClosure implementation |
| ►CSTypeManager | |
| CRegistry | |
| CTypedArguments | |
| CUndoMutation | Specialised version of the command Mutation functor, used to implement the UNDO functionality |
| ►CUndoSignature | Type analysis helper template |
| CCase | Case1: defining the Undo-Capture function |
| CCase< void, ARG > | Case2: defining the actual Undo function |
| ►Nengine | Lumiera's render engine core and operational control |
| ►Nanonymous_namespace{node-builder.hpp} | |
| CUseHeapAlloc | |
| ►Nanonymous_namespace{weaving-pattern-builder.hpp} | |
| ►C_ProcFun | Helper to pick up the parameter dimensions from the processing function |
| CMatchBuffArray | |
| CMatchBuffArray< std::array< BUF *, N > > | |
| ►Nconfig | Policies, definitions and tweaks to control the actual setup and behaviour of the render engine, and the way, render nodes are wired and instantiated |
| CAllocBufferTable | |
| CAllocOutput | |
| ►CConfigSelector | Helper for fabricating ProcNode Wiring configurations |
| CFactoryHolder | < impl type erasure |
| CFactoryTableBuilder | Helper: a visitor usable with FlagInfo |
| CFeedCache | |
| ►CInstantiation | Helper template for semi-automatic detection if instantiation is possible |
| CTest | |
| COperationBase | Base class of all concrete invocation sequences |
| CProcessData | |
| CPullInput | |
| CQueryCache | |
| CReadSource | |
| CReleaseBuffers | |
| CSelectBuffProvider | |
| CSelectBuffProvider< Config< CACHING, PROC_ign, INPLA_ign > > | |
| CStrategy | |
| CStrategy< Config< CACHING > > | |
| CStrategy< Config< CACHING, PROCESS, INPLACE_ign > > | |
| CStrategy< Config< INPLACE > > | |
| CStrategy< Config< PROCESS, INPLACE_ign > > | |
| CStrategy< Config<> > | |
| CWiringDescriptorFactory | Fabricating a Connectivity descriptor tailored for a specific node wiring situation |
| CWiringFactoryImpl | |
| ►Ndiagn | |
| CBlock | Helper for implementing a diagnostic BufferProvider: A block of heap allocated storage, with the capability to store some additional tracking information |
| CBlockPool | |
| ►Nmetadata | |
| ►Ntest | |
| ►Nanonymous_namespace{buffer-metadata-key-test.cpp} | |
| CKeyTypeSpecialisationDiagnostics | Helper to investigate the settings stored in Metadata Key elements |
| CPlacedNumbers | Test Mock to verify the attachment of objects to the buffer |
| CBufferMetadataKey_test | |
| CEntry | A complete metadata Entry, based on a Key |
| CKey | Description of a Buffer-"type" |
| CTable | (Hash)Table to store and manage buffer metadata |
| ►Ntest | |
| ►Nanonymous_namespace{mock-dispatcher.cpp} | |
| ►CDummyClosure | MockJob objects are backed by this closure |
| CInvocation | |
| ►Nanonymous_namespace{node-devel-test.cpp} | |
| CBuffer | Uninitialised local storage that can be passed as working buffer and accessed as TestFrame |
| ►Nanonymous_namespace{testframe.cpp} | |
| CDistinctNucleus | |
| CTestFrameTable | |
| CBufferMetadata_test | |
| CBufferProviderProtocol_test | |
| CCalcStream_test | |
| CDispatcherInterface_test | |
| CEngineInterface_test | |
| CFeedManifold_test | |
| CJobHash_test | |
| CJobPlanning_test | |
| CJobPlanningPipeline_test | |
| CMockDispatcher | A mocked frame Dispatcher setup without any backing model |
| CMockJob | Mock setup for a render Job with NO action but built-in diagnostics |
| CMockJobTicket | Mock setup for a JobTicket to generate dummy render Job invocations |
| CMockSegmentation | Mock setup for a complete Segmentation to emulate the structure of the actual fixture, without the need of building a low-level Model |
| CMockSupport_test | |
| CNodeBase_test | |
| CNodeBuilder_test | |
| CNodeDevel_test | |
| CNodeFeed_test | |
| CNodeLink_test | |
| CNodeMeta_test | |
| CNodeOpera_test | |
| CNodeStorage_test | |
| ►CTestFrame | Mock data frame for simulated rendering |
| CMeta | |
| CTestFrame_test | |
| ►CTestRandOntology | A fake Domain Ontology to describe mocked »render operations« on dummy data frames filled with random numbers |
| CSpec | |
| CTimings_test | |
| CTrackingHeapBlockProvider_test | |
| CActualInvocationProcess | The real invocation context state implementation |
| CAllocBufferFromCache | < using the global current StateClosure, which will delegate to Cache |
| CAllocBufferFromParent | < using the parent StateAdapter for buffer allocations |
| CBuffDescr | An opaque descriptor to identify the type and further properties of a data buffer |
| CBufferMetadata | Registry for managing buffer metadata |
| CBufferProvider | Interface: a facility providing and managing working buffers for media calculations |
| CBuffHandle | Handle for a buffer for processing data, abstracting away the actual implementation |
| ►CBuffTable | Tables of buffer handles and corresponding dereferenced buffer pointers |
| CBuilder | |
| CStorage | |
| CStorageChunk | |
| CBuffTableChunk | Obsolete, to be rewritten /////TICKET #826 to be allocated on the stack while evaluating a ProcNode::pull() call |
| ►CBuffTableStorage | Obsolete, to be rewritten /////TICKET #826 |
| CBuffHaXXXX | Just a placeholder to decouple the existing code from the reworked BuffHandle logic |
| CCalcStream | A calculation stream groups and abstracts a series of calculation jobs, delivering frames into the configured OutputSlot in a timely fashion |
| CChannelDescriptor | |
| CCompromise | |
| CConnectivity | Interface: Description of the input and output ports, processing function and predecessor nodes for a given ProcNode |
| CDefaultQoS | |
| CDiagnosticBufferProvider | Helper for unit tests: Buffer provider reference implementation |
| CDirectFunctionInvocation | Typical base configuration for a Weaving-Pattern chain: |
| ►CDispatcher | Internal abstraction: a service within the engine for translating a logical calculation stream (corresponding to a PlayProcess) into a sequence of individual RenderJob entries for calculations and data access |
| CPipeFrameTick | Job-planning Step-1: establish a sequence of frame start times |
| CPipelineBuilder | A Builder wrapper, allowing to build a Job-planning pipeline step by step, while supplying contextual information from the CalcStream |
| CPlanningPipeline | A complete job-planning pipeline: this »Lumiera Forward Iterator« drives the actual job-planning process on-demand |
| CDispatchTable | |
| ►CEngineCtx | |
| CFacilities | |
| CEngineDiagnostics | Render engine diagnostic facility |
| ►CEngineService | A service to schedule series of calculations, delivering the rendered data into an external output sink in a timely fashion |
| CQuality | Quality-of-Service definition for an Render Engine usage |
| CEngineServiceMock | Variant of the render engine, reconfigured for mock operation |
| CExitNode | A top-level point in the render node network where data generation can be driven |
| CFeedManifold | Obsolete, to be rewritten /////TICKET #826 |
| CInChanDescriptor | |
| CInvocation | Invocation context state |
| CJobPlanning | View on the execution planning for a single calculation step |
| ►CJobTicket | Execution plan for pulling a specific exit node |
| CPrerequisite | |
| CProvision | |
| CLinkBuilder | |
| ►CLocalTag | Opaque mark to be used by the BufferProvider implementation |
| COpaqueData | |
| CNodeBuilder | |
| CNodeFactory | Create processing nodes based on given objects of the high-level model |
| CNodeWiring | Actual implementation of the link between nodes, also acting as "track switch" for the execution path chosen while operating the node network for rendering |
| CParamStorageFrame | |
| CPatternData | Recursive functional data structure to collect weaving pattern data and finally to emplace a Turnout instance into the data storage for each port, as specified by preceding builder-API invocations |
| CPatternDataAnchor | Data recursion end: prime the port data storage by reserving appropriate storage to hold all known Turnout elements |
| CPort | |
| CPortBuilder | |
| CPortBuilderRoot | |
| CPriorityQoS | |
| CProcBuilder | |
| CProcID | |
| CProcNode | Key abstraction of the Render Engine: A Data processing Node |
| CProcNode_Obsolete | Key abstraction of the Render Engine: A Data processing Node |
| CProcNodeDiagnostic | |
| CRenderDrive | The active drive to keep the render process going – implemented as a job planning job, that repeatedly triggers itself again for the next planning chunk |
| CRenderEngine | |
| CRenderEnvironment | Abstract definition of the environment hosting a given render activity (CalcStream) |
| CRenderGraph | |
| CRenderInvocation | A concrete JobFunctor with the ability to activate the »Render Node Network« |
| CSimpleFunctionInvocationAdapter | Adapter to handle a simple yet common setup for media processing |
| CSimpleWeavingPattern | Standard implementation for a Weaving Pattern to connect the input and output data feeds (buffers) into a processing function |
| CStateAdapter | Adapter to shield the ProcNode from the actual buffer management, allowing the processing function within ProcNode to use logical buffer IDs |
| CStateClosure_OBSOLETE | Abstraction to access the state of a currently ongoing render/calculation process, as it is tied to the supporting facilities of the vault layer |
| CTrackingHeapBlockProvider | Simple BufferProvider implementation with additional allocation tracking |
| CTurnout | Processing structure to activate a Render Node and produce result data |
| CTurnoutSystem | Communication hub to coordinate and activate the »Render Node Network« performance |
| CTypeHandler | A pair of functors to maintain a datastructure within a buffer |
| CWeavingBuilder | A low-level Builder to prepare and adapt for a specific node invocation |
| CWiringFactory | |
| CWiringSituation | Finding out about a concrete way of wiring up a ProcNode about to be built |
| ►Nexternal | |
| CImplFacadeGAVL | Concrete media lib implementation facade allowing to work with GAVL data frames and types in an implementation agnostic way |
| CLibGavl | |
| ►Nfixture | Fixture and low-level-Model |
| ►Ntest | |
| ►Nanonymous_namespace{fixture-change-detector-test.cpp} | |
| CTestContext | |
| ►Nanonymous_namespace{model-port-registry-test.cpp} | |
| CTestContext | |
| ►Nanonymous_namespace{segmentation-integration-test.cpp} | |
| CTestContext | |
| CFixtureChangeDetector_test | |
| CFixtureSegment_test | |
| CModelPortRegistry_test | |
| CNodeGraphAttachment_test | |
| CSegmentationIntegration_test | |
| CFixture | |
| CFixtureChangeDetector | TODO type comment |
| ►CModelPortRegistry | Management facility for tracking model ports |
| CModelPortDescriptor | ModelPortDescriptor records are used as actual storage within the model port registration table; they are immutable value objects and never exposed to client code directly |
| CNodeGraphAttachment | Binding and access point from a given Segment to access the actual render nodes |
| CSegment | For the purpose of building and rendering, the fixture (for each timeline) is partitioned such that each segment is structurally constant. For each segment there is a RenderGraph (unit of the render engine) which is able to render all ExitNode(s) for this segment |
| CSegmentation | For the purpose of building and rendering, the fixture (for each timeline) is partitioned such that each segment is structurally constant. The Segmentation defines and maintains this partitioning |
| ►Nmobject | Media-Objects, edit operations and high-level session |
| ►Nanonymous_namespace{output-mapping.hpp} | |
| ►C_def | |
| CRebind | |
| CRebind< RET(DEF::*)(PId)> | |
| ►Nbuilder | Namespace of the Builder, transforming high-level into low-level |
| ►Ntest | |
| CBuilderTool_test | |
| CBuildSegment_test | |
| CTestTool | BuilderTool implementation for checking the invocation of the correct treat() function and for accessing the original Placement from within this invocation |
| CApplicable | Declare the concrete types a BuilderTool may receive and treat |
| CApplicableBuilderTargetTypes | Marker used to declare some visiting Tool class to be actually a mobject::builder::BuilderTool and to possibly accept and treat the common selection of types to be handled by any such builder tool |
| CAssembler | This is the actual building facility: provided the correct tools and associations, it serves to build and connect the individual ProcNode objects |
| CBuilderTool | Base class of all BuilderTools, used according to the visitor pattern: each Tool contains the concrete implementation for one task to be done to the various MObject classes |
| CBuildProcessState | |
| CCombiningMould | |
| CConManager | Connection Manager: used to build the connections between render engine nodes if these nodes need to cooperate besides the normal "data pull" operation |
| CInvokeCatchAllFunction | Policy invoking an catch-all function for processing an unknown tool / target pair, effectively enforcing the implementation of a catch-all function onUnknown(BASE&) |
| CMould | Interface: a workbench-like tool used by the builder for wiring up a specific building situation, followed by the application/execution of a single building step |
| CNodeCreatorTool | This Tool implementation plays the central role in the build process: given a MObject from Session, it is able to attach ProcNodes to the render engine under construction such as to reflect the properties of the MObject in the actual render |
| COperationPoint | A point in the render node network under construction |
| CPipeMould | |
| CPNode | |
| CRefPoint | |
| CSegmentationTool | Tool implementation for deriving a partitioning of the current timeline, such that each Segment has a constant configuration |
| CSourceChainMould | |
| CToolFactory | Builder with the necessary, preconfigured tools |
| CWiringMould | |
| CWiringRequest | A statefull value object denoting the wish to establish a link or connection between two entities |
| ►Nsession | Namespace of Session and user visible high-level objects |
| ►Nanonymous_namespace{element-query.hpp} | |
| C_PickRes | |
| C_PickRes< bool(&)(Placement< MO > const &)> | |
| C_PickRes< bool(*)(Placement< MO > const &)> | |
| C_PickRes< function< bool(Placement< MO > const &)> > | |
| ►Nanonymous_namespace{placement-index-query-resolver.cpp} | |
| CUseThisIndex | |
| ►Nanonymous_namespace{placement-index.cpp} | |
| CSelfCheckFailure | |
| ►Nanonymous_namespace{sess-manager-impl.cpp} | |
| CSessionLifecycleDetails | |
| ►Nanonymous_namespace{specific-contents-query.hpp} | |
| C_PickResult | |
| C_PickResult< bool(&)(Placement< MO > const &)> | |
| C_PickResult< bool(*)(Placement< MO > const &)> | |
| C_PickResult< function< bool(Placement< MO > const &)> > | |
| ►Nquery | |
| ►Nanonymous_namespace{fake-configrules.hpp} | |
| CWrapReturn | Traits-class to define the smart-ptr to wrap the result |
| CWrapReturn< ProcPatt > | |
| CLookupPreconfigured | Building block providing the mock implementation for a single type |
| CMockConfigRules | Facade: Dummy Implementation of the query interface |
| CMockTable | Actual table holding preconfigured answers packaged as boost::any objects |
| ►Ntest | |
| ►Nanonymous_namespace{session-element-tracker-test.cpp} | |
| CDummy | Test Dummy: to be created through the inherited static create(), managed by smart-ptr |
| ►Nanonymous_namespace{session-service-access-test.cpp} | |
| CInternalAPI_1 | |
| CInternalAPI_2 | |
| CTServiceAccessPoint | |
| CTServiceAccessPoint< InternalAPI_1, IMPL > | |
| CTServiceAccessPoint< InternalAPI_2, IMPL > | |
| CTSession | |
| CTSessionImpl | |
| CTSessionServices | |
| CTSessManager | |
| CTSessManagerImpl | |
| CAddClip_test | |
| CDefsManager_test | |
| CDefsManagerImpl_test | |
| CDeleteClip_test | |
| CDummyEntity | |
| CPlacementBasic_test | |
| CPlacementHierarchy_test | |
| CPlacementIndex_test | |
| CPlacementIndexQuery_test | |
| CPlacementRef_test | |
| CPlacementScope_test | |
| CQueryFocus_test | |
| CQueryFocusStack_test | |
| CRebuildFixture_test | |
| CScopePath_test | |
| CScopeQuery_test | |
| CSessionElementQuery_test | |
| CSessionElementTracker_test | |
| CSessionManager_test | Check the session management operations provided by mobject::session::Session This includes accessing the current Session (somewhat a singleton) |
| CSessionModifyParts_test | |
| CSessionServiceAccess_test | Verify the access mechanism both to the pubic session API and to implementation level APIs used by Steam-Layer internals |
| CSessionStructure_test | |
| CTestbed | |
| CTestClip | Sample or Test Clip for checking various model, session and builder operations |
| CTestPlacement | |
| CTimelineSequenceHandling_test | |
| CAbstractMO | Abstract base class of all MObjects for providing common services |
| CAllocation | Interface (abstract): any objective, constraint or wish of placing a MObject in a specific way |
| CAuto | Automation data for some parameter (i.e |
| CBinding | Explicit link to bind a Sequence (container) to be used within the Session, either as contents of a top level Timeline, or as embedded MetaClip |
| CBuildID | Helper for building Placement-ID types |
| CBuildID< Placement< MO, BMO > > | |
| CBusMO | Model entity corresponding to a global pipe |
| CChildExplorer | Strategy: explore the structure just by following the given iterator; usually this yields an element's children |
| CClip | A user visible/editable Clip is a reference to a contiguous sequence of media data loaded as Asset into the current Session |
| CConstraint | LocatingPin representing an directive by the user that must not be violated |
| CContentsQuery | |
| CDeepExplorer | Strategy: explore the structure depth first |
| CDiscoveryQuery | ABC to build Queries for placement-attached objects |
| CDummySessionConnection | Scaffolding to drive the evolution of the Lumiera application |
| CEffect | |
| CElementQuery | Access point to session global search and query functions |
| CExplorer | Interface: strategy for exploring the structure |
| CFixedLocation | The most common case of positioning a MObject in the Session: directly specifying a constant position |
| CFork | A Fork serves as grouping device within the Session |
| CGeneratorMO | A lksjaf |
| CLabel | Any sort of User visible Marker or Tag, used to mark time positions and ranges, or specific locations to attach other MObjects to |
| CLifecycleAdvisor | Skeleton of operations conducting the session lifecycle sequences |
| ►CLocatingPin | Positioning specification, possibly chained to further specifications |
| CLocatingSolution | |
| CMeta | Meta-MObject doesn't represent real Media Content, but rather all sorts of Processing Instructions and other metadata, which can be placed and attached within the Model/Session |
| CMObjectFactory | |
| CPathQuery | |
| ►CPlacementIndex | Structured compound of Placement instances with lookup capabilities |
| ►CTable | Storage and implementation backing the PlacementIndex |
| CPlacementEntry | |
| CValidator | PlacementIndex self-verification code Executes all built-in checks automatically on object creation |
| CPlacementIndexQueryResolver | Wrapper for the PlacementIndex, allowing to resolve scope contents discovery |
| CPlug | LocatingPin for requesting connection to some Pipe |
| CQueryFocus | Current focus location to use as point-of reference for contents and location discovery queries |
| CQueryFocusStack | A custom stack holding ScopePath »frames« |
| CRelativeLocation | |
| CResultSet | On query, an individual result set is prepared to be explored by the invoking client code |
| CRoot | High-level model root element, corresponding to the global session wide scope |
| CScope | A Placement scope within the high-level-model |
| CScopeLocator | Singleton service establishing a link to relate any compound of nested placement scopes to the current session and the current focus for querying and exploring this structure |
| CScopePath | Sequence of nested scopes within the high-level model |
| CScopeQuery | Query a scope to discover it's contents or location |
| CServiceAccessPoint | Access point to a single implementation-level API |
| CServiceAccessPoint< SessionServiceDefaults, IMPL > | |
| ►CServiceAccessPoint< SessionServiceExploreScope, IMPL > | |
| CAccessCurrentIndex | Indirection to use the currently defined index access point (might be a test mock) |
| CServiceAccessPoint< SessionServiceFetch, IMPL > | |
| CServiceAccessPoint< SessionServiceMockIndex, IMPL > | |
| CServiceAccessPoint< SessionServiceMutate, IMPL > | |
| CSessionImpl | Implementation class for the Session interface |
| CSessionInterfaceModules | Collection of implementation components, providing self-contained sub-elements exposed on the public Session API |
| CSessionServiceDefaults | |
| CSessionServiceExploreScope | Implementation-level service for issuing contents/discovery queries |
| CSessionServiceFetch | Implementation-level service for resolving an Placement-ID |
| CSessionServiceMockIndex | There is an implicit PlacementIndex available on a global level, by default implemented within the current session |
| CSessionServiceMutate | Implementation-level service for resolving an Placement-ID |
| CSessionServices | Collection of configured implementation-level services to provide by the Session |
| CSessManager | Creation, access and Session lifecycle Interface |
| CSessManagerImpl | Session manager implementation class holding the actual smart pointer to the current Session impl |
| ►CSpecificContentsQuery | From the session, based on a filter predicate |
| CFilter | Filter functor, built on top of a predicate, which is provided by the client on creation of this SpecivicContentsQuery instance |
| CUpExplorer | Strategy: explore the structure upwards, ascending until reaching the root element |
| CWish | LocatingPin representing a low-priority directive by the user, to be fulfilled only if possible (and after satisfying the more important LocatingPins) |
| ►Ntest | |
| CDummyMO | Test MObject subclass, which, contrary to any real MObject, can be created directly without involving MObjectFactory |
| CMObjectInterface_test | |
| CMObjectRef_test | |
| ►COutputMapping_test | |
| CDummyDef | |
| CPlacementObjectIdentity_test | |
| CTestPlacement | |
| CTestPlacement<> | |
| CTestSubMO1 | Subclass-1 is not defined "processible", thus will always be handled as DummyMO.. |
| CTestSubMO2 | Subclass-2 is defined "processible", but we omit the necessary "applicable" definition in TestTool, resulting in an invocation of the error (catch-all) function.. |
| CTestSubMO21 | |
| CAbsoluteSpec | |
| CBuildable | Marker Interface for classes visitable by Builder tools |
| CBuilderFacade | Provides unified access to the builder functionality |
| CExplicitPlacement | Special kind of Placement, where the location of the MObject has been nailed down to a fixed position |
| CIndirectSpec | |
| CInterpolator | Provides the implementation for getting the actual value of a time varying or automated effect/plugin parameter |
| CMObject | MObject is the interface class for all "Media Objects" |
| CModelPort | Handle designating a point within the model, where actually output data can be pulled |
| CMORef | An active (smart-ptr like) external reference to a specifically placed MObject "instance" within the session |
| ►COutputDesignation | Descriptor to denote the desired target of produced media data |
| CTargetSpec | |
| ►COutputMapping | OutputMapping is a facility to resolve output designations |
| CResolver | |
| CParameter | Descriptor and access object for a plugin parameter |
| CParamProvider | A facility to get the actual value of a plugin/effect parameter |
| CPlacement | A refcounting Handle to an MObject of type MO, used to constrain or explicitly specify the location where the MObject is supposed to be within the Session/Model |
| CPlacement< MObject, MObject > | This specialisation forms the root of all placements and defines all of Placement's actual functionality |
| CPlacementRef | Reference tag denoting a placement attached to the session |
| CRelativeSpec | |
| CSession | The (current) Session holds all the user visible content to be edited and manipulated within the Lumiera Application |
| ►Nnode | |
| CDummyImageGenerator | |
| CDummyTick | Tick generating service for a periodic callback, with adjustable frequency |
| CTickService | Tick generating service for a periodic callback, with adjustable frequency |
| ►Nplay | Playback and rendering control subsystem |
| ►Nanonymous_namespace{dummy-player-service.cpp} | |
| CDummyPlayerSubsysDescriptor | Details of how the DummyPlayer service can be started and used as independent "subsystem" within main() |
| ►Nanonymous_namespace{render-configurator.cpp} | |
| CLumieraRenderProcessBuilder | |
| ►Ntest | |
| CDummyPlayConnection | Framework for dummy playback and rendering |
| CDummyPlayConnection_test | |
| COutputSlotProtocol_test | |
| CPlayTestFrames_Strategy | |
| CSimulatedBuilderContext | Helper for dummy render engine: Simulate the result of a build process, without actually running the builder |
| CTimingConstraints_test | |
| CUnimplementedConnection | |
| CDataSink | Denotes an opened connection ready to receive media data for output |
| ►CDiagnosticOutputSlot | Helper for unit tests: Mock output sink |
| COutputFramesLog | Diagnostic facility to verify test data frames written to this Test/Dummy "output" |
| CSimulatedOutputSequences | Special diagnostic connection state implementation, establishing diagnostic output connections for each channel, thus allowing to verify the handling of individual buffers |
| CDummyPlayerService | Actual implementation of the DummyPlayer service |
| CFeed | Rendering data feed, corresponding to a single global pipe and to be delivered into a single OutputSlot |
| COutputDirector | Management of external Output connections |
| COutputManager | Management of external Output connections |
| ►COutputSlot | Interface: Generic output sink |
| CAllocation | |
| CConnection | |
| CConnectionState | Extension point for Implementation |
| ►COutputSlotImplBase | Base for OutputSlot standard implementation |
| CConnectionManager | Maintaining a list of active connections |
| CPlayController | TODO do we still need that?????? Isn't lumiera::Play::Controller already sufficient? |
| CPlayProcess | Playback/Render process within the Lumiera Player |
| CPlayService | Implementation access point: Player subsystem |
| CProcessImpl | Actual implementation of a single (dummy) playback process |
| CProcessTable | |
| CRenderConfigurator | Strategy for configuring the render process |
| CTimings | Generic frame timing specification |
| CTrackingInMemoryBlockSequence | Diagnostic output connection for a single channel, allowing to track generated frames and verify the processing protocol for output buffers |
| ►Ntest | |
| CRenderSegment_test | |
| ►Ntest_format | |
| CStreamTypeBasics_test | |
| CStreamTypeLifecycle_test | |
| CConfigResolver | User-visible Interface to the ConfigRules subsystem |
| CFacade | Global access point for the services implemented by the Steam-Layer |
| CPlayOutSubsysDescriptor | |
| CSessionSubsystem | |
| ►CStreamType | |
| CImplConstraint | Special case of an implementation type being only partially specified Besides requiring some aspect of the implementation type, there is the promise to fill in defaults to build a complete implementation type if necessary |
| ►CImplFacade | A (more or less) concrete implementation type, wired up as a facade providing the basic set of operations |
| CDataBuffer | Placeholder type for the contents of a data buffer |
| CTypeTag | Opaque placeholder (type erasure) for implementation specific type info |
| CPrototype | |
| ►Ntest | |
| ►Nanonymous_namespace{suite.cpp} | |
| CRegistry | Helper to collect and manage the test cases |
| CSuiteSeedNucleus | |
| CLaunch | Helper class for running a collection of tests |
| CLauncher | Interface: generic testcase creating functor |
| CSuite | Enables running a collection of tests |
| CTest | Abstract Base Class for all testcases |
| CTestOption | Support for selecting and configuring testcases via commandline arguments |
| CTestOption_test | Invokes the TestOption parser for various example commandlines |
| ►Ntext_template | |
| CDataSource | |
| CDataSource< MapS > | Data-binding for a Map-of-strings |
| CDataSource< string > | Adapter for the Map-Data-Source to consume a string spec (for testing) |
| ►Nutil | |
| ►Nanonymous_namespace{access-casted-o.hpp} | |
| Ccan_cast | |
| Ccan_cast< SRC &, TAR & > | |
| Ccan_cast< SRC *&, TAR * > | |
| Ccan_cast< SRC *, TAR * > | |
| CEmptyVal | |
| CEmptyVal< X *& > | |
| ChasRTTI | |
| Cuse_conversion | |
| Cuse_dynamic_downcast | |
| Cuse_static_downcast | |
| ►Nanonymous_namespace{access-casted.hpp} | |
| Ccan_dereference | |
| Ccan_downcast | |
| Ccan_take_address | |
| Ccan_use_conversion | |
| Ccan_use_dynamic_downcast | |
| Chas_RTTI | |
| Cif_can_dereference | |
| Cif_can_take_address | |
| Cif_can_use_conversion | |
| Cif_can_use_dynamic_downcast | |
| ►Nanonymous_namespace{format-string.hpp} | |
| C_allow_call | By default we don't allow to treat any types directly by boost::format |
| C_allow_call< char > | |
| C_allow_call< double > | |
| C_allow_call< float > | |
| C_allow_call< int16_t > | |
| C_allow_call< int32_t > | |
| C_allow_call< int64_t > | |
| C_allow_call< long > | |
| C_allow_call< string > | |
| C_allow_call< uchar > | |
| C_allow_call< uint16_t > | |
| C_allow_call< uint32_t > | |
| C_allow_call< uint64_t > | |
| C_allow_call< ulong > | |
| C_is_smart_wrapper | |
| C_is_smart_wrapper< std::shared_ptr< T > > | |
| C_is_smart_wrapper< std::unique_ptr< T, D > > | |
| C_shall_convert_toString | |
| C_shall_format_directly | |
| C_shall_show_smartWrapper | |
| ►Nanonymous_namespace{format-util.hpp} | |
| C_RangeIter | |
| C_RangeIter< IT, lib::meta::enable_if< can_IterForEach< IT > > > | |
| CSeqContainer | |
| CSeqContainer< vector< X >, ELMS... > | |
| ►Nanonymous_namespace{util-coll.hpp} | |
| Ccan_direct_access_Last | |
| Ctreat_as_LumieraIterator | |
| Ctreat_as_STL_Container | |
| ►Ntest | |
| ►Nanonymous_namespace{access-casted-test.cpp} | |
| CB | |
| CD | |
| CE | |
| CF | |
| CX | |
| ►Nanonymous_namespace{format-cout-test.cpp} | |
| CReticent | Opaque class without string conversion |
| ►Nanonymous_namespace{format-helper-test.cpp} | |
| CAutoCounter | |
| CReticent | |
| CUnReticent | |
| CAccessCasted_test | |
| CFormatCOUT_test | |
| CFormatHelper_test | |
| ►CFormatString_test | |
| CExplosive | |
| CSilent | |
| CVerbose | |
| CIosSavepoint_test | |
| CRational_test | |
| CRemoveFromSet_test | |
| CUtilCollection_test | |
| CUtilFloordiv_test | |
| CUtilFloorwrap_test | |
| ►CUtilForeach_test | |
| CDummy | |
| CTestElm | |
| ►CUtilIdentity_test | |
| CBoo | Dummy entity to compare |
| CSuBoo | |
| CUtilParseBool_test | |
| CUtilSanitizedIdentifier_test | |
| CUtilTuple_test | |
| ►C_Fmt | A front-end for using printf-style formatting |
| CConverter | Helper to prepare parameters for inclusion |
| CConverter< bool > | |
| CConverter< const char * > | |
| CConverter< lib::Literal > | |
| CConverter< lib::Symbol > | |
| CConverter< SP, lib::meta::enable_if< _shall_show_smartWrapper< SP > > > | |
| CConverter< VAL * > | |
| CConverter< VAL, lib::meta::enable_if< _shall_convert_toString< VAL > > > | Some custom types explicitly provide a string representation |
| CConverter< VAL, lib::meta::enable_if< _shall_format_directly< VAL > > > | Some basic types are directly forwarded down to the implementation; |
| CConverter< void * > | |
| CAccessCasted | Helper template to access a given value, possibly converted or casted in a safe way |
| CAccessCasted_O | |
| CCloneable | Types marked with this mix-in may be duplicated by copy-construction, yet may not be moved or transferred any further after creation |
| CIDiv | Helper to treat int or long division uniformly |
| CIDiv< int > | |
| CIDiv< llong > | |
| CIDiv< long > | |
| CIosSavepoint | RAII helper to capture and restore output stream format settings |
| CMoveAssign | Types marked with this mix-in may be moved and move-assigned |
| CMoveOnly | Types marked with this mix-in may be moved but not copied |
| CNoInstance | Not meant to be instantiated in any way |
| CNonAssign | Types marked with this mix-in may be created and moved liberally at construction, while any further assignment to object instances is prohibited thereafter |
| CNonCopyable | Any copy and copy construction prohibited |
| CNullAccessor | |
| CRegexSearchIter | Wrapped regex iterator to allow usage in foreach loops |
| CStringConv | Failsafe invocation of custom string conversion |
| CStringConv< bool > | |
| CStringConv< double > | Explicit specialisation to control precision of double values |
| CStringConv< float > | |
| CStringConv< fs::path, void > | Specialisation: render filesystem path as double quoted string |
| CStringConv< lib::meta::Num< i > > | |
| CStringConv< lib::time::FSecs, void > | Specialisation: render fractional seconds (for diagnostics) |
| CStringConv< SP, show_SmartPointer< SP > > | |
| CStringConv< std::tuple< TYPES... > > | |
| CStringConv< X *, lib::meta::disable_if< std::__or_< std::is_same< std::remove_cv_t< X >, char >, std::is_same< std::remove_cv_t< X >, void > > > > | Specialisation to allow rendering pointers to string-convertible types |
| CStringConv< X, enable_LexicalConversion< X > > | |
| CStringConv< X, lib::meta::enable_CustomStringConversion< X > > | |
| ►Nvault | Vault-Layer implementation namespace root |
| ►Ngear | Active working gear and plumbing |
| ►Nactivity | |
| CHook | Extension point to invoke a callback from Activity activation |
| CInstant | < special definitions for the Scheduler activity language |
| CTerm | A Term of the »Activity Language«, describing the steps necessary to perform the calculation of a single frame or similar tasks |
| ►NblockFlow | |
| CDefaultConfig | Lightweight yet safe parametrisation of memory management |
| ►CEpoch | Allocation Extent holding scheduler Activities to be performed altogether before a common deadline. Other than the underlying raw Extent, the Epoch maintains a deadline time and keeps track of storage slots already claimed |
| CEpochGate | Specifically rigged GATE Activity, used for managing Epoch metadata |
| CRenderConfig | Parametrisation tuned for Render Engine performance |
| CStrategy | Policy template to mix into the BlockFlow allocator, providing the parametrisation for self-regulation |
| ►Ntest | |
| ►Nbench | |
| ►CBreakingPoint | Specific stress test scheme to determine the »breaking point« where the Scheduler starts to slip |
| CRes | |
| ►CLoadPeak_ParamRange_Evaluation | Mix-in for setup of a #ParameterRange evaluation to watch the processing of a single load peak, using the number of added job as independent parameter |
| CDataRow | |
| CParameterRange | Specific test scheme to perform a Scheduler setup over a given control parameter range to determine correlations |
| ►CActivityDetector | Diagnostic context to record and evaluate activations within the Scheduler |
| C_DiagnosticFun | |
| CActivityProbe | A rigged CALLBACK-Activity to watch passing of activations |
| CDiagnosticFun | A Mock functor, logging all invocations into the EventLog |
| CFakeExecutionCtx | Mock setup of the execution context for Activity activation |
| CMockJobFunctor | A Mocked job operation to detect any actual invocation |
| CActivityDetector_test | |
| CActivityMatch | |
| CBlockFlow_test | |
| CChainFunctor | Baseclass: JobFunctor to invoke TestChainLoad |
| CComputationalLoad | A calibratable CPU load to be invoked from a node job functor |
| CIndicator | Distribution indicators for one kind of evaluation |
| CLevelWeight | |
| CRandomChainCalcFunctor | Render JobFunctor to invoke the calculation of a single Node |
| CRandomChainPlanFunctor | Render JobFunctor to perform chunk wise planning of Node jobs to calculate a complete Chain-Load graph step by step |
| CSchedulerActivity_test | |
| CSchedulerCommutator_test | |
| CSchedulerInterface_test | |
| CSchedulerInvocation_test | |
| CSchedulerLoadControl_test | |
| CSchedulerService_test | |
| CSchedulerStress_test | |
| CSchedulerUsage_test | |
| CSpecialJobFun_test | |
| CStatistic | Statistic data calculated for a given chain-load topology |
| CStatKey | |
| ►CStressTestRig | Configurable template framework for running Scheduler Stress tests Use to build a custom setup class, which is then injected to perform a specific measurement tool. Several tools and detailed customisations are available in namespace bench |
| CLauncher | |
| ►CTestChainLoad | A Generator for synthetic Render Jobs for Scheduler load testing |
| ►CNode | Graph Data structure |
| CTab | Table with connections to other Node records |
| ►CNodeControlBinding | Policy/Binding for generation of random parameters by »drawing« based on the node-hash |
| CAdaptor | Adaptor to handle further mapping functions |
| CAdaptor< RES(double)> | Rules may also build solely on the (guessed) height |
| CAdaptor< RES(size_t)> | Allow simple rules directly manipulating the hash value |
| CAdaptor< RES(size_t, double)> | Allow rules additionally involving the height of the graph, which also represents time |
| CScheduleCtx | Setup and wiring for a test run to schedule a computation structure as defined by this TestChainLoad instance |
| CTestChainLoad_test | |
| CWorkForce_test | |
| ►Nwork | |
| CConfig | Base for configuration of the worker pool |
| CWorker | Individual worker thread: repeatedly pulls the doWork functor |
| CActivationEvent | |
| ►CActivity | Record to describe an Activity, to happen within the Scheduler's control flow |
| CArgumentData | Storage of Argument data dependent on Activity::verb_ |
| CCallback | Extension point to invoke |
| CCondition | Access gate condition to evaluate |
| CFeed | Payload data to provide |
| CInvocation | External work functor to activate |
| CNotification | Notification towards another Activity |
| CTimeWindow | Time window to define for activation |
| CTiming | Timing observation to propagate |
| CActivityLang | Term builder and execution framework to perform chains of scheduler Activities |
| ►CBlockFlow | Allocation scheme for the Scheduler, based on Epoch(s) |
| CAllocatorHandle | Local handle to allow allocating a collection of Activities, all sharing a common deadline |
| CStorageAdaptor | Adapt the access to the raw storage to present the Extents as Epoch; also caches the address resolution for performance reasons (+20%) |
| CEngineConfig | Point of access for any kind of engine configuration, setup and performance tweaks |
| ►CEngineEvent | Low-level Render Engine event — abstracted storage base |
| CPayload | |
| CEngineObserver | Collector and aggregator for performance data |
| CFlowDiagnostic | |
| CJob | Individual frame rendering task, forwarding to a closure |
| CJobClosure | Interface of the closure for frame rendering jobs |
| CJobFunctor | |
| ►CLoadController | Controller to coordinate resource usage related to the Scheduler |
| CWiring | |
| CManifestationID | Marker for current (and obsolete) manifestations of a CalcStream processed by the Render-Engine |
| CNopJobFunctor | Stub/Test implementation of the JobFunctor interface for a render job to do nothing at all |
| ►CScheduler | »Scheduler-Service« : coordinate render activities |
| CExecutionCtx | |
| CSetup | Binding of worker callbacks to the scheduler implementation |
| ►CSchedulerCommutator | Scheduler Layer-2 : execution of Scheduler Activities |
| CScopedGroomingGuard | |
| CWorkerInstruction | Monad-like step sequence: perform sequence of steps, as long as the result remains activity::PASS |
| CSchedulerDiagnostics | Render engine diagnostic facility |
| ►CSchedulerFrontend | Access point to the scheduler service provided by the back-end |
| CJobTransaction | Definition context for jobs to be scheduled |
| CSchedulerInvocation | Scheduler Layer-1 : time based dispatch |
| CScheduleSpec | |
| CSpecialFunPrototype | Interface: JobFunctor configured to invoke a function a limited number of times |
| ►CSpecialJobFun | Front-end to configure a special job functor for one-time use |
| CSpecialExecutor | |
| CWorkForce | Pool of worker threads for rendering |
| CWorkTiming | Work-timing event for performance observation |
| ►Nmem | Memory Management |
| ►Ntest | |
| CExtentFamily_test | |
| CExtentDiagnostic | |
| ►CExtentFamily | Memory manager to provide a sequence of Extents for cyclic usage |
| CExtent | Logical structure of a memory Extent |
| CIdxLink | Iteration »State Core« based on Extents index position |
| CStorage | Entry in the Extents management datastructure |
| ►Ntest | |
| ►Nanonymous_namespace{media-access-mock.cpp} | |
| CResponse | |
| CTestCases | |
| CMediaAccessMock | Mock implementation of the MediaAccessFacade |
| CMediaAccessMock_test | |
| CChanDesc | Description of one channel found in a media file; result of querying the channel |
| CEngineFacade | Interface to the vault layer (render engine subsystem): Global access point for starting the render engine subsystem and for defining the public interface(s) for talking with the engine |
| CEngineSubsysDescriptor | |
| CMediaAccessFacade | Interface to the vault layer: provides functions for querying (opening) a media file, detecting the channels or streams found within this file etc |
| CMediaDesc | Descriptor holding the global information record required for further handling this kind of media within Lumiera |
| CNetNodeFacade | Interface to the vault layer (renderfarm node): Global access point for starting a server listening on a TCP port and accepting render tasks |
| CNetNodeSubsysDescriptor | |
| CRealClock | Convenience frontend to access the current raw system time |
| CScriptRunnerFacade | Interface to the vault layer (TODO 2018 really?) (script runner): Global access point for starting a script within Lumiera application context |
| CScriptRunnerSubsysDescriptor | |
| CDataSource | Binding to a specific data source |
| CExamplePlugin | |
| CExamplePlugin_de | |
| CExamplePlugin_en | |
| CInvocationInstanceID | Opaque ID attached to each individual job invocation |
| CInvocationInstanceID.code | |
| CInvocationInstanceID.part | |
| Cllist | |
| Clumiera_config | |
| Clumiera_config_lookup | Just contains a hashtable to give sufficient abstraction |
| Clumiera_config_lookupentry | |
| Clumiera_configentry | |
| Clumiera_configitem | |
| Clumiera_configitem_vtable | |
| Clumiera_displaySlot | |
| Clumiera_errorcontext | Holding error and some context data |
| Clumiera_interface | Header for an interface, just the absolute necessary metadata |
| Clumiera_interfacenode | Interface management node |
| Clumiera_interfaceslot | This is just a placeholder for an entry in a interface table |
| Clumiera_jobDefinition | Complete definition of an individual job |
| Clumiera_jobDescriptor | Description of a job |
| Clumiera_jobParameter | Invocation parameter for the individual frame calculation job |
| Clumiera_mutex | Mutex |
| Clumiera_playprocess | |
| Clumiera_plugin | |
| Clumiera_plugintype | Record the extension and a callback function for loading the associated plugin for each plugin type |
| Clumiera_recmutex | Recursive Mutex |
| Clumiera_tmpbuf_struct | |
| CLumieraJobClosure | Closure representing the execution context of a job |
| CLumieraSectionlock | Sectionlock used to manage the state of mutexes |
| Cpsplay | Type and handle for a psplay root structure This structure shall be treated opaque, its only defined in the header to allow one to integrate it directly instead referencing it |
| Cpsplaynode | Type and handle for a psplay tree node This node have to be placed inside users data |
| Cpsplaytrail | |
| CRsvgSizeCallbackData | |
| CRsvgSourceRectangle | |
| CTestItem | |
| ►CTextTemplate | Text template substitution engine |
| CAction | |
| CActionCompiler | |
| CInstanceCore | Iterator »State Core« to process the template instantiation |
| CParseCtx |
1.8.13