ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean-up: successfully replaced the old fixed type sequence (closes: #987)

Browse source 
This resolves an intricate problem related to metaprogramming with
variadic templates and function signatures. Due to exceptional complexity,
a direct solution was blocked for several years, and required a better
organisation of the support code involved; several workarounds were
developed, gradually leading to a transition path, which could now
be completed in an focused clean-up effort over the last week.

Metaprogramming with sequences of types is organised into three layers:
- simple tasks can be solved with the standard facilities of the language,
  using pattern match with variadic template specialisations
- the ''type-sequence'' construct `Types<T...>` takes the centre stage
  for the explicit definition of collections of types; it can be re-bound
  to other variadic templates and supports simple direct manipulation
- for more elaborate and advanced processing tasks, a ''Loki-style type list''
  can be obtained from a type-sequence, allowing to perform recursive
  list processing task with a technique similar to LISP.
This commit is contained in:
Fischlurch 2025-06-07 18:04:59 +02:00
parent acc77654d1
commit 20392eee1c
54 changed files with 422 additions and 1181 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
doc/technical/howto/crackNuts.txt
View file

@ -182,8 +182,7 @@ pick and manipulate individually::
- see 'variadic-argument-picker-test.cpp' - see 'variadic-argument-picker-test.cpp'
- but sometimes it is easier to use the tried and true technique of the Loki-Typelists, which - but sometimes it is easier to use the tried and true technique of the Loki-Typelists, which
can be programmed recursively, similar to LISP. The »bridge« is to unpack the variadic argument pack can be programmed recursively, similar to LISP. The »bridge« is to unpack the variadic argument pack
into the `lib::meta::Types<ARGS...>` ([yellow-background]#⚠ still broken in 2024# into the `lib::meta::Types<ARGS...>`
see https://issues.lumiera.org/ticket/987[#987], use `lib::meta::TySeq` from 'meta/typelist.hpp' as workaround...)
+ +
apply functor to each tuple element:: apply functor to each tuple element::
A common trick is to use `std::apply` in combination with a _fold-expression_ A common trick is to use `std::apply` in combination with a _fold-expression_

4
research/try.cpp
View file

@ -121,7 +121,7 @@ main (int, char**)
using Fut = decltype(fun); using Fut = decltype(fun);
SHOW_TYPE (_Fun<Fut>::Sig) SHOW_TYPE (_Fun<Fut>::Sig)
auto wup = buildInvokableWrapper<lib::meta::TySeq<int>>(bup); auto wup = buildInvokableWrapper<lib::meta::Types<int>>(bup);
using Wup = decltype(wup); using Wup = decltype(wup);
using WupSig = _Fun<Wup>::Sig; using WupSig = _Fun<Wup>::Sig;
@ -130,7 +130,7 @@ main (int, char**)
SHOW_EXPR (sizeof(bup)) SHOW_EXPR (sizeof(bup))
SHOW_EXPR (sizeof(wup)) SHOW_EXPR (sizeof(wup))
auto waua = buildInvokableWrapper<lib::meta::TySeq<>> (std::bind (fun, 55)); auto waua = buildInvokableWrapper<lib::meta::Types<>> (std::bind (fun, 55));
waua (); waua ();
SHOW_TYPE (_Fun<decltype(waua)>::Sig) SHOW_TYPE (_Fun<decltype(waua)>::Sig)

2
src/lib/diff/gen-node.hpp
View file

@ -132,7 +132,7 @@ namespace diff{
using Rec = Record<GenNode>; using Rec = Record<GenNode>;
using RecRef = RecordRef<GenNode>; using RecRef = RecordRef<GenNode>;
using MakeRec = Rec::Mutator; using MakeRec = Rec::Mutator;
using DataValues = meta::TySeq<int using DataValues = meta::Types<int
,int64_t ,int64_t
,short ,short
,char ,char

16
src/lib/meta/function-closure.hpp
View file

@ -294,7 +294,7 @@ namespace func{
using Ret = typename _Fun<SIG>::Ret; using Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::List; using ArgsList = typename Args::List;
using ValList = typename VAL::List; using ValList = typename VAL::List;
using ValTypes = typename TySeq<ValList>::Seq; // reconstruct a type-seq from a type-list using ValTypes = typename Types<ValList>::Seq; // reconstruct a type-seq from a type-list
enum { ARG_CNT = count<ArgsList>() enum { ARG_CNT = count<ArgsList>()
, VAL_CNT = count<ValList>() , VAL_CNT = count<ValList>()
@ -306,8 +306,8 @@ namespace func{
using LeftReduced = typename Splice<ArgsList, ValList>::Back; using LeftReduced = typename Splice<ArgsList, ValList>::Back;
using RightReduced = typename Splice<ArgsList, ValList, ROFFSET>::Front; using RightReduced = typename Splice<ArgsList, ValList, ROFFSET>::Front;
using ArgsL = typename TySeq<LeftReduced>::Seq; using ArgsL = typename Types<LeftReduced>::Seq;
using ArgsR = typename TySeq<RightReduced>::Seq; using ArgsR = typename Types<RightReduced>::Seq;
// build a list, where each of the *remaining* arguments is replaced by a placeholder marker // build a list, where each of the *remaining* arguments is replaced by a placeholder marker
@ -319,8 +319,8 @@ namespace func{
using LeftReplaced = typename Splice<ArgsList, TrailingPlaceholders, VAL_CNT>::List; using LeftReplaced = typename Splice<ArgsList, TrailingPlaceholders, VAL_CNT>::List;
using RightReplaced = typename Splice<ArgsList, LeadingPlaceholders, 0 >::List; using RightReplaced = typename Splice<ArgsList, LeadingPlaceholders, 0 >::List;
using LeftReplacedTypes = typename TySeq<LeftReplaced>::Seq; using LeftReplacedTypes = typename Types<LeftReplaced>::Seq;
using RightReplacedTypes = typename TySeq<RightReplaced>::Seq; using RightReplacedTypes = typename Types<RightReplaced>::Seq;
// create a "builder" helper, which accepts exactly the value tuple elements // create a "builder" helper, which accepts exactly the value tuple elements
// and puts them at the right location, while default-constructing the remaining // and puts them at the right location, while default-constructing the remaining
@ -407,7 +407,7 @@ namespace func{
using Args = typename _Fun<SIG>::Args; using Args = typename _Fun<SIG>::Args;
using Ret = typename _Fun<SIG>::Ret; using Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::List; using ArgsList = typename Args::List;
using ValList = typename TySeq<X>::List; using ValList = typename Types<X>::List;
enum { ARG_CNT = count<ArgsList>() }; enum { ARG_CNT = count<ArgsList>() };
@ -423,8 +423,8 @@ namespace func{
using PreparedArgs = Prefix<PreparedArgsRaw, ARG_CNT>; using PreparedArgs = Prefix<PreparedArgsRaw, ARG_CNT>;
using ReducedArgs = typename Append<RemainingFront, RemainingBack>::List; using ReducedArgs = typename Append<RemainingFront, RemainingBack>::List;
using PreparedArgTypes = typename TySeq<PreparedArgs>::Seq; using PreparedArgTypes = typename Types<PreparedArgs>::Seq;
using RemainingArgs = typename TySeq<ReducedArgs>::Seq; using RemainingArgs = typename Types<ReducedArgs>::Seq;
template<class SRC, class TAR, size_t i> template<class SRC, class TAR, size_t i>

290
src/lib/meta/function.hpp
View file

@ -2,7 +2,7 @@
FUNCTION.hpp - metaprogramming utilities for transforming function types FUNCTION.hpp - metaprogramming utilities for transforming function types
Copyright (C) Copyright (C)
2009, Hermann Vosseler <Ichthyostega@web.de> 2009-2025, Hermann Vosseler <Ichthyostega@web.de>
  **Lumiera** is free software; you can redistribute it and/or modify it   **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the   under the terms of the GNU General Public License as published by the
@ -13,25 +13,66 @@
/** @file function.hpp /** @file function.hpp
** Metaprogramming tools for transforming functor types. ** Metaprogramming tools for detecting and transforming function types.
** Sometimes it is necessary to build and remould a function signature, e.g. for ** Sometimes it is necessary to build and remould a function signature, e.g. for
** creating a functor or a closure based on an existing function of function pointer. ** creating a functor or a closure based on an existing function of function pointer.
** This is a core task of functional programming, but sadly C++ in its current shape ** Functors, especially in the form of Lambdas, can be used to parametrise a common
** is still lacking in this area. (C++11 significantly improved this situation). ** skeleton of computation logic to make it work with concrete implementation parts
** As an \em pragmatic fix, we define here a collection of templates, specialising ** tied directly to the actual usage. A _functor centric_ approach places the focus
** them in a very repetitive way for up to 9 function arguments. Doing so enables ** on the _computation structure_ and often complements the more _object centric_ one,
** us to capture a function, access the return type and argument types as a typelist, ** where relations and responsibilities are structured and built from building blocks
** eventually to manipulate them and re-build a different signature, or to create ** with fixed type relations.
** specifically tailored bindings.
** **
** If the following code makes you feel like vomiting, please look away, ** However, handling arbitrary functions as part of a common structure scheme requires
** and rest assured: you aren't alone. ** to cope with generally unknown argument and result types. Notably the number and
** sequence of the expected arguments of an unknown function can be arbitrary, which
** places the onus upon the handling and receiving context to adapt to actual result
** types and to provide suitable invocation arguments. Typically, failure to do so
** will produce a sway of almost impenetrable compilation failure messages, making
** the reason of the failure difficult to spot. So to handle this challenge, ways
** to inspect and isolate parts of the function's _signature_ become essential.
** **
** @todo get rid of the repetitive specialisations ** The _trait template_ [_Fun](\ref lib::meta::_Fun) is the entrance point to
** and use variadic templates to represent the arguments /////////////////////////////////TICKET #994 ** extract information regarding the function signature at compile time. Defined as
** a series partial template specialisations, it allows to create a level playing field
** and abstract over the wide array of different flavours of »invokable entities«:
** this can be direct references to some function in the code, function pointers,
** pointers to function members of an object, generally any object with an _function call_
** `operator()`, and especially the relevant features of the standard library, which are
** the generic function adapter `std::function` and the _binder_ objects created when
** _partially closing_ (binding) some function arguments ahead of the actual invocation.
** And last but not least the _Lambda functions_, which represent an abstracted, opaque
** and anonymous function and are supported by a special syntactical construct, allowing
** to pass _blocks of C++ code_ directly as argument to some other function or object.
** **
** Code to control the process of compilation, by detecting some aspects of the involved
** types and react accordingly, is a form of **metaprogramming** — and allows for dynamic
** **code generation** right from the ongoing compilation process. The flexible and open
** nature of function arguments often directly leads into such metaprogramming tasks.
** While the contemporary C++ language offers the language construct of _variadics_,
** such variadic template argument packs can only be dissected and processed further
** by instantiating another template with the argument pack and then exploiting
** _partial template specialisation_ to perform a _pattern match_ against the variadic
** arguments. Sometimes this approach comes in natural, yet in many commonplace situations
** if feels kind of »backwards« and leads to very tricky, hard to decipher template code.
** The Lumiera support library thus offers special features to handle _type sequences_
** and _type lists_ directly, allowing to process by recursive list programming patterns
** as known from the LISP language. The `_Fun` trait mentioned above directly provides
** an entrance point to this kind of in-compilation programming, as it exposes a nested
** type definition `_Fun<F>::Args`, which is an instance of the **type sequence** template
** \ref lib::meta::Types. This in turn exposes a nested type definition `List`, leading
** to the [Loki Type Lists](\ref typelist.hpp).
**
** Furthermore, this header defines some very widely used abbreviations for the most
** common tasks of detecting aspects of a function. These are often used in conjunction
** with the _constexpr if_ available since C++17:
** - _FunRet is a templated type definition to extract the return type
** - _FunArg extracts the type of single-arg function and fails compilation else
** - has_Arity<N> is a _meta-function_ to check for a specific number of arguments
** - is_NullaryFun, is_UnaryFun, is_BinaryFun, is_TernaryFun (common abbreviations)
** - the metafunction has_Sig is often placed close to the entrance point of an
** elaborate, template based ecosystem and helps to produce better error messages
** **
** @see control::CommandDef usage example
** @see function-closure.hpp generic function application ** @see function-closure.hpp generic function application
** @see typelist.hpp ** @see typelist.hpp
** @see tuple.hpp ** @see tuple.hpp
@ -55,24 +96,25 @@ namespace meta{
using std::function; using std::function;
/** /**************************************************************************//**
* Helper for uniform access to function signature types. * Trait template for uniform access to function signature types.
* Extract the type information contained in a function or functor type, * Extracts the type information contained in a function or functor type,
* so it can be manipulated by metaprogramming. This template works on * so it can be manipulated by metaprogramming. This template works on
* anything _function like_, irrespective if the parameter is given * anything _function like_, irrespective if the parameter is given
* as function reference, function pointer, member function pointer, * as function reference, function pointer, member function pointer,
* functor object, `std::function` or lambda. The embedded typedefs * functor object, `std::function` or lambda. The embedded typedefs
* allow to pick up * allow to expose
* - `Ret` : the return type * - `Ret` : the return type
* - `Args`: the sequence of argument types as type sequence `Types<ARGS...>` * - `Args`: the sequence of argument types as type sequence `Types<ARGS...>`
* - `Sig` : the bare function signature type * - `Sig` : the bare function signature type
* - `Functor` : corresponding Functor type which can be instantiated or copied. * - `Functor` : corresponding Functor type which can be instantiated or copied.
* - `ARITY` : number of arguments
* *
* This template can also be used in metaprogramming with `enable_if` to enable * This template can also be used in metaprogramming with `enable_if` to enable
* some definition or specialisation only if a function-like type was detected; thus * some definition or specialisation only if a function-like type was detected; thus
* the base case holds no nested type definitions and inherits from std::false_type. * the base case holds no nested type definitions and inherits from std::false_type.
* The primary, catch-all case gets activated whenever on functor objects, i.e. anything * The primary, catch-all case gets activated whenever used on functor objects
* with an `operator()`. * proper, i.e. anything with an `operator()`.
* The following explicit specialisations handle the other cases, which are * The following explicit specialisations handle the other cases, which are
* not objects, but primitive types (function (member) pointers and references). * not objects, but primitive types (function (member) pointers and references).
* @remarks The key trick of this solution is to rely on `decltype` of `operator()` * @remarks The key trick of this solution is to rely on `decltype` of `operator()`
@ -86,6 +128,7 @@ namespace meta{
* - when there are several overloads of `operator()` * - when there are several overloads of `operator()`
* - when the function call operator is templated * - when the function call operator is templated
* - on *generic lambdas* * - on *generic lambdas*
* - on results of std::bind
* All these cases will activate the base (false) case, as if the * All these cases will activate the base (false) case, as if the
* tested subject was not a function at all. Generally speaking, * tested subject was not a function at all. Generally speaking,
* it is _not possible_ to probe a generic lambda or templated function, * it is _not possible_ to probe a generic lambda or templated function,
@ -116,7 +159,7 @@ namespace meta{
: std::true_type : std::true_type
{ {
using Ret = RET; using Ret = RET;
using Args = TySeq<ARGS...>; using Args = Types<ARGS...>;
using Sig = RET(ARGS...); using Sig = RET(ARGS...);
using Functor = std::function<Sig>; using Functor = std::function<Sig>;
enum { ARITY = sizeof...(ARGS) }; enum { ARITY = sizeof...(ARGS) };
@ -182,6 +225,29 @@ namespace meta{
/**
* Build function types from given Argument types.
* As embedded typedefs, you'll find a std::function #Func
* and the bare function signature #Sig
* @param RET the function return type
* @param ARGS a type sequence describing the arguments
*/
template<typename RET, typename ARGS>
struct BuildFunType;
template<typename RET, typename...ARGS>
struct BuildFunType<RET, Types<ARGS...>>
{
using Sig = RET(ARGS...);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
/** abbreviation for referring to a function's return type */ /** abbreviation for referring to a function's return type */
template<typename FUN> template<typename FUN>
using _FunRet = typename _Fun<FUN>::Ret; using _FunRet = typename _Fun<FUN>::Ret;
@ -329,187 +395,5 @@ namespace meta{
/**
* Build function types from given Argument types.
* As embedded typedefs, you'll find a tr1 functor #Func
* and the bare function signature #Sig
* @param RET the function return type
* @param ARGS a type sequence describing the arguments
*/ //////////////////////////////////////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic, then replace this by a single variadic template
template<typename RET, typename ARGS>
struct BuildFunType;
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : this specialisation handles the variadic case and will be the only definition in future
template<typename RET, typename...ARGS>
struct BuildFunType<RET, TySeq<ARGS...>>
{
using Sig = RET(ARGS...);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisations become obsolete with the old-style type-sequence
template< typename RET>
struct BuildFunType<RET, TyOLD<> >
{
using Sig = RET(void);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
>
struct BuildFunType<RET, TyOLD<A1>>
{
using Sig = RET(A1);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
>
struct BuildFunType<RET, TyOLD<A1,A2>>
{
using Sig = RET(A1,A2);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
, typename A3
>
struct BuildFunType<RET, TyOLD<A1,A2,A3>>
{
using Sig = RET(A1,A2,A3);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
, typename A3
, typename A4
>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4>>
{
using Sig = RET(A1,A2,A3,A4);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
, typename A3
, typename A4
, typename A5
>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4,A5>>
{
using Sig = RET(A1,A2,A3,A4,A5);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
, typename A3
, typename A4
, typename A5
, typename A6
>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4,A5,A6>>
{
using Sig = RET(A1,A2,A3,A4,A5,A6);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
, typename A3
, typename A4
, typename A5
, typename A6
, typename A7
>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4,A5,A6,A7>>
{
using Sig = RET(A1,A2,A3,A4,A5,A6,A7);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
, typename A3
, typename A4
, typename A5
, typename A6
, typename A7
, typename A8
>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4,A5,A6,A7,A8>>
{
using Sig = RET(A1,A2,A3,A4,A5,A6,A7,A8);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
template< typename RET
, typename A1
, typename A2
, typename A3
, typename A4
, typename A5
, typename A6
, typename A7
, typename A8
, typename A9
>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4,A5,A6,A7,A8,A9>>
{
using Sig = RET(A1,A2,A3,A4,A5,A6,A7,A8,A9);
using Fun = _Fun<Sig>;
using Func = function<Sig>;
using Functor = Func;
};
}} // namespace lib::meta }} // namespace lib::meta
#endif #endif

4
src/lib/meta/tuple-closure.hpp
View file

@ -93,7 +93,7 @@ namespace meta{
static auto static auto
closeFront (VALS&& ...vs) closeFront (VALS&& ...vs)
{ {
using ClosedTypes = TySeq<std::decay_t<VALS>...>; using ClosedTypes = Types<std::decay_t<VALS>...>;
auto boundArgs = std::make_tuple (std::forward<VALS> (vs)...); // Note: must be passed by-val here auto boundArgs = std::make_tuple (std::forward<VALS> (vs)...); // Note: must be passed by-val here
return wrapBuilder (func::PApply<TupleBuilderSig, ClosedTypes>::bindFront (buildRecord, move(boundArgs))); return wrapBuilder (func::PApply<TupleBuilderSig, ClosedTypes>::bindFront (buildRecord, move(boundArgs)));
} }
@ -104,7 +104,7 @@ namespace meta{
static auto static auto
closeBack (VALS&& ...vs) closeBack (VALS&& ...vs)
{ {
using ClosedTypes = TySeq<std::decay_t<VALS>...>; using ClosedTypes = Types<std::decay_t<VALS>...>;
auto boundArgs = std::make_tuple (std::forward<VALS> (vs)...); auto boundArgs = std::make_tuple (std::forward<VALS> (vs)...);
return wrapBuilder (func::PApply<TupleBuilderSig, ClosedTypes>::bindBack (buildRecord, move(boundArgs))); return wrapBuilder (func::PApply<TupleBuilderSig, ClosedTypes>::bindBack (buildRecord, move(boundArgs)));
} }

56
src/lib/meta/tuple-helper.hpp
View file

@ -14,20 +14,13 @@
/** @file tuple-helper.hpp /** @file tuple-helper.hpp
** Metaprogramming with tuples-of-types and the `std::tuple` record. ** Metaprogramming with tuples-of-types and the `std::tuple` record.
** The metaprogramming part of this header complements typelist.hpp and allows ** This header complements typelist.hpp and provides a bridge from type sequences
** some additional manipulations on type sequences, especially to integrate ** to the tuple type provided by the standard library, including traits and
** with the Tuples provided by the standard library. ** helpers to build tuple types from metaprogramming and to pretty-print tuples.
** **
** @warning the metaprogramming part of Lumiera to deal with type sequences is in a ** Furthermore, a generic iteration construct is provided, to instantiate
** state of transition, since C++11 now offers direct language support for ** a generic Lambda for each element of a given tuple, which allows to write
** processing of flexible template parameter sequences ("parameter packs"). ** generic code »for each tuple element«.
** It is planned to regroup and simplify our homemade type sequence framework
** to rely on variadic templates and integrate better with std::tuple.
** It is clear that we will _retain some parts_ of our own framework,
** since programming with _Loki-style typelists_ is way more obvious
** and straight forward than handling of template parameter packs,
** since the latter can only be rebound through pattern matching.
** @todo transition lib::meta::Types to variadic parameters /////////////////////////////////TICKET #987
** **
** @see control::CommandDef usage example ** @see control::CommandDef usage example
** @see TupleHelper_test ** @see TupleHelper_test
@ -142,27 +135,15 @@ namespace meta {
{ }; { };
template<typename...TYPES> template<typename...TYPES>
struct BuildTupleType<TySeq<TYPES...>> struct BuildTupleType<Types<TYPES...>>
{ {
using Type = std::tuple<TYPES...>; using Type = std::tuple<TYPES...>;
}; };
/**
* temporary workaround: strip trailing Nil-Type entries
* prior to rebinding to the `std::tuple` type.
*/
template<typename...TYPES>
struct BuildTupleType<TyOLD<TYPES...>>
{
using VariadicSeq = typename StripNil<TyOLD<TYPES...>>::Seq;
using Type = typename BuildTupleType<VariadicSeq>::Type;
};
template<class H, typename TAIL> template<class H, typename TAIL>
struct BuildTupleType<Node<H, TAIL>> struct BuildTupleType<Node<H, TAIL>>
{ {
using Seq = typename TySeq<Node<H,TAIL>>::Seq; using Seq = typename Types<Node<H,TAIL>>::Seq;
using Type = typename BuildTupleType<Seq>::Type; using Type = typename BuildTupleType<Seq>::Type;
}; };
@ -195,13 +176,13 @@ namespace meta {
template<typename...TYPES> template<typename...TYPES>
struct RebindTupleTypes struct RebindTupleTypes
{ {
using Seq = typename TySeq<TYPES...>::Seq; using Seq = typename Types<TYPES...>::Seq;
using List = typename Seq::List; using List = typename Seq::List;
}; };
template<typename...TYPES> template<typename...TYPES>
struct RebindTupleTypes<std::tuple<TYPES...>> struct RebindTupleTypes<std::tuple<TYPES...>>
{ {
using Seq = typename TySeq<TYPES...>::Seq; using Seq = typename Types<TYPES...>::Seq;
using List = typename Seq::List; using List = typename Seq::List;
}; };
@ -349,29 +330,16 @@ namespace meta {
}; };
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : this specialisation handles the variadic case and will be the only definition in future
template template
< template<class,class,class, uint> class _X_ < template<class,class,class, uint> class _X_
, class TUP , class TUP
, uint i , uint i
> >
class BuildTupleAccessor< _X_, TySeq<>, TUP, i> class BuildTupleAccessor< _X_, Types<>, TUP, i>
{ {
public: public:
using Product = _X_<Nil, TUP, TUP, i>; // Note: i == tuple size using Product = _X_<Nil, TUP, TUP, i>; // Note: i == tuple size
}; };
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisation will be obsoleted by the removal of old-style type-sequences
template
< template<class,class,class, uint> class _X_
, class TUP
, uint i
>
class BuildTupleAccessor< _X_, TyOLD<>, TUP, i>
{
public:
using Product = _X_<Nil, TUP, TUP, i>; // Note: i == tuple size
};
@ -431,7 +399,7 @@ namespace meta {
inline std::string inline std::string
dump (std::tuple<TYPES...> const& tuple) dump (std::tuple<TYPES...> const& tuple)
{ {
using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, TySeq<TYPES...>>; using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, Types<TYPES...>>;
using Displayer = typename BuildAccessor::Product ; using Displayer = typename BuildAccessor::Product ;
return static_cast<Displayer const&> (tuple) return static_cast<Displayer const&> (tuple)

2
src/lib/meta/tuple-record-init.hpp
View file

@ -193,7 +193,7 @@ namespace meta {
struct ElementExtractor<lib::diff::Rec, std::tuple<TYPES...>> struct ElementExtractor<lib::diff::Rec, std::tuple<TYPES...>>
{ {
template<size_t i> template<size_t i>
using TargetType = typename Pick<TySeq<TYPES...>, i>::Type; using TargetType = typename Pick<Types<TYPES...>, i>::Type;
template<size_t i> template<size_t i>

85
src/lib/meta/typelist.hpp
View file

@ -37,7 +37,7 @@ This code is heavily inspired by
** The latter brings LISP style recursive manipulation techniques into the ** The latter brings LISP style recursive manipulation techniques into the
** realm of type metaprogramming; this approach was pioneered with the ** realm of type metaprogramming; this approach was pioneered with the
** **Loki Library** by Alexandrescu (2001) and makes complex processing ** **Loki Library** by Alexandrescu (2001) and makes complex processing
** much easier to write and to understand following. Effectively the set ** much easier to write and to follow for the reader. Effectively the set
** of definitions used here is a tailored version of what could be found ** of definitions used here is a tailored version of what could be found
** in the Loki library, and was in the following years integrated with ** in the Loki library, and was in the following years integrated with
** processing of variadics, function manipulation and std::tuple. ** processing of variadics, function manipulation and std::tuple.
@ -58,17 +58,6 @@ This code is heavily inspired by
** effectively this is a flavour of functional programming; the _execution environment_ ** effectively this is a flavour of functional programming; the _execution environment_
** is the compiler, and evaluation is set off by some template instantiation. ** is the compiler, and evaluation is set off by some template instantiation.
** **
** @warning the metaprogramming part of Lumiera to deal with type sequences is in a
** state of transition, since C++11 now offers direct language support for
** processing of flexible template parameter sequences ("parameter packs").
** It is planned to regroup and simplify our homemade type sequence framework
** to rely on variadic templates and integrate better with std::tuple.
** It is clear that we will _retain some parts_ of our own framework,
** since programming with _Loki-style typelists_ is way more obvious
** and straight forward than handling of template parameter packs,
** since the latter can only be rebound through pattern matching.
** @todo transition lib::meta::Types to variadic parameters /////////////////////////////////TICKET #987
**
** @see TypeList_test ** @see TypeList_test
** @see TypeListManip_test ** @see TypeListManip_test
** @see TypeSecManip_test ** @see TypeSecManip_test
@ -108,80 +97,22 @@ namespace meta {
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 : this is the old non-variadic definition from lib Loki -- it will be obsoleted with the transition /** variadic sequence of types */
template
< class T01=Nil
, class T02=Nil
, class T03=Nil
, class T04=Nil
, class T05=Nil
, class T06=Nil
, class T07=Nil
, class T08=Nil
, class T09=Nil
, class T10=Nil
, class T11=Nil
, class T12=Nil
, class T13=Nil
, class T14=Nil
, class T15=Nil
, class T16=Nil
, class T17=Nil
, class T18=Nil
, class T19=Nil
, class T20=Nil
>
class TyOLD
{
typedef typename TyOLD< T02, T03, T04
, T05, T06, T07, T08
, T09, T10, T11, T12
, T13, T14, T15, T16
, T17, T18, T19, T20>::List ListTail;
public:
using List = Node<T01, ListTail>;
using Seq = TyOLD;
};
template<>
struct TyOLD<>
{
using List = Nil;
using Seq = TyOLD<>;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND -- transition to variadic type-sequences
/**
* temporary workaround:
* alternative definition of "type sequence",
* already using variadic template parameters.
* @remarks the problem with our existing type sequence type
* is that it fills the end of each sequence with Nil,
* which was the only way to get a flexible type sequence
* prior to C++11. Unfortunately these trailing Nil
* entries do not play well with other variadic defs.
* @deprecated when we switch our primary type sequence type
* to variadic parameters, this type will be obsoleted. ////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic
* @todo 6/25 the transition is now mostly settled
* and will be completed by just _renaming_ this
* definition back into `Types<...>`
*/
template<typename...TYPES> template<typename...TYPES>
struct TySeq; struct Types;
template<typename T, typename...TS> template<typename T, typename...TS>
struct TySeq<T,TS...> struct Types<T,TS...>
{ {
using List = Node<T, typename TySeq<TS...>::List>; using List = Node<T, typename Types<TS...>::List>;
using Seq = TySeq; using Seq = Types;
}; };
template<> template<>
struct TySeq<> struct Types<>
{ {
using List = Nil; using List = Nil;
using Seq = TySeq<>; using Seq = Types<>;
}; };
}} // namespace lib::meta }} // namespace lib::meta

217
src/lib/meta/typeseq-util.hpp
View file

@ -22,17 +22,6 @@
** - shifting a type sequence ** - shifting a type sequence
** - re-generating a type sequence from a typelist. ** - re-generating a type sequence from a typelist.
** **
** @warning the metaprogramming part of Lumiera to deal with type sequences is in a
** state of transition, since C++11 now offers direct language support for
** processing of flexible template parameter sequences ("parameter packs").
** It is planned to regroup and simplify our homemade type sequence framework
** to rely on variadic templates and integrate better with std::tuple.
** It is clear that we will _retain some parts_ of our own framework,
** since programming with _Loki-style typelists_ is way more obvious
** and straight forward than handling of template parameter packs,
** since the latter can only be rebound through pattern matching.
** @todo transition lib::meta::Types to variadic parameters /////////////////////////////////TICKET #987
**
** @see typeseq-manip-test.cpp ** @see typeseq-manip-test.cpp
** @see typelist.hpp ** @see typelist.hpp
** @see typelist-util.hpp ** @see typelist-util.hpp
@ -88,11 +77,7 @@ namespace meta {
: SizConst<sizeof...(TYPES)> : SizConst<sizeof...(TYPES)>
{ }; { };
template<class... TYPES> template<class... TYPES>
struct count<TySeq<TYPES...>> struct count<Types<TYPES...>>
: SizConst<sizeof...(TYPES)>
{ };
template<class... TYPES>
struct count<TyOLD<TYPES...>>
: SizConst<sizeof...(TYPES)> : SizConst<sizeof...(TYPES)>
{ }; { };
@ -101,78 +86,15 @@ namespace meta {
* Helper: prepend a type to an existing type sequence, * Helper: prepend a type to an existing type sequence,
* thus shifting all elements within the sequence * thus shifting all elements within the sequence
* to the right, eventually dropping the last element * to the right, eventually dropping the last element
* @todo support variadic type-seq ////////////////////////////////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic, then replace this by a single variadic template
*/ */
template<class T, class TYPES> template<class T, class TYPES>
struct Prepend; struct Prepend;
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisation will be obsoleted by the removal of old-style type-sequences
template< typename T01
, typename T02
, typename T03
, typename T04
, typename T05
, typename T06
, typename T07
, typename T08
, typename T09
, typename T10
, typename T11
, typename T12
, typename T13
, typename T14
, typename T15
, typename T16
, typename T17
, typename T18
, typename T19
, typename T20
, typename IGN
>
struct Prepend<T01, TyOLD< T02,T03,T04,T05
, T06,T07,T08,T09,T10
, T11,T12,T13,T14,T15
, T16,T17,T18,T19,T20
, IGN
> >
{
typedef TyOLD< T01,T02,T03,T04,T05
, T06,T07,T08,T09,T10
, T11,T12,T13,T14,T15
, T16,T17,T18,T19,T20 > Seq;
typedef typename Seq::List List;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND -- to be obsoleted
/**
* Additional specialisation of the basic type sequence type,
* allowing to re-create a (flat) type sequence from a typelist.
*/
template<class H, class T>
struct TyOLD< Node<H,T> >
{
typedef Node<H,T> List;
typedef typename Prepend< H
, typename TyOLD<T>::Seq
>::Seq Seq;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND -- to be obsoleted
/**
* temporary workaround: additional specialisation for the template
* `Prepend` to work also with the (alternative) variadic TySeq.
* @see typeseq-util.hpp
*/
template<typename T, typename...TYPES> template<typename T, typename...TYPES>
struct Prepend<T, TySeq<TYPES...>> struct Prepend<T, Types<TYPES...>>
{ {
using Seq = TySeq<T, TYPES...>; using Seq = Types<T, TYPES...>;
using List = typename TySeq<T, TYPES...>::List; using List = typename Types<T, TYPES...>::List;
}; };
@ -180,157 +102,73 @@ namespace meta {
/** /**
* Additional specialisation of the basic type sequence type, * Additional specialisation of the basic type sequence type,
* allowing to re-create a (flat) type sequence from a typelist. * allowing to re-create a (flat) type sequence from a typelist.
* @remark can now be built with the help of \ref Prepend.
*/ */
template<class H, class T> template<class H, class T>
struct TySeq< Node<H,T> > struct Types< Node<H,T> >
{ {
using List = Node<H,T>; using List = Node<H,T>;
using Seq = typename Prepend< H using Seq = typename Prepend< H
, typename TySeq<T>::Seq , typename Types<T>::Seq
>::Seq; >::Seq;
}; };
template<> template<>
struct TySeq<Nil> struct Types<Nil>
{ {
using List = Nil; using List = Nil;
using Seq = TySeq<>; using Seq = Types<>;
}; };
template<> template<>
struct TySeq<NilNode> struct Types<NilNode>
: TySeq<Nil> : Types<Nil>
{ }; { };
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND -- to be obsoleted
/**
* temporary workaround: strip trailing Nil entries from a
* type sequence, to make it compatible with new-style variadic
* template definitions.
* @note the result type is a TySec, to keep it apart from our
* legacy (non-variadic) lib::meta::Types
* @deprecated necessary for the transition to variadic sequences ////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic
*/
template<typename SEQ>
struct StripNil;
template<typename T, typename...TYPES>
struct StripNil<TyOLD<T,TYPES...>>
{
using TailSeq = typename StripNil<TyOLD<TYPES...>>::Seq;
using Seq = typename Prepend<T, TailSeq>::Seq;
};
template<typename...TYPES>
struct StripNil<TyOLD<Nil, TYPES...>>
{
using Seq = TySeq<>; // NOTE: this causes the result to be a TySeq
};
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisation is a catch-all and becomes obsolete
template<typename...TYPES>
struct StripNil<TySeq<TYPES...>>
{
using Seq = TySeq<TYPES...>;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND(End) -- to be obsoleted
/** Helper: separate parts of a type sequence /** Helper: separate parts of a type sequence
* @todo support variadic type-seq ////////////////////////////////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic, then replace this by a single variadic template
*/ */
template<class TYPES> template<class TYPES>
struct Split; struct Split;
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : this specialisation handles the variadic case and will be the only definition in future
template<typename T1, typename...TS> template<typename T1, typename...TS>
struct Split<TySeq<T1,TS...> > struct Split<Types<T1,TS...> >
{ {
using List = typename TySeq<T1,TS...>::List; using List = typename Types<T1,TS...>::List;
using Head = T1; using Head = T1;
using First = TySeq<T1>; using First = Types<T1>;
using Tail = TySeq<TS...>; using Tail = Types<TS...>;
// for finding the end we need the help of typelist-util.hpp // for finding the end we need the help of typelist-util.hpp
using PrefixList = typename PickLast<List>::List; using PrefixList = typename PickLast<List>::List;
using TailList = typename Tail::List; using TailList = typename Tail::List;
using Prefix = typename TySeq<PrefixList>::Seq; using Prefix = typename Types<PrefixList>::Seq;
using End = typename PickLast<List>::Type; using End = typename PickLast<List>::Type;
using Last = TySeq<End>; using Last = Types<End>;
}; };
template<> template<>
struct Split<TySeq<>> struct Split<Types<>>
{ {
using List = Nil; using List = Nil;
using Head = Nil; using Head = Nil;
using First = TySeq<>; using First = Types<>;
using Tail = TySeq<>; using Tail = Types<>;
// for finding the end we need the help of typelist-util.hpp // for finding the end we need the help of typelist-util.hpp
using PrefixList = Nil; using PrefixList = Nil;
using TailList = Nil; using TailList = Nil;
using Prefix = TySeq<>; using Prefix = Types<>;
using Last = TySeq<>; using Last = Types<>;
using End = Nil; using End = Nil;
}; };
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisation will be obsoleted by the removal of old-style type-sequences
template< typename T01
, typename T02
, typename T03
, typename T04
, typename T05
, typename T06
, typename T07
, typename T08
, typename T09
, typename T10
, typename T11
, typename T12
, typename T13
, typename T14
, typename T15
, typename T16
, typename T17
, typename T18
, typename T19
, typename T20
>
struct Split<TyOLD< T01,T02,T03,T04,T05
, T06,T07,T08,T09,T10
, T11,T12,T13,T14,T15
, T16,T17,T18,T19,T20
> >
{
typedef typename
TyOLD< T01,T02,T03,T04,T05
, T06,T07,T08,T09,T10
, T11,T12,T13,T14,T15
, T16,T17,T18,T19,T20
>::List List;
typedef T01 Head;
typedef TyOLD< T01 > First;
typedef TyOLD< T02,T03,T04,T05
, T06,T07,T08,T09,T10
, T11,T12,T13,T14,T15
, T16,T17,T18,T19,T20 > Tail;
// for finding the end we need the help of typelist-util.hpp
typedef typename PickLast<List>::List PrefixList;
typedef typename Tail::List TailList;
typedef typename TyOLD<PrefixList>::Seq Prefix;
typedef typename PickLast<List>::Type End;
typedef TyOLD<End> Last;
};
@ -362,14 +200,9 @@ namespace meta {
* @see typelist-manip.hpp * @see typelist-manip.hpp
*/ */
template<typename...TYPES, size_t i> template<typename...TYPES, size_t i>
struct Pick<TyOLD<TYPES...>, i> struct Pick<Types<TYPES...>, i>
{ {
using Type = typename lib::meta::Shifted<TyOLD<TYPES...>, i>::Head; using Type = typename Shifted<Types<TYPES...>, i>::Head;
};
template<typename...TYPES, size_t i>
struct Pick<TySeq<TYPES...>, i>
{
using Type = typename Shifted<TySeq<TYPES...>, i>::Head;
}; };
@ -388,7 +221,7 @@ namespace meta {
template<typename T> template<typename T>
struct Repeat<T,0> struct Repeat<T,0>
{ {
using Seq = TySeq<>; using Seq = Types<>;
}; };

59
src/lib/meta/variadic-helper.hpp
View file

@ -20,18 +20,13 @@
** lists _at compile time,_ driven by template instantiation, allowing to specialise ** lists _at compile time,_ driven by template instantiation, allowing to specialise
** and react specifically on some concrete pattern of argument types. ** and react specifically on some concrete pattern of argument types.
** **
** @warning the metaprogramming part of Lumiera to deal with type sequences is in a ** @remark in Lumiera, over time three different approaches were developed for
** state of transition, since C++11 now offers direct language support for ** handling sequences of types in metaprogramming; some of these techniques
** processing of flexible template parameter sequences ("parameter packs"). ** are better suited for specific kinds of tasks than others
** It is planned to regroup and simplify our homemade type sequence framework ** - templates with variadic arguments (e.g. std::tuple) can be manipulated directly
** to rely on variadic templates and integrate better with std::tuple. ** - a type-sequence `Types<T...>` can be primed / rebound from other variadic templates
** It is clear that we will _retain some parts_ of our own framework, ** - Loki-style type-lists are created from type-sequences and enable elaborate manipulations
** since programming with _Loki-style typelists_ is way more obvious ** @see feed-manifold.hpp advanced usage example in the Render Engine
** and straight forward than handling of template parameter packs,
** since the latter can only be rebound through pattern matching.
** @todo transition lib::meta::Types to variadic parameters /////////////////////////////////TICKET #987
**
** @see control::CommandDef usage example
** @see TupleHelper_test ** @see TupleHelper_test
** @see typelist.hpp ** @see typelist.hpp
** @see function.hpp ** @see function.hpp
@ -140,32 +135,8 @@ namespace meta {
}; };
/** build an index number sequence from a type sequence */ /** build an index number sequence from a type sequence */
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND -- to be obsoleted
template<typename...TYPES> template<typename...TYPES>
struct BuildIdxIter<TyOLD<TYPES...>> struct BuildIdxIter<Types<TYPES...>>
{
///////////////////////TICKET #987 : since Types<T...> is not variadic, need to strip Nil-Type here (instead of just using sizeof...(TYPES)
enum {SIZ = lib::meta::count<typename TyOLD<TYPES...>::List>::value };
using Builder = BuildIndexSeq<SIZ>;
using Ascending = typename Builder::Ascending;
using Descending = typename Builder::Descending;
template<size_t d>
using OffsetBy = typename Builder::template OffsetBy<d>;
template<size_t x>
using FilledWith = typename Builder::template FilledWith<x>;
template<size_t c>
using First = typename Builder::template First<c>;
template<size_t c>
using After = typename Builder::template After<c>;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND(END)
template<typename...TYPES>
struct BuildIdxIter<TySeq<TYPES...>>
: BuildIdxIter<TYPES...> : BuildIdxIter<TYPES...>
{ }; { };
@ -196,11 +167,11 @@ namespace meta {
{ {
static constexpr size_t SIZ = 1; static constexpr size_t SIZ = 1;
using Idx = std::index_sequence<SIZ>; using Idx = std::index_sequence<SIZ>;
using Seq = TySeq<X>; using Seq = Types<X>;
using Tup = std::tuple<X>; using Tup = std::tuple<X>;
template<template<class> class META> template<template<class> class META>
using Apply = TySeq<META<X>>; using Apply = Types<META<X>>;
template<template<typename...> class O> template<template<typename...> class O>
using Rebind = O<X>; using Rebind = O<X>;
template<template<class> class PRED> template<template<class> class PRED>
@ -211,15 +182,15 @@ namespace meta {
/** Partial specialisation to handle type sequences */ /** Partial specialisation to handle type sequences */
template<typename...TYPES> template<typename...TYPES>
struct ElmTypes<TySeq<TYPES...>> struct ElmTypes<Types<TYPES...>>
{ {
static constexpr size_t SIZ = sizeof...(TYPES); static constexpr size_t SIZ = sizeof...(TYPES);
using Idx = std::make_index_sequence<SIZ>; using Idx = std::make_index_sequence<SIZ>;
using Seq = TySeq<TYPES...>; using Seq = Types<TYPES...>;
using Tup = std::tuple<TYPES...>; using Tup = std::tuple<TYPES...>;
template<template<class> class META> template<template<class> class META>
using Apply = TySeq<META<TYPES>...>; using Apply = Types<META<TYPES>...>;
template<template<typename...> class O> template<template<typename...> class O>
using Rebind = typename lib::meta::RebindVariadic<O, Seq>::Type; using Rebind = typename lib::meta::RebindVariadic<O, Seq>::Type;
@ -242,7 +213,7 @@ namespace meta {
template<size_t...idx> template<size_t...idx>
struct Extract<std::index_sequence<idx...>> struct Extract<std::index_sequence<idx...>>
{ {
using ElmTypes = TySeq<typename std::tuple_element<idx,TUP>::type ...>; using ElmTypes = Types<typename std::tuple_element<idx,TUP>::type ...>;
}; };
static constexpr size_t SIZ = std::tuple_size<TUP>::value; static constexpr size_t SIZ = std::tuple_size<TUP>::value;
@ -315,7 +286,7 @@ namespace meta {
return lib::meta::count<typename TTX::List>(); return lib::meta::count<typename TTX::List>();
else else
{ // Fallback: rebind template arguments into a type sequence { // Fallback: rebind template arguments into a type sequence
using Seq = typename RebindVariadic<TySeq, TTX>::Type; using Seq = typename RebindVariadic<Types, TTX>::Type;
return size_t(count<Seq>()); return size_t(count<Seq>());
} }
}; };

2
src/lib/parse.hpp
View file

@ -392,7 +392,7 @@ namespace util {
: tuple<RESULTS...> : tuple<RESULTS...>
{ {
static constexpr size_t N = sizeof...(RESULTS); static constexpr size_t N = sizeof...(RESULTS);
using Seq = lib::meta::TySeq<RESULTS...>; using Seq = lib::meta::Types<RESULTS...>;
using Tup = std::tuple<RESULTS...>; using Tup = std::tuple<RESULTS...>;
SeqModel() = default; SeqModel() = default;

4
src/lib/time/formats.hpp
View file

@ -166,7 +166,7 @@ namespace time {
/* == Descriptor to define Support for specific formats == */ /* == Descriptor to define Support for specific formats == */
using lib::meta::TySeq; using lib::meta::Types;
using lib::meta::Node; using lib::meta::Node;
using lib::meta::Nil; using lib::meta::Nil;
@ -238,7 +238,7 @@ namespace time {
: Supported : Supported
{ {
SupportStandardTimecode() SupportStandardTimecode()
: Supported(formats< TySeq<Hms,Smpte,Frames,Seconds> >()) : Supported(formats< Types<Hms,Smpte,Frames,Seconds> >())
{ } { }
}; };

6
src/lib/variant.hpp
View file

@ -98,7 +98,7 @@ namespace lib {
namespace variant { // implementation metaprogramming helpers namespace variant { // implementation metaprogramming helpers
using std::remove_reference; using std::remove_reference;
using meta::TySeq; using meta::Types;
using meta::Node; using meta::Node;
using meta::Nil; using meta::Nil;
@ -159,8 +159,8 @@ namespace lib {
}; };
template<class...TYPES, template<class> class _P_> template<class...TYPES, template<class> class _P_>
struct FirstMatchingType<TySeq<TYPES...>, _P_> struct FirstMatchingType<Types<TYPES...>, _P_>
: FirstMatchingType<typename TySeq<TYPES...>::List, _P_> : FirstMatchingType<typename Types<TYPES...>::List, _P_>
{ }; { };
template<class T, class TYPES, template<class> class _P_> template<class T, class TYPES, template<class> class _P_>

2
src/lib/visitor.hpp
View file

@ -171,7 +171,7 @@ namespace visitor {
} }
}; };
using typelist::TySeq; // convenience for the user of "Applicable" using typelist::Types; // convenience for the user of "Applicable"

2
src/lib/wrapperptr.hpp
View file

@ -36,7 +36,7 @@ namespace steam {
namespace mobject { class MObject; } namespace mobject { class MObject; }
using WrapperTypes = lib::meta::TySeq< mobject::Placement<mobject::MObject>* using WrapperTypes = lib::meta::Types< mobject::Placement<mobject::MObject>*
, lib::P<asset::Asset>* , lib::P<asset::Asset>*
> ::List; > ::List;
} }

4
src/stage/interact/view-spec-dsl.hpp
View file

@ -207,7 +207,7 @@ namespace interact {
using lib::meta::_Fun; using lib::meta::_Fun;
using lib::meta::Split; using lib::meta::Split;
using lib::meta::Tuple; using lib::meta::Tuple;
using lib::meta::TySeq; using lib::meta::Types;
using lib::meta::func::PApply; using lib::meta::func::PApply;
typedef typename _Fun<FUN>::Ret Ret; typedef typename _Fun<FUN>::Ret Ret;
@ -219,7 +219,7 @@ namespace interact {
"Allocator function must accept UICoordinates (where to create/locate) as first argument"); "Allocator function must accept UICoordinates (where to create/locate) as first argument");
static_assert (std::is_convertible<Ret, UICoord>::value, static_assert (std::is_convertible<Ret, UICoord>::value,
"Allocator function must produce UICoordinates (of the actually allocated UI element)"); "Allocator function must produce UICoordinates (of the actually allocated UI element)");
static_assert (std::is_convertible<FurtherArgs, TySeq<ARGS...>>::value, static_assert (std::is_convertible<FurtherArgs, Types<ARGS...>>::value,
"Additional parameters of the allocator function must match the AllocSpec<ARGS> template parameters"); "Additional parameters of the allocator function must match the AllocSpec<ARGS> template parameters");

4
src/stage/model/element-access.hpp
View file

@ -63,7 +63,7 @@ namespace model {
namespace error = lumiera::error; namespace error = lumiera::error;
using interact::UICoord; using interact::UICoord;
using lib::meta::TySeq; using lib::meta::Types;
using std::string; using std::string;
class Tangible; class Tangible;
@ -91,7 +91,7 @@ namespace model {
protected: protected:
using RawResult = lib::Variant<TySeq<model::Tangible*, Gtk::Widget*>>; using RawResult = lib::Variant<Types<model::Tangible*, Gtk::Widget*>>;
/** @internal drill down according to coordinates, maybe create element */ /** @internal drill down according to coordinates, maybe create element */
virtual RawResult performAccessTo (UICoord::Builder &, size_t limitCreation) =0; virtual RawResult performAccessTo (UICoord::Builder &, size_t limitCreation) =0;

2
src/steam/config-resolver.hpp
View file

@ -61,7 +61,7 @@ namespace steam {
* the list of all concrete types participating in the * the list of all concrete types participating in the
* rule based config query system * rule based config query system
*/ */
using InterfaceTypes = lib::meta::TySeq < steam::mobject::session::Fork using InterfaceTypes = lib::meta::Types < steam::mobject::session::Fork
, steam::asset::Pipe , steam::asset::Pipe
, const steam::asset::ProcPatt , const steam::asset::ProcPatt
, steam::asset::Timeline , steam::asset::Timeline

386
src/steam/control/argument-tuple-accept.hpp
View file

@ -36,8 +36,6 @@
** when the provided arguments don't fit the (hidden) function signature embedded ** when the provided arguments don't fit the (hidden) function signature embedded
** within the CommandMutation (functor). ** within the CommandMutation (functor).
** **
** @todo switch to variadic templates. Requires a rework of Types<...> /////////////////////////////////////TICKET #967
**
** @see Command ** @see Command
** @see CommandDef ** @see CommandDef
** @see argument-tuple-accept-test.cpp ** @see argument-tuple-accept-test.cpp
@ -69,19 +67,14 @@ namespace control {
using std::make_tuple; using std::make_tuple;
// /** @internal mix in a function operator */
// _______________________________________________________________________________________________________________
/** @internal mix in a function operator
* @todo variadic type-seq //////////////////////////////////////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic, then replace this by a single variadic template
*/
template< class TAR, class BA, class RET template< class TAR, class BA, class RET
, typename TYPES , typename TYPES
> >
struct AcceptArgs ; struct AcceptArgs ;
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : this specialisation handles the variadic case and will be the only definition in future
template<class TAR, class BA, class RET, typename...ARGS> template<class TAR, class BA, class RET, typename...ARGS>
struct AcceptArgs<TAR,BA,RET, TySeq<ARGS...> > struct AcceptArgs<TAR,BA,RET, Types<ARGS...> >
: BA : BA
{ {
RET RET
@ -92,201 +85,15 @@ namespace control {
}; };
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisations become obsolete with the old-style type-sequence
/* specialisations for 0...9 Arguments.... */
template< class TAR, class BA, class RET /** @internal mix in a \c bind() function */
> //____________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<> > ///< Accept dummy binding (0 Arguments)
: BA
{
RET
operator() ()
{
return static_cast<TAR*> (this) -> bindArg (std::tuple<>() );
}
};
template< class TAR, class BA, class RET
, typename T1
> //_______________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1> > ///< Accept binding for 1 Argument
: BA
{
RET
operator() (T1 a1)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2> > ///< Accept binding for 2 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3> > ///< Accept binding for 3 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2, T3 a3)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4> > ///< Accept binding for 4 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2, T3 a3, T4 a4)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5> > ///< Accept binding for 5 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6> > ///< Accept binding for 6 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
, typename T7
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7> > ///< Accept binding for 7 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6,a7));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
, typename T7
, typename T8
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8> > ///< Accept binding for 8 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6,a7,a8));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
, typename T7
, typename T8
, typename T9
> //________________________________
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8,T9> > ///< Accept binding for 9 Arguments
: BA
{
RET
operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6,a7,a8,a9));
}
};
//
// _______________________________________________________________________________________________________________
/** @internal mix in a \c bind() function
* @todo variadic type-seq //////////////////////////////////////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic, then replace this by a single variadic template
*/
template< class TAR, class BA, class RET template< class TAR, class BA, class RET
, typename TYPES , typename TYPES
> >
struct AcceptBind ; struct AcceptBind ;
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : this specialisation handles the variadic case and will be the only definition in future
template<class TAR, class BA, class RET, typename...ARGS> template<class TAR, class BA, class RET, typename...ARGS>
struct AcceptBind<TAR,BA,RET, TySeq<ARGS...> > struct AcceptBind<TAR,BA,RET, Types<ARGS...> >
: BA : BA
{ {
RET RET
@ -297,191 +104,10 @@ namespace control {
}; };
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisations become obsolete with the old-style type-sequence
/* specialisations for 0...9 Arguments.... */
template< class TAR, class BA, class RET
> //____________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<> > ///< Accept dummy binding (0 Arguments)
: BA
{
RET
bind ()
{
return static_cast<TAR*> (this) -> bindArg (std::tuple<>() );
}
};
template< class TAR, class BA, class RET
, typename T1
> //_______________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1> > ///< Accept binding for 1 Argument
: BA
{
RET
bind (T1 a1)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2> > ///< Accept binding for 2 Arguments
: BA
{
RET
bind (T1 a1, T2 a2)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3> > ///< Accept binding for 3 Arguments
: BA
{
RET
bind (T1 a1, T2 a2, T3 a3)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4> > ///< Accept binding for 4 Arguments
: BA
{
RET
bind (T1 a1, T2 a2, T3 a3, T4 a4)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5> > ///< Accept binding for 5 Arguments
: BA
{
RET
bind (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6> > ///< Accept binding for 6 Arguments
: BA
{
RET
bind (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
, typename T7
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7> > ///< Accept binding for 7 Arguments
: BA
{
RET
bind (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6,a7));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
, typename T7
, typename T8
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8> > ///< Accept binding for 8 Arguments
: BA
{
RET
bind (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6,a7,a8));
}
};
template< class TAR, class BA, class RET
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
, typename T7
, typename T8
, typename T9
> //________________________________
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8,T9> > ///< Accept binding for 9 Arguments
: BA
{
RET
bind (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9)
{
return static_cast<TAR*> (this) -> bindArg (make_tuple (a1,a2,a3,a4,a5,a6,a7,a8,a9));
}
};
/** @internal mix in complete set of templated `bind()` functions
//
// _______________________________________________________________________________________________________________
/** @internal mix in complete set of templated \c bind() functions
*/ */
template< class TAR, class BA, class RET> template< class TAR, class BA, class RET>
struct AcceptAnyBind struct AcceptAnyBind
@ -524,7 +150,7 @@ namespace control {
template<typename...TYPES> template<typename...TYPES>
struct _Type<std::tuple<TYPES...> > struct _Type<std::tuple<TYPES...> >
{ {
using Args = typename TyOLD<TYPES...>::Seq; using Args = typename Types<TYPES...>::Seq;
using Ret = void; using Ret = void;
using Sig = typename BuildFunType<void, Args>::Sig; using Sig = typename BuildFunType<void, Args>::Sig;
using ArgTuple = std::tuple<TYPES...>; using ArgTuple = std::tuple<TYPES...>;

8
src/steam/control/command-signature.hpp
View file

@ -59,7 +59,7 @@ namespace control {
using lib::meta::BuildFunType; using lib::meta::BuildFunType;
using lib::meta::_Fun; using lib::meta::_Fun;
using lib::meta::TySeq; using lib::meta::Types;
using lib::meta::Append; using lib::meta::Append;
using lib::meta::PickLast; using lib::meta::PickLast;
@ -77,7 +77,7 @@ namespace control {
using Args = typename _Fun<SIG>::Args; using Args = typename _Fun<SIG>::Args;
using ArgList = typename Args::List; using ArgList = typename Args::List;
using ExtendedArglist = typename Append<ArgList, MEM>::List; using ExtendedArglist = typename Append<ArgList, MEM>::List;
using ExtendedArgs = typename TySeq<ExtendedArglist>::Seq; using ExtendedArgs = typename Types<ExtendedArglist>::Seq;
public: public:
using OperateSig = typename BuildFunType<void, Args>::Sig; using OperateSig = typename BuildFunType<void, Args>::Sig;
@ -118,7 +118,7 @@ namespace control {
using Memento = RET; using Memento = RET;
using ExtendedArglist = typename Append<ARG, Memento>::List; using ExtendedArglist = typename Append<ARG, Memento>::List;
using ExtendedArgs = typename TySeq<ExtendedArglist>::Seq; using ExtendedArgs = typename Types<ExtendedArglist>::Seq;
using OperateSig = typename BuildFunType<void, ARG>::Sig; using OperateSig = typename BuildFunType<void, ARG>::Sig;
using CaptureSig = typename BuildFunType<Ret,ARG>::Sig; using CaptureSig = typename BuildFunType<Ret,ARG>::Sig;
@ -132,7 +132,7 @@ namespace control {
using Memento = typename PickLast<Args>::Type; using Memento = typename PickLast<Args>::Type;
using OperationArglist = typename PickLast<Args>::List; using OperationArglist = typename PickLast<Args>::List;
using OperationArgs = typename TySeq<OperationArglist>::Seq; using OperationArgs = typename Types<OperationArglist>::Seq;
using OperateSig = typename BuildFunType<void, OperationArgs>::Sig; using OperateSig = typename BuildFunType<void, OperationArgs>::Sig;
using CaptureSig = typename BuildFunType<Ret,OperationArgs>::Sig; using CaptureSig = typename BuildFunType<Ret,OperationArgs>::Sig;

2
src/steam/control/command.hpp
View file

@ -88,7 +88,7 @@ namespace control {
using lib::Symbol; using lib::Symbol;
using std::shared_ptr; using std::shared_ptr;
using lib::meta::Tuple; using lib::meta::Tuple;
using lib::meta::TySeq; using lib::meta::Types;
using FuncPtr = void*; using FuncPtr = void*;

4
src/steam/engine/feed-manifold.hpp
View file

@ -101,7 +101,7 @@ namespace engine {
using lib::meta::forEachIDX; using lib::meta::forEachIDX;
using lib::meta::ElmTypes; using lib::meta::ElmTypes;
using lib::meta::Tagged; using lib::meta::Tagged;
using lib::meta::TySeq; using lib::meta::Types;
using lib::meta::Nil; using lib::meta::Nil;
using std::is_pointer; using std::is_pointer;
using std::is_reference; using std::is_reference;
@ -563,7 +563,7 @@ namespace engine {
}; };
using ElmsI = typename _Proc::ElmsI; using ElmsI = typename _Proc::ElmsI;
using ElmsO = typename _Proc::ElmsO; using ElmsO = typename _Proc::ElmsO;
using ElmsP = conditional_t<_Trait::hasParam(), typename _Proc::ArgP, TySeq<>>; using ElmsP = conditional_t<_Trait::hasParam(), typename _Proc::ArgP, Types<>>;
using Param = typename _Proc::SigP; ///////////////////////////////////////////////////////////////////OOO qualify? using Param = typename _Proc::SigP; ///////////////////////////////////////////////////////////////////OOO qualify?
template<template<class> class META> template<template<class> class META>

2
src/steam/mobject/builder/applicable-builder-target-types.hpp
View file

@ -58,7 +58,7 @@ namespace steam {
namespace mobject { namespace mobject {
namespace builder { namespace builder {
using BuilderTargetTypes = TySeq< session::Root using BuilderTargetTypes = Types< session::Root
, session::Clip , session::Clip
, session::Effect , session::Effect
, session::Binding , session::Binding

2
src/steam/mobject/builder/buildertool.hpp
View file

@ -159,7 +159,7 @@ namespace mobject {
{ } { }
; ;
using lib::meta::TySeq; // convenience for the users of "Applicable" using lib::meta::Types; // convenience for the users of "Applicable"
}// namespace mobject::builder }// namespace mobject::builder

2
src/steam/mobject/output-designation.hpp
View file

@ -113,7 +113,7 @@ namespace mobject {
{ VTABLE = sizeof(size_t) { VTABLE = sizeof(size_t)
, SPEC_SIZ = VTABLE , SPEC_SIZ = VTABLE
+ mp::maxSize< + mp::maxSize<
mp::TySeq< PID, lumiera_uid, uint>::List>() mp::Types< PID, lumiera_uid, uint>::List>()
}; };
typedef lib::OpaqueHolder<TargetSpec, SPEC_SIZ> SpecBuff; typedef lib::OpaqueHolder<TargetSpec, SPEC_SIZ> SpecBuff;

2
src/steam/mobject/session/session-impl.hpp
View file

@ -268,7 +268,7 @@ namespace session {
* to create "the session" instance and expose it through the * to create "the session" instance and expose it through the
* global Session PImpl * global Session PImpl
*/ */
using SessionImplAPI = SessionServices< TySeq< SessionServiceFetch using SessionImplAPI = SessionServices< Types< SessionServiceFetch
, SessionServiceMutate , SessionServiceMutate
, SessionServiceExploreScope , SessionServiceExploreScope
, SessionServiceMockIndex , SessionServiceMockIndex

2
src/steam/mobject/session/session-services.hpp
View file

@ -78,7 +78,7 @@ namespace mobject {
namespace session { namespace session {
using lib::meta::InstantiateChained; using lib::meta::InstantiateChained;
using lib::meta::TySeq; using lib::meta::Types;
/** /**

4
tests/basics/time/format-support-test.cpp
View file

@ -39,8 +39,8 @@ namespace test {
run (Arg) run (Arg)
{ {
SupportStandardTimecode just_fine; SupportStandardTimecode just_fine;
Supported just_smpte = Supported::formats< TySeq<Smpte> >(); Supported just_smpte = Supported::formats< Types<Smpte> >();
Supported just_simple = Supported::formats< TySeq<Frames,Seconds> >(); Supported just_simple = Supported::formats< Types<Frames,Seconds> >();
Supported& support1 (just_fine); Supported& support1 (just_fine);
Supported& support2 (just_smpte); Supported& support2 (just_smpte);

6
tests/basics/time/time-control-test.cpp
View file

@ -46,7 +46,7 @@ namespace test{
using lib::wrapper::ItemWrapper; using lib::wrapper::ItemWrapper;
using steam::asset::meta::TimeGrid; using steam::asset::meta::TimeGrid;
using lib::meta::TySeq; using lib::meta::Types;
using lib::meta::InstantiateChainedCombinations; using lib::meta::InstantiateChainedCombinations;
using LERR_(UNCONNECTED); using LERR_(UNCONNECTED);
@ -475,8 +475,8 @@ namespace test{
void void
TimeControl_test::verifyMatrix_of_MutationCases (TimeValue const& origVal, TimeValue const& change) TimeControl_test::verifyMatrix_of_MutationCases (TimeValue const& origVal, TimeValue const& change)
{ {
using KindsOfTarget = TySeq<Duration,TimeSpan,QuTime> ; // time entities to receive value changes using KindsOfTarget = Types<Duration,TimeSpan,QuTime> ; // time entities to receive value changes
using KindsOfSource = TySeq<TimeValue,Time,Duration,TimeSpan,QuTime>; // time entities to be used as change values using KindsOfSource = Types<TimeValue,Time,Duration,TimeSpan,QuTime>; // time entities to be used as change values
using TestMatrix = InstantiateChainedCombinations< KindsOfTarget using TestMatrix = InstantiateChainedCombinations< KindsOfTarget
, KindsOfSource , KindsOfSource
, TestCase // template to be instantiated for each type , TestCase // template to be instantiated for each type

7
tests/basics/visitingtool-extended-test.cpp
View file

@ -65,7 +65,7 @@ namespace test2 {
class Babbler class Babbler
: public Applicable< Babbler, : public Applicable< Babbler,
TySeq<Boss,BigBoss>::List, // treat this types Types<Boss,BigBoss>::List, // treat this types
VerboseVisitor<Tool> // intermediary base class VerboseVisitor<Tool> // intermediary base class
> >
{ {
@ -114,7 +114,7 @@ namespace test2 {
*/ */
class Blatherer class Blatherer
: public Applicable< Blatherer, : public Applicable< Blatherer,
TySeq<Visionary>::List, // get calls to Visionary dispatched Types<Visionary>::List, // get calls to Visionary dispatched
VerboseVisitor<Hastalavista> // note: different tool base class VerboseVisitor<Hastalavista> // note: different tool base class
> >
{ {
@ -137,7 +137,8 @@ namespace test2 {
*/ */
class VisitingToolExtended_test : public Test class VisitingToolExtended_test : public Test
{ {
virtual void run(Arg) virtual void
run(Arg)
{ {
known_visitor_known_class(); known_visitor_known_class();
visitor_not_visiting_some_class(); visitor_not_visiting_some_class();

16
tests/basics/visitingtool-test.cpp
View file

@ -58,6 +58,7 @@ namespace test1 {
class Leader : public Visionary class Leader : public Visionary
{ {
/* can not be visited */
}; };
@ -74,8 +75,8 @@ namespace test1 {
class Babbler class Babbler
: public Applicable< Babbler : public Applicable< Babbler
, TySeq<Boss,BigBoss,Visionary>::List // dispatch calls to this types , Types<Boss,BigBoss,Visionary>::List // dispatch calls to this types
, VerboseVisitor , VerboseVisitor // (base class / interface)
> >
{ {
public: public:
@ -83,9 +84,9 @@ namespace test1 {
void treat (BigBoss&) { talk_to("Big Boss"); } void treat (BigBoss&) { talk_to("Big Boss"); }
}; };
// note the following details: // note the following fine points:
// - Babbler "forgot" to declare being applicable to HomoSapiens // - Babbler "forgot" to declare being applicable to HomoSapiens
// - we have new derived class Leader without separate "apply()"-implementation // - the class Leader hidden deep in the hierarchy is lacking an "apply()"-implementation
@ -116,12 +117,12 @@ namespace test1 {
BigBoss x2; BigBoss x2;
// masquerade as HomoSapiens... // masquerade as HomoSapiens...
HomoSapiens& homo1 (x1); HomoSapiens& homo1{x1};
HomoSapiens& homo2 (x2); HomoSapiens& homo2{x2};
cout << "=== Babbler meets Boss and BigBoss ===\n"; cout << "=== Babbler meets Boss and BigBoss ===\n";
Babbler bab; Babbler bab;
VisitingTool& vista (bab); VisitingTool& vista{bab};
homo1.apply (vista); homo1.apply (vista);
homo2.apply (vista); homo2.apply (vista);
} }
@ -141,7 +142,6 @@ namespace test1 {
homo1.apply (vista); // silent error handler (not Applicable to HomoSapiens) homo1.apply (vista); // silent error handler (not Applicable to HomoSapiens)
homo2.apply (vista); // Leader handled as Visionary and treated as Boss homo2.apply (vista); // Leader handled as Visionary and treated as Boss
} }
}; };

5
tests/core/steam/control/command-clone-builder-test.cpp
View file

@ -111,8 +111,7 @@ namespace test {
void void
bindRandArgument (CommandImpl& cmd) bindRandArgument (CommandImpl& cmd)
{ {
using ArgType = TySeq<int>; TypedArguments<std::tuple<int>> arg {std::make_tuple (rani (10000))};
TypedArguments<Tuple<ArgType>> arg (std::make_tuple (rani (10000)));
cmd.setArguments (arg); cmd.setArguments (arg);
CHECK (cmd.canExec()); CHECK (cmd.canExec());
} }
@ -126,7 +125,7 @@ namespace test {
void void
verifySeparation (PCmdImpl orig, PCmdImpl copy) verifySeparation (PCmdImpl orig, PCmdImpl copy)
{ {
CHECK (orig && copy); CHECK (orig and copy);
CHECK (orig->canExec()); CHECK (orig->canExec());
CHECK (copy->canExec()); CHECK (copy->canExec());

2
tests/core/steam/control/command-equality-test.cpp
View file

@ -79,7 +79,7 @@ namespace test {
typedef function<Sig_capt> Fun_c; typedef function<Sig_capt> Fun_c;
typedef function<Sig_undo> Fun_u; typedef function<Sig_undo> Fun_u;
using ArgTuple = Tuple<TySeq<char>>; using ArgTuple = std::tuple<char>;
using ArgHolder = OpClosure<Sig_oper>; using ArgHolder = OpClosure<Sig_oper>;
using MemHolder = MementoTie<Sig_oper, string>; using MemHolder = MementoTie<Sig_oper, string>;
using Closure = SimpleClosure<Sig_oper>; using Closure = SimpleClosure<Sig_oper>;

4
tests/core/steam/control/command-mutation-test.cpp
View file

@ -107,7 +107,7 @@ namespace test {
VERIFY_ERROR (UNBOUND_ARGUMENTS, functor(nullClosure) ); VERIFY_ERROR (UNBOUND_ARGUMENTS, functor(nullClosure) );
// now create a real closure.... // now create a real closure....
Tuple<TySeq<int>> param = std::make_tuple (23); std::tuple<int> param = std::make_tuple(23);
SimpleClosure<void(int)> closed_over{param}; SimpleClosure<void(int)> closed_over{param};
CmdClosure& closure (closed_over); CmdClosure& closure (closed_over);
@ -154,7 +154,7 @@ namespace test {
VERIFY_ERROR (UNBOUND_ARGUMENTS, undoFunctor(nullClosure) ); VERIFY_ERROR (UNBOUND_ARGUMENTS, undoFunctor(nullClosure) );
VERIFY_ERROR (UNBOUND_ARGUMENTS, undoFunctor.captureState(nullClosure) ); VERIFY_ERROR (UNBOUND_ARGUMENTS, undoFunctor.captureState(nullClosure) );
Tuple<TySeq<>> param; Tuple<Types<>> param;
SimpleClosure<void()> clo{param}; SimpleClosure<void()> clo{param};
CHECK (!mementoHolder); CHECK (!mementoHolder);

6
tests/core/steam/control/command-registry-test.cpp
View file

@ -190,7 +190,7 @@ namespace test {
// when the CommandDef is complete, it issues the // when the CommandDef is complete, it issues the
// allocation call to the registry behind the scenes.... // allocation call to the registry behind the scenes....
typedef shared_ptr<CommandImpl> PImpl; using PImpl = shared_ptr<CommandImpl>;
PImpl pImpl = registry.newCommandImpl(o_Fun,c_Fun,u_Fun); PImpl pImpl = registry.newCommandImpl(o_Fun,c_Fun,u_Fun);
CHECK (1+cnt_inst == registry.instance_count()); CHECK (1+cnt_inst == registry.instance_count());
@ -210,8 +210,8 @@ namespace test {
CHECK (!isSameObject (*pImpl, *clone)); CHECK (!isSameObject (*pImpl, *clone));
CHECK (!pImpl->canExec()); CHECK (!pImpl->canExec());
using ArgType = TySeq<int>; using ArgTuple = std::tuple<int>;
TypedArguments<Tuple<ArgType>> arg{Tuple<ArgType>(98765)}; TypedArguments<ArgTuple> arg{ArgTuple{98765}};
pImpl->setArguments(arg); pImpl->setArguments(arg);
CHECK (pImpl->canExec()); CHECK (pImpl->canExec());

6
tests/core/steam/control/handling-pattern-basics-test.cpp
View file

@ -168,10 +168,10 @@ namespace test {
CHECK (com); CHECK (com);
CHECK (not com->canExec()); CHECK (not com->canExec());
using ArgType = TySeq<int>; using ArgTuple = std::tuple<int>;
const int ARGR{1 + rani (1000)}; const int ARGR{1 + rani (1000)};
Tuple<ArgType> tuple(ARGR); ArgTuple argTup{ARGR};
TypedArguments<Tuple<ArgType>> arg(tuple); TypedArguments<ArgTuple> arg{argTup};
com->setArguments(arg); com->setArguments(arg);
CHECK (com->canExec()); CHECK (com->canExec());

2
tests/core/steam/mobject/builder/builder-tool-test.cpp
View file

@ -59,7 +59,7 @@ namespace test {
* so it will call the \c onUnknown(Buildable&) instead * so it will call the \c onUnknown(Buildable&) instead
*/ */
class TestTool class TestTool
: public Applicable<TestTool, TySeq<Clip, DummyMO>::List> : public Applicable<TestTool, Types<Clip, DummyMO>::List>
{ {
public: public:
string log_; string log_;

4
tests/core/steam/mobject/session/session-service-access-test.cpp
View file

@ -41,7 +41,7 @@ namespace test {
namespace { // what follows is a simulated (simplified) version namespace { // what follows is a simulated (simplified) version
// of the complete Session + SessionManager setup..... // of the complete Session + SessionManager setup.....
using lib::meta::TySeq; using lib::meta::Types;
using lib::meta::InstantiateChained; using lib::meta::InstantiateChained;
@ -161,7 +161,7 @@ namespace test {
struct TSessManagerImpl; struct TSessManagerImpl;
using SessionImplAPI = TSessionServices< TySeq<InternalAPI_1,InternalAPI_2> using SessionImplAPI = TSessionServices< Types<InternalAPI_1,InternalAPI_2>
, TSessManagerImpl , TSessManagerImpl
, TSessionImpl , TSessionImpl
>; >;

20
tests/library/meta/function-closure-test.cpp
View file

@ -46,8 +46,8 @@ namespace test {
namespace { // test data namespace { // test data
using List1 = TySeq<Num<1>, Num<2>, Num<3> >::List; using List1 = Types<Num<1>, Num<2>, Num<3> >::List;
using List2 = TySeq<Num<5>, Num<6>, Num<7> >::List; using List2 = Types<Num<5>, Num<6>, Num<7> >::List;
/** special test fun /** special test fun
@ -140,10 +140,10 @@ namespace test {
{ {
cout << "\t:\n\t: ---Bind----\n"; cout << "\t:\n\t: ---Bind----\n";
Tuple<TySeq<>> tup0 ; Tuple<Types<>> tup0 ;
Tuple<TySeq<int>> tup1 (11); Tuple<Types<int>> tup1 (11);
Tuple<TySeq<int,int>> tup2 (11,12); Tuple<Types<int,int>> tup2 (11,12);
Tuple<TySeq<int,int,int>> tup3 (11,12,13); Tuple<Types<int,int,int>> tup3 (11,12,13);
DUMPVAL (tup0); DUMPVAL (tup0);
DUMPVAL (tup1); DUMPVAL (tup1);
DUMPVAL (tup2); DUMPVAL (tup2);
@ -167,10 +167,10 @@ namespace test {
void void
check_bindFunc () check_bindFunc ()
{ {
Tuple<TySeq<>> tup0 ; Tuple<Types<>> tup0 ;
Tuple<TySeq<int>> tup1 (11); Tuple<Types<int>> tup1 (11);
Tuple<TySeq<int,int>> tup2 (11,12); Tuple<Types<int,int>> tup2 (11,12);
Tuple<TySeq<int,int,int>> tup3 (11,12,13); Tuple<Types<int,int,int>> tup3 (11,12,13);
function<int()> unbound_functor0 (fun0); function<int()> unbound_functor0 (fun0);
function<int(int)> unbound_functor1 (fun1); function<int(int)> unbound_functor1 (fun1);
function<int(int,int)> unbound_functor2 (fun2); function<int(int,int)> unbound_functor2 (fun2);

6
tests/library/meta/function-composition-test.cpp
View file

@ -198,7 +198,7 @@ namespace test {
// Version2: extract the binding arguments from a tuple--- // // Version2: extract the binding arguments from a tuple--- //
using PartialArg = Tuple<TySeq<Num<1>, PH1, PH2>>; // Tuple type to hold the binding values. Note the placeholder types using PartialArg = Tuple<Types<Num<1>, PH1, PH2>>; // Tuple type to hold the binding values. Note the placeholder types
PartialArg arg{num18, PH1(), PH2()}; // Value for partial application (the placeholders are default constructed) PartialArg arg{num18, PH1(), PH2()}; // Value for partial application (the placeholders are default constructed)
fun_23 = std::bind (f, get<0>(arg) // now extract the values to bind from this tuple fun_23 = std::bind (f, get<0>(arg) // now extract the values to bind from this tuple
@ -219,7 +219,7 @@ namespace test {
// Version3: let the PApply-template do the work for us--- // // Version3: let the PApply-template do the work for us--- //
using ArgTypes = TySeq<Num<1>>; // now package just the argument(s) to be applied into a tuple using ArgTypes = Types<Num<1>>; // now package just the argument(s) to be applied into a tuple
Tuple<ArgTypes> args_to_bind{Num<1>(18)}; Tuple<ArgTypes> args_to_bind{Num<1>(18)};
fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind); fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind);
@ -281,7 +281,7 @@ namespace test {
// covering the general case of partial function closure: // covering the general case of partial function closure:
typedef Num<5> Sig54321 (Num<5>, Num<4>, Num<3>, Num<2>, Num<1>); // Signature of the 5-argument function typedef Num<5> Sig54321 (Num<5>, Num<4>, Num<3>, Num<2>, Num<1>); // Signature of the 5-argument function
typedef Num<5> Sig54 (Num<5>, Num<4>); // ...closing the last 3 arguments should yield this 2-argument function typedef Num<5> Sig54 (Num<5>, Num<4>); // ...closing the last 3 arguments should yield this 2-argument function
using Args2Close = TySeq<Num<3>, Num<2>, Num<1>>; // Tuple type to hold the 3 argument values used for the closure using Args2Close = Types<Num<3>, Num<2>, Num<1>>; // Tuple type to hold the 3 argument values used for the closure
// Close the trailing 3 arguments of the 5-argument function... // Close the trailing 3 arguments of the 5-argument function...
function<Sig54> fun_54 = PApply<Sig54321,Args2Close>::bindBack (fun15<5,4,3,2,1> function<Sig54> fun_54 = PApply<Sig54321,Args2Close>::bindBack (fun15<5,4,3,2,1>

4
tests/library/meta/generator-combinations-test.cpp
View file

@ -35,11 +35,11 @@ namespace test {
namespace { // test cases and data.... namespace { // test cases and data....
typedef TySeq< Num<1> typedef Types< Num<1>
, Num<3> , Num<3>
, Num<5> , Num<5>
> Types1; > Types1;
typedef TySeq< Num<2> typedef Types< Num<2>
, Num<4> , Num<4>
, Num<6> , Num<6>
> Types2; > Types2;

2
tests/library/meta/generator-test.cpp
View file

@ -88,7 +88,7 @@ namespace test {
using BASE::eat; // prevent shadowing using BASE::eat; // prevent shadowing
}; };
using TheTypes = TySeq< Block<1> using TheTypes = Types< Block<1>
, Block<2> , Block<2>
, Block<3> , Block<3>
, Block<5> , Block<5>

2
tests/library/meta/meta-utils-test.cpp
View file

@ -203,7 +203,7 @@ namespace test {
//-------------------------------------------------TEST-types-- //-------------------------------------------------TEST-types--
using TheList = TySeq<int using TheList = Types<int
,uint ,uint
,int64_t ,int64_t
,uint64_t ,uint64_t

8
tests/library/meta/tuple-helper-test.cpp
View file

@ -44,14 +44,14 @@ namespace test {
namespace { // test data namespace { // test data
typedef TySeq< Num<1> typedef Types< Num<1>
, Num<3> , Num<3>
, Num<5> , Num<5>
> Types1; > Types1;
typedef TySeq< Num<2> typedef Types< Num<2>
, Num<4> , Num<4>
> Types2; > Types2;
typedef TySeq< Num<7>> Types3; typedef Types< Num<7>> Types3;
@ -132,7 +132,7 @@ namespace test {
Prepend prep (22, 11,33,Num<5>()); Prepend prep (22, 11,33,Num<5>());
CHECK (toString(prep) == "«tuple<int, Num<1>, Num<3>, Num<5> >»──(22,{11},{33},(5))"_expect); CHECK (toString(prep) == "«tuple<int, Num<1>, Num<3>, Num<5> >»──(22,{11},{33},(5))"_expect);
using NulT = Tuple<TySeq<> >; // plain-flat empty Tuple using NulT = Tuple<Types<> >; // plain-flat empty Tuple
using NulL = Tuple<Nil>; // list-style empty Tuple using NulL = Tuple<Nil>; // list-style empty Tuple
NulT nulT; // and these, too, can be instantiated NulT nulT; // and these, too, can be instantiated

20
tests/library/meta/tuple-record-init-test.cpp
View file

@ -31,7 +31,7 @@ using lib::idi::EntryID;
using lib::diff::Rec; using lib::diff::Rec;
using lib::diff::MakeRec; using lib::diff::MakeRec;
using lib::diff::GenNode; using lib::diff::GenNode;
using lib::meta::TySeq; using lib::meta::Types;
using lib::meta::Tuple; using lib::meta::Tuple;
using lib::meta::buildTuple; using lib::meta::buildTuple;
using lib::time::Duration; using lib::time::Duration;
@ -82,8 +82,8 @@ namespace test {
void void
show_simpleUsage() show_simpleUsage()
{ {
using NiceTypes = TySeq<string, int>; using NiceTypes = Types<string, int>;
using UgglyTypes = TySeq<EntryID<long>, Symbol, int, int64_t, double, Duration>; // various conversions and an immutable type (Duration) using UgglyTypes = Types<EntryID<long>, Symbol, int, int64_t, double, Duration>; // various conversions and an immutable type (Duration)
Rec args = MakeRec().scope("lalü", 42); Rec args = MakeRec().scope("lalü", 42);
Rec urgs = MakeRec().scope("lalü", "lala", 12, 34, 5.6, Time(7,8,9)); Rec urgs = MakeRec().scope("lalü", "lala", 12, 34, 5.6, Time(7,8,9));
@ -108,19 +108,19 @@ namespace test {
{ {
Rec args = MakeRec().scope("surprise", 42); Rec args = MakeRec().scope("surprise", 42);
using TooMany = TySeq<string, int, long>; using TooMany = Types<string, int, long>;
VERIFY_ERROR (WRONG_TYPE, buildTuple<TooMany> (args)); // number of types in tuple exceeds capacity of the supplied argument record VERIFY_ERROR (WRONG_TYPE, buildTuple<TooMany> (args)); // number of types in tuple exceeds capacity of the supplied argument record
using Unsigned = TySeq<string, uint>; using Unsigned = Types<string, uint>;
using Floating = TySeq<string, float>; using Floating = Types<string, float>;
using Narrowing = TySeq<string, short>; using Narrowing = Types<string, short>;
VERIFY_ERROR (WRONG_TYPE, buildTuple<Unsigned> (args)); // dangerous conversion from signed to unsigned int is prohibited VERIFY_ERROR (WRONG_TYPE, buildTuple<Unsigned> (args)); // dangerous conversion from signed to unsigned int is prohibited
VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args)); // conversion from integral to floating point element is prohibited VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args)); // conversion from integral to floating point element is prohibited
VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args)); // narrowing conversion from int to short is prohibited VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args)); // narrowing conversion from int to short is prohibited
// yet other (non-numeric) conversions are still possible // yet other (non-numeric) conversions are still possible
Rec timeArg = MakeRec().scope(Time(1,2,3,4)); Rec timeArg = MakeRec().scope(Time(1,2,3,4));
using TupStr = TySeq<string>; using TupStr = Types<string>;
Tuple<TupStr> tup = buildTuple<TupStr> (timeArg); Tuple<TupStr> tup = buildTuple<TupStr> (timeArg);
CHECK (std::get<string> (tup) == "4:03:02.001"); CHECK (std::get<string> (tup) == "4:03:02.001");
@ -133,7 +133,7 @@ namespace test {
VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args)); VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args));
VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args)); VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args));
using ToSizeT = TySeq<string, size_t>; using ToSizeT = Types<string, size_t>;
VERIFY_ERROR (WRONG_TYPE, (buildTuple<ToSizeT> (args))); // not even conversion to size_t is allowed VERIFY_ERROR (WRONG_TYPE, (buildTuple<ToSizeT> (args))); // not even conversion to size_t is allowed
struct Hashy struct Hashy
@ -145,7 +145,7 @@ namespace test {
{ } { }
}; };
using WithHashy = TySeq<string, Hashy>; using WithHashy = Types<string, Hashy>;
Tuple<WithHashy> tup2 = buildTuple<WithHashy> (hashArg); // while any type explicitly constructible from LUID are permitted. Tuple<WithHashy> tup2 = buildTuple<WithHashy> (hashArg); // while any type explicitly constructible from LUID are permitted.
VERIFY_ERROR (WRONG_TYPE, buildTuple<WithHashy> (args)); // building a `Hashy` from int(42) is disallowed, of course VERIFY_ERROR (WRONG_TYPE, buildTuple<WithHashy> (args)); // building a `Hashy` from int(42) is disallowed, of course

30
tests/library/meta/typelist-manip-test.cpp
View file

@ -45,11 +45,11 @@ namespace test {
namespace { // type-lists to test with namespace { // type-lists to test with
using List1 = TySeq< Num<1> using List1 = Types< Num<1>
, Num<2> , Num<2>
, Num<3> , Num<3>
>::List; >::List;
using List2 = TySeq< Num<5> using List2 = Types< Num<5>
, Num<6> , Num<6>
, Num<7> , Num<7>
>::List; >::List;
@ -158,7 +158,7 @@ namespace test {
using Elm = PickLast<List1>::Type; using Elm = PickLast<List1>::Type;
using Prefix = PickLast<List1>::List; using Prefix = PickLast<List1>::List;
using ElmL = TySeq<Elm>::List; using ElmL = Types<Elm>::List;
EXPECT (Prefix, "-<1>-<2>-"); EXPECT (Prefix, "-<1>-<2>-");
EXPECT (ElmL , "-<3>-" ); EXPECT (ElmL , "-<3>-" );
@ -166,7 +166,7 @@ namespace test {
using Elm1 = PickLast<ElmL>::Type; using Elm1 = PickLast<ElmL>::Type;
using NPrefix = PickLast<ElmL>::List; using NPrefix = PickLast<ElmL>::List;
EXPECT (TySeq<Elm1>, "-<3>-"); EXPECT (Types<Elm1>, "-<3>-");
EXPECT (NPrefix , "-"); EXPECT (NPrefix , "-");
using NilSplit = PickLast<Nil>::Type; using NilSplit = PickLast<Nil>::Type;
@ -204,16 +204,16 @@ namespace test {
void void
verify_splice () verify_splice ()
{ // various base lists { // various base lists
using BaLi1 = TySeq<Num<1>>::List; EXPECT (BaLi1, "-<1>-"); using BaLi1 = Types<Num<1>>::List; EXPECT (BaLi1, "-<1>-");
using BaLi2 = TySeq<Num<1>,Num<2>>::List; EXPECT (BaLi2, "-<1>-<2>-"); using BaLi2 = Types<Num<1>,Num<2>>::List; EXPECT (BaLi2, "-<1>-<2>-");
using BaLi3 = TySeq<Num<1>,Num<2>,Num<3>>::List; EXPECT (BaLi3, "-<1>-<2>-<3>-"); using BaLi3 = Types<Num<1>,Num<2>,Num<3>>::List; EXPECT (BaLi3, "-<1>-<2>-<3>-");
using BaLi5 = TySeq<Num<1>,Num<2>,Num<3>,Num<4>,Num<5>>::List; using BaLi5 = Types<Num<1>,Num<2>,Num<3>,Num<4>,Num<5>>::List;
EXPECT (BaLi5, "-<1>-<2>-<3>-<4>-<5>-"); EXPECT (BaLi5, "-<1>-<2>-<3>-<4>-<5>-");
// will "paste" those overlay lists "on top" the base typelists... // will "paste" those overlay lists "on top" the base typelists...
using OLi1 = TySeq<Num<9>>::List; EXPECT (OLi1, "-<9>-"); using OLi1 = Types<Num<9>>::List; EXPECT (OLi1, "-<9>-");
using OLi2 = TySeq<Num<9>,Num<8>>::List; EXPECT (OLi2, "-<9>-<8>-"); using OLi2 = Types<Num<9>,Num<8>>::List; EXPECT (OLi2, "-<9>-<8>-");
using OLi3 = TySeq<Num<9>,Num<8>,Num<7>>::List; EXPECT (OLi3, "-<9>-<8>-<7>-"); using OLi3 = Types<Num<9>,Num<8>,Num<7>>::List; EXPECT (OLi3, "-<9>-<8>-<7>-");
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
@ -472,7 +472,7 @@ namespace test {
using Head = Dissect<LL>::Head; using Head = Dissect<LL>::Head;
using End = Dissect<LL>::End; using End = Dissect<LL>::End;
using HeadEnd = TySeq<Head,End>; EXPECT (HeadEnd, "-<1>-<7>-"); using HeadEnd = Types<Head,End>; EXPECT (HeadEnd, "-<1>-<7>-");
} }
@ -538,7 +538,7 @@ namespace test {
// Notably this can also be used to distribute into an already nested structure, // Notably this can also be used to distribute into an already nested structure,
// since the implementation is based on Append, which will actually concatenate lists // since the implementation is based on Append, which will actually concatenate lists
// To demonstrate this, we first create a mixed list, where some elements are nested lists // To demonstrate this, we first create a mixed list, where some elements are nested lists
using List_of_Lists = TySeq<List1::List using List_of_Lists = Types<List1::List
,Num<0> // ◁—————————————— this one is a regular element ,Num<0> // ◁—————————————— this one is a regular element
,List2::List>::List; ,List2::List>::List;
EXPECT (List_of_Lists, EXPECT (List_of_Lists,
@ -573,7 +573,7 @@ namespace test {
"\n\t" "+---<11>-<2>-+" "\n\t" "+---<11>-<2>-+"
"\n\t" "+---<11>-<3>-+-"); "\n\t" "+---<11>-<3>-+-");
using Prefixes = TySeq<Num<11>,Num<22>,Num<33>>::List; using Prefixes = Types<Num<11>,Num<22>,Num<33>>::List;
using Dist2 = Distribute<Prefixes, Num<0>>; using Dist2 = Distribute<Prefixes, Num<0>>;
EXPECT (Dist2, "\n\t" "+---<11>-<0>-+" EXPECT (Dist2, "\n\t" "+---<11>-<0>-+"
"\n\t" "+---<22>-<0>-+" "\n\t" "+---<22>-<0>-+"
@ -590,7 +590,7 @@ namespace test {
"\n\t" "+---<33>-<2>-+" "\n\t" "+---<33>-<2>-+"
"\n\t" "+---<33>-<3>-+-"); "\n\t" "+---<33>-<3>-+-");
using LioLi = TySeq<List1::List,List2::List>::List; using LioLi = Types<List1::List,List2::List>::List;
EXPECT (LioLi, "\n\t" "+---<1>-<2>-<3>-+" EXPECT (LioLi, "\n\t" "+---<1>-<2>-<3>-+"
"\n\t" "+---<5>-<6>-<7>-+-"); "\n\t" "+---<5>-<6>-<7>-+-");
using Dist4 = Distribute<Prefixes, LioLi>; using Dist4 = Distribute<Prefixes, LioLi>;

2
tests/library/meta/typelist-test.cpp
View file

@ -40,7 +40,7 @@ namespace test {
}; };
using SequenceOfTypes = TySeq< Block<21> using SequenceOfTypes = Types< Block<21>
, Block<13> , Block<13>
, Block<8> , Block<8>
, Block<5> , Block<5>

4
tests/library/meta/typelist-util-test.cpp
View file

@ -27,13 +27,13 @@ namespace test {
using TheList = TySeq< int using TheList = Types< int
, uint , uint
, int64_t , int64_t
, uint64_t , uint64_t
>::List; >::List;
using EmptyList = TySeq< >::List; using EmptyList = Types< >::List;

50
tests/library/meta/typeseq-manip-test.cpp
View file

@ -43,14 +43,14 @@ namespace test {
namespace { // type-sequences to test with namespace { // type-sequences to test with
typedef TySeq< Num<1> using Types1 = Types< Num<1>
, Num<2> , Num<2>
, Num<3> , Num<3>
> Types1; >;
typedef TySeq< Num<7> using Types2 = Types< Num<7>
, Num<8> , Num<8>
, Num<9> , Num<9>
> Types2; >;
} // (End) test data } // (End) test data
@ -96,12 +96,12 @@ namespace test {
using LL = Append<Types1::List, Types2::List>::List; using LL = Append<Types1::List, Types2::List>::List;
EXPECT (LL, "-<1>-<2>-<3>-<7>-<8>-<9>-"); EXPECT (LL, "-<1>-<2>-<3>-<7>-<8>-<9>-");
using Seq = TySeq<LL>::Seq; using Seq = Types<LL>::Seq;
using SeqList = Seq::List; using SeqList = Seq::List;
EXPECT (Seq, "-<1>-<2>-<3>-<7>-<8>-<9>-"); EXPECT (Seq, "-<1>-<2>-<3>-<7>-<8>-<9>-");
EXPECT (SeqList, "-<1>-<2>-<3>-<7>-<8>-<9>-"); EXPECT (SeqList, "-<1>-<2>-<3>-<7>-<8>-<9>-");
using NulS = TySeq<NilNode>::Seq; using NulS = Types<NilNode>::Seq;
EXPECT (NulS, "-"); EXPECT (NulS, "-");
} }
@ -111,8 +111,8 @@ namespace test {
{ {
using Prepend1 = Prepend<Num<5>, Types1 >; EXPECT (Prepend1, "-<5>-<1>-<2>-<3>-"); using Prepend1 = Prepend<Num<5>, Types1 >; EXPECT (Prepend1, "-<5>-<1>-<2>-<3>-");
using Prepend2 = Prepend<Nil, Types1 >; EXPECT (Prepend2, "-<·>-<1>-<2>-<3>-"); using Prepend2 = Prepend<Nil, Types1 >; EXPECT (Prepend2, "-<·>-<1>-<2>-<3>-");
using Prepend3 = Prepend<Num<5>, TySeq<>>; EXPECT (Prepend3, "-<5>-"); using Prepend3 = Prepend<Num<5>, Types<>>; EXPECT (Prepend3, "-<5>-");
using Prepend4 = Prepend<Nil, TySeq<>>; EXPECT (Prepend4, "-"); using Prepend4 = Prepend<Nil, Types<>>; EXPECT (Prepend4, "-");
} }
@ -120,7 +120,7 @@ namespace test {
check_shift () check_shift ()
{ {
using LL = Append<Types2::List, Types1::List>::List; using LL = Append<Types2::List, Types1::List>::List;
using Seq = TySeq<LL>::Seq; using Seq = Types<LL>::Seq;
using Seq_0 = Shifted<Seq,0>::Type; EXPECT (Seq_0, "-<7>-<8>-<9>-<1>-<2>-<3>-"); using Seq_0 = Shifted<Seq,0>::Type; EXPECT (Seq_0, "-<7>-<8>-<9>-<1>-<2>-<3>-");
using Seq_1 = Shifted<Seq,1>::Type; EXPECT (Seq_1, "-<8>-<9>-<1>-<2>-<3>-"); using Seq_1 = Shifted<Seq,1>::Type; EXPECT (Seq_1, "-<8>-<9>-<1>-<2>-<3>-");
@ -130,14 +130,14 @@ namespace test {
using Seq_5 = Shifted<Seq,5>::Type; EXPECT (Seq_5, "-<3>-"); using Seq_5 = Shifted<Seq,5>::Type; EXPECT (Seq_5, "-<3>-");
using Seq_6 = Shifted<Seq,6>::Type; EXPECT (Seq_6, "-"); using Seq_6 = Shifted<Seq,6>::Type; EXPECT (Seq_6, "-");
using Head_0 = TySeq<Shifted<Seq,0>::Head>; EXPECT (Head_0, "-<7>-"); using Head_0 = Types<Shifted<Seq,0>::Head>; EXPECT (Head_0, "-<7>-");
using Head_1 = TySeq<Shifted<Seq,1>::Head>; EXPECT (Head_1, "-<8>-"); using Head_1 = Types<Shifted<Seq,1>::Head>; EXPECT (Head_1, "-<8>-");
using Head_2 = TySeq<Shifted<Seq,2>::Head>; EXPECT (Head_2, "-<9>-"); using Head_2 = Types<Shifted<Seq,2>::Head>; EXPECT (Head_2, "-<9>-");
using Head_3 = TySeq<Shifted<Seq,3>::Head>; EXPECT (Head_3, "-<1>-"); using Head_3 = Types<Shifted<Seq,3>::Head>; EXPECT (Head_3, "-<1>-");
using Head_4 = TySeq<Shifted<Seq,4>::Head>; EXPECT (Head_4, "-<2>-"); using Head_4 = Types<Shifted<Seq,4>::Head>; EXPECT (Head_4, "-<2>-");
using Head_5 = TySeq<Shifted<Seq,5>::Head>; EXPECT (Head_5, "-<3>-"); using Head_5 = Types<Shifted<Seq,5>::Head>; EXPECT (Head_5, "-<3>-");
using Head_6 = TySeq<Shifted<Seq,6>::Head>; EXPECT (Head_6, "-" ); using Head_6 = Types<Shifted<Seq,6>::Head>; EXPECT (Head_6, "-" );
using Head_7 = TySeq<Shifted<Seq,7>::Head>; EXPECT (Head_7, "-" ); using Head_7 = Types<Shifted<Seq,7>::Head>; EXPECT (Head_7, "-" );
} }
@ -145,7 +145,7 @@ namespace test {
check_split () check_split ()
{ {
using LL = Append<Types1::List, Types2::List>::List; using LL = Append<Types1::List, Types2::List>::List;
using Seq = TySeq<LL>::Seq; EXPECT (Seq , "-<1>-<2>-<3>-<7>-<8>-<9>-"); using Seq = Types<LL>::Seq; EXPECT (Seq , "-<1>-<2>-<3>-<7>-<8>-<9>-");
using List = Split<Seq>::List; EXPECT (List , "-<1>-<2>-<3>-<7>-<8>-<9>-"); using List = Split<Seq>::List; EXPECT (List , "-<1>-<2>-<3>-<7>-<8>-<9>-");
using First = Split<Seq>::First; EXPECT (First , "-<1>-" ); using First = Split<Seq>::First; EXPECT (First , "-<1>-" );
@ -156,10 +156,10 @@ namespace test {
using Head = Split<Seq>::Head; using Head = Split<Seq>::Head;
using End = Split<Seq>::End; using End = Split<Seq>::End;
using Ends = TySeq<Head,End>; EXPECT (Ends , "-<1>-<9>-"); using Ends = Types<Head,End>; EXPECT (Ends , "-<1>-<9>-");
using NoList = Split<TySeq<>>::List; EXPECT (NoList, "-"); using NoList = Split<Types<>>::List; EXPECT (NoList, "-");
using NoHead = Split<TySeq<>>::Head; EXPECT (NoHead, "-"); using NoHead = Split<Types<>>::Head; EXPECT (NoHead, "-");
} }

16
tests/library/meta/variadic-helper-test.cpp
View file

@ -71,12 +71,12 @@ namespace test {
using S1 = ElmTypes<T1>; using S1 = ElmTypes<T1>;
CHECK (2 == S1::SIZ); CHECK (2 == S1::SIZ);
CHECK (showType< S1 >() == "ElmTypes<tuple<int, double>, void>"_expect); CHECK (showType< S1 >() == "ElmTypes<tuple<int, double>, void>"_expect);
CHECK (showType< S1::Seq >() == "TySeq<int, double>"_expect); CHECK (showType< S1::Seq >() == "Types<int, double>"_expect);
CHECK (showType< S1::Tup >() == "tuple<int, double>"_expect); CHECK (showType< S1::Tup >() == "tuple<int, double>"_expect);
CHECK (showType< S1::Idx >() == "integer_sequence<ulong, 0ul, 1ul>"_expect); CHECK (showType< S1::Idx >() == "integer_sequence<ulong, 0ul, 1ul>"_expect);
using S1A = S1::Apply<std::is_pointer>; using S1A = S1::Apply<std::is_pointer>;
CHECK (showType< S1A >() == "TySeq<is_pointer<int>, is_pointer<double> >"_expect); CHECK (showType< S1A >() == "Types<is_pointer<int>, is_pointer<double> >"_expect);
using S1AR = ElmTypes<S1A>::Rebind<std::__and_>; using S1AR = ElmTypes<S1A>::Rebind<std::__and_>;
CHECK (showType< S1AR >() == "__and_<is_pointer<int>, is_pointer<double> >"_expect); CHECK (showType< S1AR >() == "__and_<is_pointer<int>, is_pointer<double> >"_expect);
@ -98,12 +98,12 @@ namespace test {
using S0 = ElmTypes<T0>; using S0 = ElmTypes<T0>;
CHECK (1 == S0::SIZ); CHECK (1 == S0::SIZ);
CHECK (showType< S0 >() == "ElmTypes<int*, void>"_expect); CHECK (showType< S0 >() == "ElmTypes<int*, void>"_expect);
CHECK (showType< S0::Seq >() == "TySeq<int*>"_expect); CHECK (showType< S0::Seq >() == "Types<int*>"_expect);
CHECK (showType< S0::Tup >() == "tuple<int*>"_expect); CHECK (showType< S0::Tup >() == "tuple<int*>"_expect);
CHECK (showType< S0::Idx >() == "integer_sequence<ulong, 1ul>"_expect); CHECK (showType< S0::Idx >() == "integer_sequence<ulong, 1ul>"_expect);
using S0A = S0::Apply<std::is_pointer>; using S0A = S0::Apply<std::is_pointer>;
CHECK (showType< S0A >() == "TySeq<is_pointer<int*> >"_expect); CHECK (showType< S0A >() == "Types<is_pointer<int*> >"_expect);
using S0AA = S0::AndAll<std::is_pointer>; using S0AA = S0::AndAll<std::is_pointer>;
CHECK (showType< S0AA >() == "__and_<is_pointer<int*> >"_expect); CHECK (showType< S0AA >() == "__and_<is_pointer<int*> >"_expect);
@ -121,12 +121,12 @@ namespace test {
using S2 = ElmTypes<T2>; using S2 = ElmTypes<T2>;
CHECK (3 == S2::SIZ); CHECK (3 == S2::SIZ);
CHECK (showType< S2 >() == "ElmTypes<array<int*, 3ul>, void>"_expect); CHECK (showType< S2 >() == "ElmTypes<array<int*, 3ul>, void>"_expect);
CHECK (showType< S2::Seq >() == "TySeq<int*, int*, int*>"_expect); CHECK (showType< S2::Seq >() == "Types<int*, int*, int*>"_expect);
CHECK (showType< S2::Tup >() == "tuple<int*, int*, int*>"_expect); CHECK (showType< S2::Tup >() == "tuple<int*, int*, int*>"_expect);
CHECK (showType< S2::Idx >() == "integer_sequence<ulong, 0ul, 1ul, 2ul>"_expect); CHECK (showType< S2::Idx >() == "integer_sequence<ulong, 0ul, 1ul, 2ul>"_expect);
using S2A = S2::Apply<std::is_pointer>; using S2A = S2::Apply<std::is_pointer>;
CHECK (showType< S2A >() == "TySeq<is_pointer<int*>, is_pointer<int*>, is_pointer<int*> >"_expect); CHECK (showType< S2A >() == "Types<is_pointer<int*>, is_pointer<int*>, is_pointer<int*> >"_expect);
using S2AA = S2::AndAll<std::is_pointer>; using S2AA = S2::AndAll<std::is_pointer>;
CHECK (showType< S2AA >() == "__and_<is_pointer<int*>, is_pointer<int*>, is_pointer<int*> >"_expect); CHECK (showType< S2AA >() == "__and_<is_pointer<int*>, is_pointer<int*>, is_pointer<int*> >"_expect);
@ -144,11 +144,11 @@ namespace test {
using S3 = ElmTypes<T3>; using S3 = ElmTypes<T3>;
CHECK (3 == S3::SIZ); CHECK (3 == S3::SIZ);
CHECK (showType< S3 >() == "ElmTypes<HeteroData<int*, long, double*>, void>"_expect); CHECK (showType< S3 >() == "ElmTypes<HeteroData<int*, long, double*>, void>"_expect);
CHECK (showType< S3::Seq >() == "TySeq<int*, long, double*>"_expect); CHECK (showType< S3::Seq >() == "Types<int*, long, double*>"_expect);
CHECK (showType< S3::Idx >() == "integer_sequence<ulong, 0ul, 1ul, 2ul>"_expect); CHECK (showType< S3::Idx >() == "integer_sequence<ulong, 0ul, 1ul, 2ul>"_expect);
using S3A = S3::Apply<std::is_pointer>; using S3A = S3::Apply<std::is_pointer>;
CHECK (showType< S3A >() == "TySeq<is_pointer<int*>, is_pointer<long>, is_pointer<double*> >"_expect); CHECK (showType< S3A >() == "Types<is_pointer<int*>, is_pointer<long>, is_pointer<double*> >"_expect);
using S3AA = S3::AndAll<std::is_pointer>; using S3AA = S3::AndAll<std::is_pointer>;
CHECK (showType< S3AA >() == "__and_<is_pointer<int*>, is_pointer<long>, is_pointer<double*> >"_expect); CHECK (showType< S3AA >() == "__and_<is_pointer<int*>, is_pointer<long>, is_pointer<double*> >"_expect);

4
tests/library/variant-test.cpp
View file

@ -31,7 +31,7 @@ namespace lib {
namespace test{ namespace test{
using ::Test; using ::Test;
using meta::TySeq; using meta::Types;
using lib::time::Time; using lib::time::Time;
using lib::time::TimeVar; using lib::time::TimeVar;
@ -43,7 +43,7 @@ namespace test{
// Test fixture... // Test fixture...
using TestVariant = Variant<TySeq<bool,int,string,Time>>; using TestVariant = Variant<Types<bool,int,string,Time>>;

7
tests/vault/gear/activity-detector.hpp
View file

@ -292,10 +292,9 @@ namespace test {
template<typename SIG> template<typename SIG>
struct _DiagnosticFun struct _DiagnosticFun
{ {
using Ret = typename lib::meta::_Fun<SIG>::Ret; using Ret = typename lib::meta::_Fun<SIG>::Ret;
using Args = typename lib::meta::_Fun<SIG>::Args; using Args = typename lib::meta::_Fun<SIG>::Args;
using ArgsX = typename lib::meta::StripNil<Args>::Seq; ////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic using SigTypes = typename lib::meta::Prepend<Ret, Args>::Seq;
using SigTypes = typename lib::meta::Prepend<Ret, ArgsX>::Seq;
using Type = typename RebindVariadic<DiagnosticFun, SigTypes>::Type; using Type = typename RebindVariadic<DiagnosticFun, SigTypes>::Type;
}; };

144
wiki/thinkPad.ichthyo.mm
View file

@ -85141,7 +85141,7 @@ Date:&#160;&#160;&#160;Thu Apr 20 18:53:17 2023 +0200<br/>
<icon BUILTIN="idea"/> <icon BUILTIN="idea"/>
</node> </node>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1744755490793" ID="ID_1135941103" MODIFIED="1744756657146" TEXT="2025-4 : kann jetzt &#xfc;berall weg"> <node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1744755490793" ID="ID_1135941103" MODIFIED="1744756657146" TEXT="2025-4 : kann jetzt &#xfc;berall weg">
<linktarget COLOR="#fd26d0" DESTINATION="ID_1135941103" ENDARROW="Default" ENDINCLINATION="-1048;89;" ID="Arrow_ID_1050531240" SOURCE="ID_831819953" STARTARROW="None" STARTINCLINATION="-1120;-23;"/> <linktarget COLOR="#265efd" DESTINATION="ID_1135941103" ENDARROW="Default" ENDINCLINATION="-1048;89;" ID="Arrow_ID_1050531240" SOURCE="ID_831819953" STARTARROW="None" STARTINCLINATION="-1120;-23;"/>
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
<node COLOR="#435e98" CREATED="1744755518679" ID="ID_1083442460" MODIFIED="1744755532011" TEXT="lib::Several hat sich gut etabliert"> <node COLOR="#435e98" CREATED="1744755518679" ID="ID_1083442460" MODIFIED="1744755532011" TEXT="lib::Several hat sich gut etabliert">
<icon BUILTIN="ksmiletris"/> <icon BUILTIN="ksmiletris"/>
@ -161972,7 +161972,8 @@ actively maintained upstream. Please remove gdl from Debian.</pre>
</node> </node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1439176875682" ID="ID_1482098521" MODIFIED="1742175232490" TEXT="Debian/Trixie"> <node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1439176875682" ID="ID_1482098521" MODIFIED="1742175232490" TEXT="Debian/Trixie">
<icon BUILTIN="pencil"/> <icon BUILTIN="pencil"/>
<node CREATED="1742175232490" ID="ID_1849121366" MODIFIED="1742175241823" TEXT="Aufgaben"> <node CREATED="1742175232490" ID="ID_1849121366" MODIFIED="1749341104677" TEXT="Aufgaben">
<icon BUILTIN="yes"/>
<node COLOR="#338800" CREATED="1742175284498" ID="ID_381697845" MODIFIED="1745722043514" TEXT="Scons-Build migrieren"> <node COLOR="#338800" CREATED="1742175284498" ID="ID_381697845" MODIFIED="1745722043514" TEXT="Scons-Build migrieren">
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1742175408138" ID="ID_22551307" MODIFIED="1742176275192" TEXT="den gro&#xdf;en Schritt hat bereits Benny gemacht"> <node COLOR="#338800" CREATED="1742175408138" ID="ID_22551307" MODIFIED="1742176275192" TEXT="den gro&#xdf;en Schritt hat bereits Benny gemacht">
@ -162757,8 +162758,8 @@ Since then others have made contributions, see the log for the history.</font></
</node> </node>
</node> </node>
</node> </node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1742175611912" ID="ID_16098937" MODIFIED="1747359127313" TEXT="etwas aufr&#xe4;umen"> <node COLOR="#338800" CREATED="1742175611912" ID="ID_16098937" MODIFIED="1749341021068" TEXT="etwas aufr&#xe4;umen">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1742175621250" FOLDED="true" ID="ID_1886919024" MODIFIED="1745860228467" TEXT="boost-filesystem loswerden!"> <node COLOR="#338800" CREATED="1742175621250" FOLDED="true" ID="ID_1886919024" MODIFIED="1745860228467" TEXT="boost-filesystem loswerden!">
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
<node CREATED="1744754918427" ID="ID_368377472" MODIFIED="1745799970522" TEXT="lib/searchpath.hpp"> <node CREATED="1744754918427" ID="ID_368377472" MODIFIED="1745799970522" TEXT="lib/searchpath.hpp">
@ -162837,9 +162838,9 @@ Since then others have made contributions, see the log for the history.</font></
<arrowlink DESTINATION="ID_368377472" ENDARROW="Default" ENDINCLINATION="107;14;" ID="Arrow_ID_1432393919" STARTARROW="None" STARTINCLINATION="74;7;"/> <arrowlink DESTINATION="ID_368377472" ENDARROW="Default" ENDINCLINATION="107;14;" ID="Arrow_ID_1432393919" STARTARROW="None" STARTINCLINATION="74;7;"/>
</node> </node>
</node> </node>
<node COLOR="#338800" CREATED="1742175872016" ID="ID_1131308211" MODIFIED="1747359118365" TEXT="Untersuchung: einfacher XV-Displayer"> <node COLOR="#338800" CREATED="1742175872016" FOLDED="true" ID="ID_1131308211" MODIFIED="1747359118365" TEXT="Untersuchung: einfacher XV-Displayer">
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1742175882083" ID="ID_846823682" MODIFIED="1745783296480" TEXT="Christian hatte uns im Chat einen Tip gegeben"> <node BACKGROUND_COLOR="#dae1b4" COLOR="#0a0099" CREATED="1742175882083" ID="ID_846823682" MODIFIED="1747359118480" TEXT="Christian hatte uns im Chat einen Tip gegeben">
<richcontent TYPE="NOTE"><html> <richcontent TYPE="NOTE"><html>
<head> <head>
<body> <body>
@ -163099,7 +163100,7 @@ Since then others have made contributions, see the log for the history.</font></
</node> </node>
</node> </node>
</node> </node>
<node COLOR="#338800" CREATED="1742176004434" ID="ID_393175435" MODIFIED="1747355570776" TEXT="Reste vom GTK-2-GUI zur&#xfc;ckbauen"> <node COLOR="#338800" CREATED="1742176004434" FOLDED="true" ID="ID_393175435" MODIFIED="1747355570776" TEXT="Reste vom GTK-2-GUI zur&#xfc;ckbauen">
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
<node COLOR="#984373" CREATED="1746059790896" ID="ID_1458700110" MODIFIED="1747358892480" TEXT="macht den GUI-Code verst&#xe4;ndlicher..."> <node COLOR="#984373" CREATED="1746059790896" ID="ID_1458700110" MODIFIED="1747358892480" TEXT="macht den GUI-Code verst&#xe4;ndlicher...">
<font ITALIC="true" NAME="SansSerif" SIZE="12"/> <font ITALIC="true" NAME="SansSerif" SIZE="12"/>
@ -163201,7 +163202,7 @@ Since then others have made contributions, see the log for the history.</font></
</node> </node>
</node> </node>
</node> </node>
<node BACKGROUND_COLOR="#bfcad3" COLOR="#1a475d" CREATED="1742249461535" ID="ID_1554376708" MODIFIED="1748489820913" TEXT="Rolle der lib-Gavl &#xfc;berpr&#xfc;fen"> <node BACKGROUND_COLOR="#bfcad3" COLOR="#1a475d" CREATED="1742249461535" FOLDED="true" ID="ID_1554376708" MODIFIED="1748489820913" TEXT="Rolle der lib-Gavl &#xfc;berpr&#xfc;fen">
<linktarget COLOR="#1857a4" DESTINATION="ID_1554376708" ENDARROW="Default" ENDINCLINATION="440;-36;" ID="Arrow_ID_608156847" SOURCE="ID_1683248748" STARTARROW="None" STARTINCLINATION="193;12;"/> <linktarget COLOR="#1857a4" DESTINATION="ID_1554376708" ENDARROW="Default" ENDINCLINATION="440;-36;" ID="Arrow_ID_608156847" SOURCE="ID_1683248748" STARTARROW="None" STARTINCLINATION="193;12;"/>
<linktarget COLOR="#4c3b8b" DESTINATION="ID_1554376708" ENDARROW="Default" ENDINCLINATION="219;519;" ID="Arrow_ID_589652743" SOURCE="ID_219954631" STARTARROW="None" STARTINCLINATION="326;-188;"/> <linktarget COLOR="#4c3b8b" DESTINATION="ID_1554376708" ENDARROW="Default" ENDINCLINATION="219;519;" ID="Arrow_ID_589652743" SOURCE="ID_219954631" STARTARROW="None" STARTINCLINATION="326;-188;"/>
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
@ -163807,7 +163808,7 @@ Since then others have made contributions, see the log for the history.</font></
</node> </node>
</node> </node>
</node> </node>
<node COLOR="#338800" CREATED="1746059853111" ID="ID_975342117" MODIFIED="1748563719621" TEXT="auch altes RenderNode-Framework zur&#xfc;ckbauen"> <node COLOR="#338800" CREATED="1746059853111" FOLDED="true" ID="ID_975342117" MODIFIED="1748563719621" TEXT="auch altes RenderNode-Framework zur&#xfc;ckbauen">
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1748561872884" ID="ID_962941766" MODIFIED="1748563677391" TEXT="Ansatzpunkte"> <node COLOR="#338800" CREATED="1748561872884" ID="ID_962941766" MODIFIED="1748563677391" TEXT="Ansatzpunkte">
<icon BUILTIN="idea"/> <icon BUILTIN="idea"/>
@ -163855,11 +163856,17 @@ Since then others have made contributions, see the log for the history.</font></
<icon BUILTIN="ksmiletris"/> <icon BUILTIN="ksmiletris"/>
</node> </node>
</node> </node>
<node COLOR="#338800" CREATED="1744756270441" ID="ID_831819953" LINK="https://issues.lumiera.org/ticket/473" MODIFIED="1748738386934" TEXT="RefArray und ScopedHolder m&#xfc;ssen jetzt wirklich mal weg"> <node COLOR="#338800" CREATED="1744756270441" FOLDED="true" ID="ID_831819953" LINK="https://issues.lumiera.org/ticket/473" MODIFIED="1748738386934" TEXT="RefArray und ScopedHolder m&#xfc;ssen jetzt wirklich mal weg">
<arrowlink COLOR="#fd26d0" DESTINATION="ID_1135941103" ENDARROW="Default" ENDINCLINATION="-1048;89;" ID="Arrow_ID_1050531240" STARTARROW="None" STARTINCLINATION="-1120;-23;"/> <arrowlink COLOR="#265efd" DESTINATION="ID_1135941103" ENDARROW="Default" ENDINCLINATION="-1048;89;" ID="Arrow_ID_1050531240" STARTARROW="None" STARTINCLINATION="-1120;-23;"/>
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
<node BACKGROUND_COLOR="#f0d5c5" COLOR="#990033" CREATED="1747180091430" ID="ID_202566672" MODIFIED="1747180099934" TEXT="was ist mit ScopedPtrvect?"> <node COLOR="#435e98" CREATED="1747180091430" ID="ID_202566672" MODIFIED="1749340966203" TEXT="was ist mit ScopedPtrvect?">
<icon BUILTIN="help"/> <icon BUILTIN="help"/>
<node COLOR="#437498" CREATED="1749340995322" ID="ID_1686131057" MODIFIED="1749341011299" TEXT="sinnvoll...">
<font NAME="SansSerif" SIZE="9"/>
</node>
<node COLOR="#437498" CREATED="1749340999254" ID="ID_1836393412" MODIFIED="1749341011300" TEXT="bleibt erhalten">
<font NAME="SansSerif" SIZE="9"/>
</node>
</node> </node>
<node COLOR="#435e98" CREATED="1748609941535" ID="ID_309992355" MODIFIED="1748738408223" TEXT="Status feststellen"> <node COLOR="#435e98" CREATED="1748609941535" ID="ID_309992355" MODIFIED="1748738408223" TEXT="Status feststellen">
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
@ -164234,10 +164241,10 @@ Since then others have made contributions, see the log for the history.</font></
</node> </node>
<node CREATED="1748731316160" ID="ID_1388202310" MODIFIED="1748731324655" TEXT="hash-fnv.h|c"/> <node CREATED="1748731316160" ID="ID_1388202310" MODIFIED="1748731324655" TEXT="hash-fnv.h|c"/>
</node> </node>
<node BACKGROUND_COLOR="#bc9daa" COLOR="#5b280f" CREATED="1748732382635" ID="ID_365290009" MODIFIED="1748737931585" STYLE="fork" TEXT="RefArray &#xd83d;&#xdc80;"> <node BACKGROUND_COLOR="#bc9daa" COLOR="#5b280f" CREATED="1748732382635" FOLDED="true" ID="ID_365290009" MODIFIED="1749340958256" STYLE="fork" TEXT="RefArray &#xd83d;&#xdc80;">
<edge COLOR="#808080" STYLE="bezier" WIDTH="thin"/> <edge COLOR="#808080" STYLE="bezier" WIDTH="thin"/>
<icon BUILTIN="button_cancel"/> <icon BUILTIN="button_cancel"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1748732389628" ID="ID_344324779" MODIFIED="1748737931582" TEXT="eine Verwendung auf dem Session-Interface"> <node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1748732389628" FOLDED="true" ID="ID_344324779" MODIFIED="1749340952576" TEXT="eine Verwendung auf dem Session-Interface">
<icon BUILTIN="messagebox_warning"/> <icon BUILTIN="messagebox_warning"/>
<node CREATED="1748732426725" ID="ID_280482100" MODIFIED="1748737931582" TEXT="also wirklich: Interface-hat-eine-Collection"/> <node CREATED="1748732426725" ID="ID_280482100" MODIFIED="1748737931582" TEXT="also wirklich: Interface-hat-eine-Collection"/>
<node CREATED="1748732511785" ID="ID_1712841924" MODIFIED="1748737931582" TEXT="und zwar mit shared-Pointern"/> <node CREATED="1748732511785" ID="ID_1712841924" MODIFIED="1748737931582" TEXT="und zwar mit shared-Pointern"/>
@ -164355,7 +164362,7 @@ Since then others have made contributions, see the log for the history.</font></
</node> </node>
</node> </node>
</node> </node>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1748826201673" ID="ID_358783348" MODIFIED="1748826459126" TEXT="gehe jetzt das Problem mit den variadischen Typlisten an"> <node BACKGROUND_COLOR="#bee5cf" COLOR="#338800" CREATED="1748826201673" FOLDED="true" ID="ID_358783348" MODIFIED="1749341082318" TEXT="gehe jetzt das Problem mit den variadischen Typlisten an">
<linktarget COLOR="#4c5dd7" DESTINATION="ID_358783348" ENDARROW="Default" ENDINCLINATION="-1131;-56;" ID="Arrow_ID_470275962" SOURCE="ID_575940847" STARTARROW="None" STARTINCLINATION="-4286;314;"/> <linktarget COLOR="#4c5dd7" DESTINATION="ID_358783348" ENDARROW="Default" ENDINCLINATION="-1131;-56;" ID="Arrow_ID_470275962" SOURCE="ID_575940847" STARTARROW="None" STARTINCLINATION="-4286;314;"/>
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1748826834261" ID="ID_1288761919" LINK="https://issues.lumiera.org/ticket/987" MODIFIED="1748826884703" TEXT="siehe ausf&#xfc;hrliche &#xdc;berlegungen in Ticket #987 "> <node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1748826834261" ID="ID_1288761919" LINK="https://issues.lumiera.org/ticket/987" MODIFIED="1748826884703" TEXT="siehe ausf&#xfc;hrliche &#xdc;berlegungen in Ticket #987 ">
@ -164392,8 +164399,8 @@ Since then others have made contributions, see the log for the history.</font></
</html></richcontent> </html></richcontent>
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
</node> </node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1748826894390" ID="ID_1736451439" MODIFIED="1748826903420" TEXT="Zonen f&#xfc;r Umstellung identifizieren"> <node BACKGROUND_COLOR="#d1d3d8" COLOR="#524398" CREATED="1748826894390" FOLDED="true" ID="ID_1736451439" MODIFIED="1749340895600" TEXT="Zonen f&#xfc;r Umstellung identifizieren">
<icon BUILTIN="flag-yellow"/> <icon BUILTIN="yes"/>
<node COLOR="#435e98" CREATED="1748827924638" ID="ID_1710277250" MODIFIED="1748869708456" TEXT="Manipulations-Funktionen"> <node COLOR="#435e98" CREATED="1748827924638" ID="ID_1710277250" MODIFIED="1748869708456" TEXT="Manipulations-Funktionen">
<node CREATED="1748827943942" ID="ID_1841252518" MODIFIED="1748828044902" TEXT="Tuple-Builder, Split, Prepend und Pick unterst&#xfc;tzen bereits beide Varianten"/> <node CREATED="1748827943942" ID="ID_1841252518" MODIFIED="1748828044902" TEXT="Tuple-Builder, Split, Prepend und Pick unterst&#xfc;tzen bereits beide Varianten"/>
<node CREATED="1748828081030" ID="ID_780708642" MODIFIED="1748828109653" TEXT="damit k&#xf6;nnen alle typeseq-util bereits f&#xfc;r beide Varianten verwendet werden"> <node CREATED="1748828081030" ID="ID_780708642" MODIFIED="1748828109653" TEXT="damit k&#xf6;nnen alle typeseq-util bereits f&#xfc;r beide Varianten verwendet werden">
@ -164460,7 +164467,7 @@ Since then others have made contributions, see the log for the history.</font></
</html></richcontent> </html></richcontent>
</node> </node>
<node CREATED="1748828781783" ID="ID_691444823" MODIFIED="1748828794388" TEXT="sollte also f&#xfc;r alle Varianten gleicherma&#xdf;en greifen"/> <node CREATED="1748828781783" ID="ID_691444823" MODIFIED="1748828794388" TEXT="sollte also f&#xfc;r alle Varianten gleicherma&#xdf;en greifen"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748888164617" ID="ID_145174722" MODIFIED="1748980951490" TEXT="sollte Tests ustellen auf Inline-Checks (mit _expect)"> <node COLOR="#435e98" CREATED="1748888164617" ID="ID_145174722" MODIFIED="1749340875647" TEXT="sollte Tests ustellen auf Inline-Checks (mit _expect)">
<arrowlink DESTINATION="ID_1431343903" ENDARROW="Default" ENDINCLINATION="206;-13;" ID="Arrow_ID_1374886089" STARTARROW="None" STARTINCLINATION="250;329;"/> <arrowlink DESTINATION="ID_1431343903" ENDARROW="Default" ENDINCLINATION="206;-13;" ID="Arrow_ID_1374886089" STARTARROW="None" STARTINCLINATION="250;329;"/>
<arrowlink DESTINATION="ID_665924488" ENDARROW="Default" ENDINCLINATION="358;-61;" ID="Arrow_ID_369345367" STARTARROW="None" STARTINCLINATION="208;250;"/> <arrowlink DESTINATION="ID_665924488" ENDARROW="Default" ENDINCLINATION="358;-61;" ID="Arrow_ID_369345367" STARTARROW="None" STARTINCLINATION="208;250;"/>
<arrowlink DESTINATION="ID_653647632" ENDARROW="Default" ENDINCLINATION="135;-20;" ID="Arrow_ID_1807168701" STARTARROW="None" STARTINCLINATION="235;315;"/> <arrowlink DESTINATION="ID_653647632" ENDARROW="Default" ENDINCLINATION="135;-20;" ID="Arrow_ID_1807168701" STARTARROW="None" STARTINCLINATION="235;315;"/>
@ -165424,33 +165431,50 @@ Since then others have made contributions, see the log for the history.</font></
</node> </node>
<node CREATED="1748830139501" ID="ID_622177889" MODIFIED="1748830160252" TEXT="ElmTypes ist nur f&#xfc;r neue (variadisch) definiert"/> <node CREATED="1748830139501" ID="ID_622177889" MODIFIED="1748830160252" TEXT="ElmTypes ist nur f&#xfc;r neue (variadisch) definiert"/>
</node> </node>
<node CREATED="1748829176262" ID="ID_1246318914" MODIFIED="1748829178958" TEXT="Variant"/> <node COLOR="#435e98" CREATED="1748829176262" ID="ID_1246318914" MODIFIED="1749340864846" TEXT="Variant"/>
<node CREATED="1748829201135" ID="ID_1330371655" MODIFIED="1748829203111" TEXT="Visitor"/> <node COLOR="#435e98" CREATED="1748829201135" ID="ID_1330371655" MODIFIED="1749340864846" TEXT="Visitor"/>
<node CREATED="1748829220424" ID="ID_795696886" MODIFIED="1748829224836" TEXT="Session-Command"> <node COLOR="#435e98" CREATED="1748829220424" ID="ID_795696886" MODIFIED="1749340869312" TEXT="Session-Command">
<node CREATED="1748829229664" ID="ID_214343950" MODIFIED="1748829240967" TEXT="AcceptArg und AcceptBind umstellen"/> <node CREATED="1748829229664" ID="ID_214343950" MODIFIED="1748829240967" TEXT="AcceptArg und AcceptBind umstellen"/>
<node CREATED="1748829241698" ID="ID_1502522588" MODIFIED="1748829249189" TEXT="dann sollte big-Bang m&#xf6;glich sein"/> <node CREATED="1748829241698" ID="ID_1502522588" MODIFIED="1748829249189" TEXT="dann sollte big-Bang m&#xf6;glich sein"/>
</node> </node>
<node CREATED="1748829278917" ID="ID_250508253" MODIFIED="1748829282736" TEXT="Session &amp; Builder"> <node COLOR="#435e98" CREATED="1748829278917" ID="ID_250508253" MODIFIED="1749340869312" TEXT="Session &amp; Builder">
<node CREATED="1748829283559" ID="ID_373354659" MODIFIED="1748829291711" TEXT="h&#xe4;ngt vermutlich an Variant bzw. Visitor"/> <node CREATED="1748829283559" ID="ID_373354659" MODIFIED="1748829291711" TEXT="h&#xe4;ngt vermutlich an Variant bzw. Visitor"/>
</node> </node>
<node CREATED="1748829316732" ID="ID_733906672" MODIFIED="1748829324434" TEXT="Timecode-formate"/> <node COLOR="#435e98" CREATED="1748829316732" ID="ID_733906672" MODIFIED="1749340869312" TEXT="Timecode-formate"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748829331775" ID="ID_1553022384" MODIFIED="1748900515205" TEXT="Tests"> <node COLOR="#338800" CREATED="1748829331775" FOLDED="true" ID="ID_1553022384" MODIFIED="1749340860142" TEXT="Tests">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1748829335663" ID="ID_953757498" MODIFIED="1748900529301" TEXT="jeweils bei Bezug mit umstellen"> <node COLOR="#435e98" CREATED="1748829335663" ID="ID_953757498" MODIFIED="1749336247762" TEXT="jeweils bei Bezug mit umstellen">
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
</node> </node>
<node CREATED="1748829344620" ID="ID_1034418764" MODIFIED="1748883769361" TEXT="im Einzelnen"> <node CREATED="1748829344620" ID="ID_1034418764" MODIFIED="1748883769361" TEXT="im Einzelnen">
<icon BUILTIN="list"/> <icon BUILTIN="list"/>
<node CREATED="1748829369449" MODIFIED="1748829369449" TEXT="FormatSupport_test"/> <node COLOR="#435e98" CREATED="1748829369449" ID="ID_1712572941" MODIFIED="1749296147872" TEXT="FormatSupport_test"/>
<node CREATED="1748829384655" MODIFIED="1748829384655" TEXT="TimeControl_test"/> <node COLOR="#435e98" CREATED="1748829384655" ID="ID_818292101" MODIFIED="1749297906698" TEXT="TimeControl_test"/>
<node CREATED="1748829402514" MODIFIED="1748829402514" TEXT="VisitingTool_test"/> <node COLOR="#435e98" CREATED="1748829402514" ID="ID_1475154957" MODIFIED="1749298311811" TEXT="VisitingTool_test"/>
<node CREATED="1748829412897" MODIFIED="1748829412897" TEXT="CommandCloneBuilder_test"/> <node COLOR="#5b280f" CREATED="1748829412897" ID="ID_1140250977" MODIFIED="1749298480081" TEXT="CommandCloneBuilder_test">
<node CREATED="1748829420654" MODIFIED="1748829420654" TEXT="CommandEquality_test"/> <icon BUILTIN="button_cancel"/>
<node CREATED="1748829427640" MODIFIED="1748829427640" TEXT="CommandMutation_test"/> <node COLOR="#744398" CREATED="1749298484082" HGAP="22" ID="ID_1296599024" MODIFIED="1749336241334" TEXT="std::tuple stat type-seq verwendet" VSHIFT="5">
<node CREATED="1748829435006" MODIFIED="1748829435006" TEXT="CommandRegistry_test"/> <arrowlink COLOR="#8526c8" DESTINATION="ID_783380997" ENDARROW="None" ENDINCLINATION="54;5;" ID="Arrow_ID_829287253" STARTARROW="None" STARTINCLINATION="5;20;"/>
<node CREATED="1748829442778" MODIFIED="1748829442778" TEXT="HandlingPatternBasics_test"/> <arrowlink COLOR="#9e6ac3" DESTINATION="ID_556747715" ENDARROW="None" ENDINCLINATION="102;11;" ID="Arrow_ID_1444297637" STARTARROW="None" STARTINCLINATION="13;57;"/>
<node CREATED="1748829453011" MODIFIED="1748829453011" TEXT="BuilderTool_test"/> <font NAME="SansSerif" SIZE="9"/>
<node CREATED="1748829468217" MODIFIED="1748829468217" TEXT="SessionServiceAccess_test"/> </node>
</node>
<node COLOR="#5b280f" CREATED="1748829442778" ID="ID_783380997" MODIFIED="1749335956242" TEXT="HandlingPatternBasics_test">
<linktarget COLOR="#8526c8" DESTINATION="ID_783380997" ENDARROW="None" ENDINCLINATION="54;5;" ID="Arrow_ID_829287253" SOURCE="ID_1296599024" STARTARROW="None" STARTINCLINATION="5;20;"/>
<icon BUILTIN="button_cancel"/>
</node>
<node COLOR="#5b280f" CREATED="1748829420654" ID="ID_580068958" MODIFIED="1749336193046" TEXT="CommandEquality_test">
<icon BUILTIN="button_cancel"/>
</node>
<node COLOR="#5b280f" CREATED="1748829427640" ID="ID_1308198327" MODIFIED="1749336193045" TEXT="CommandMutation_test">
<icon BUILTIN="button_cancel"/>
</node>
<node COLOR="#5b280f" CREATED="1748829435006" ID="ID_556747715" MODIFIED="1749336230725" TEXT="CommandRegistry_test">
<linktarget COLOR="#9e6ac3" DESTINATION="ID_556747715" ENDARROW="None" ENDINCLINATION="102;11;" ID="Arrow_ID_1444297637" SOURCE="ID_1296599024" STARTARROW="None" STARTINCLINATION="13;57;"/>
<icon BUILTIN="button_cancel"/>
</node>
<node COLOR="#435e98" CREATED="1748829453011" ID="ID_298624775" MODIFIED="1749265246395" TEXT="BuilderTool_test"/>
<node COLOR="#435e98" CREATED="1748829468217" ID="ID_294054246" MODIFIED="1749332387894" TEXT="SessionServiceAccess_test"/>
<node COLOR="#435e98" CREATED="1748829480048" ID="ID_142039126" MODIFIED="1749007517616" TEXT="FunctionClosure_test"> <node COLOR="#435e98" CREATED="1748829480048" ID="ID_142039126" MODIFIED="1749007517616" TEXT="FunctionClosure_test">
<linktarget COLOR="#a9b4c1" DESTINATION="ID_142039126" ENDARROW="Default" ENDINCLINATION="726;0;" ID="Arrow_ID_535671141" SOURCE="ID_240022720" STARTARROW="None" STARTINCLINATION="726;0;"/> <linktarget COLOR="#a9b4c1" DESTINATION="ID_142039126" ENDARROW="Default" ENDINCLINATION="726;0;" ID="Arrow_ID_535671141" SOURCE="ID_240022720" STARTARROW="None" STARTINCLINATION="726;0;"/>
</node> </node>
@ -165519,7 +165543,7 @@ Since then others have made contributions, see the log for the history.</font></
<node COLOR="#435e98" CREATED="1748829523737" ID="ID_803058969" MODIFIED="1748883754992" TEXT="TypeListGenerator_test"> <node COLOR="#435e98" CREATED="1748829523737" ID="ID_803058969" MODIFIED="1748883754992" TEXT="TypeListGenerator_test">
<linktarget COLOR="#a9b4c1" DESTINATION="ID_803058969" ENDARROW="Default" ENDINCLINATION="852;0;" ID="Arrow_ID_1971292758" SOURCE="ID_511778446" STARTARROW="None" STARTINCLINATION="302;17;"/> <linktarget COLOR="#a9b4c1" DESTINATION="ID_803058969" ENDARROW="Default" ENDINCLINATION="852;0;" ID="Arrow_ID_1971292758" SOURCE="ID_511778446" STARTARROW="None" STARTINCLINATION="302;17;"/>
</node> </node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1748829534601" ID="ID_75861658" MODIFIED="1749177103638" TEXT="MetaUtils_test"/> <node COLOR="#435e98" CREATED="1748829534601" ID="ID_75861658" MODIFIED="1749332314880" TEXT="MetaUtils_test"/>
<node COLOR="#435e98" CREATED="1748829542074" ID="ID_653647632" MODIFIED="1748960053937" TEXT="TupleHelper_test"> <node COLOR="#435e98" CREATED="1748829542074" ID="ID_653647632" MODIFIED="1748960053937" TEXT="TupleHelper_test">
<linktarget COLOR="#a9b4c1" DESTINATION="ID_653647632" ENDARROW="Default" ENDINCLINATION="135;-20;" ID="Arrow_ID_1807168701" SOURCE="ID_145174722" STARTARROW="None" STARTINCLINATION="235;315;"/> <linktarget COLOR="#a9b4c1" DESTINATION="ID_653647632" ENDARROW="Default" ENDINCLINATION="135;-20;" ID="Arrow_ID_1807168701" SOURCE="ID_145174722" STARTARROW="None" STARTINCLINATION="235;315;"/>
</node> </node>
@ -165539,38 +165563,38 @@ Since then others have made contributions, see the log for the history.</font></
<node COLOR="#435e98" CREATED="1748829567920" ID="ID_1097523075" MODIFIED="1749078634991" TEXT="TypeList_test"> <node COLOR="#435e98" CREATED="1748829567920" ID="ID_1097523075" MODIFIED="1749078634991" TEXT="TypeList_test">
<linktarget COLOR="#8ec9a3" DESTINATION="ID_1097523075" ENDARROW="Default" ENDINCLINATION="1324;0;" ID="Arrow_ID_370033957" SOURCE="ID_91346918" STARTARROW="None" STARTINCLINATION="481;24;"/> <linktarget COLOR="#8ec9a3" DESTINATION="ID_1097523075" ENDARROW="Default" ENDINCLINATION="1324;0;" ID="Arrow_ID_370033957" SOURCE="ID_91346918" STARTARROW="None" STARTINCLINATION="481;24;"/>
</node> </node>
<node CREATED="1748829607017" MODIFIED="1748829607017" TEXT="Variant_test"/> <node COLOR="#435e98" CREATED="1748829607017" ID="ID_596384261" MODIFIED="1749265034416" TEXT="Variant_test"/>
</node> </node>
</node> </node>
</node> </node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871733811" ID="ID_1327114043" MODIFIED="1748871745451" TEXT="schrittweise umarbeiten..."> <node COLOR="#338800" CREATED="1748871733811" FOLDED="true" ID="ID_1327114043" MODIFIED="1749340906083" TEXT="schrittweise umarbeiten...">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871746934" ID="ID_1013283697" MODIFIED="1748883821476" TEXT="mit einfachen Typ-Listen anfangen"> <node COLOR="#338800" CREATED="1748871746934" ID="ID_1013283697" MODIFIED="1749265043727" TEXT="mit einfachen Typ-Listen anfangen">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1748871760093" ID="ID_234969081" MODIFIED="1748883829134" TEXT="alle Konvertierungspfade aufgedoppelt"> <node COLOR="#338800" CREATED="1748871760093" ID="ID_234969081" MODIFIED="1748883829134" TEXT="alle Konvertierungspfade aufgedoppelt">
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
</node> </node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871777734" ID="ID_543292197" MODIFIED="1748883832925" TEXT="die zugeh&#xf6;rigen Tests auf die neuen Typ-Sequenzen umstellen"> <node COLOR="#338800" CREATED="1748871777734" ID="ID_543292197" MODIFIED="1749265045831" TEXT="die zugeh&#xf6;rigen Tests auf die neuen Typ-Sequenzen umstellen">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
</node> </node>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1748871811471" ID="ID_1037157310" MODIFIED="1748883848889" TEXT="bei der Gelegenheit auch modernisieren"> <node BACKGROUND_COLOR="#c8c0b6" COLOR="#435e98" CREATED="1748871811471" ID="ID_1037157310" MODIFIED="1749336412166" TEXT="bei der Gelegenheit auch modernisieren">
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871820220" ID="ID_446849123" MODIFIED="1748883860119" TEXT="typedefs durch using ersetzen"> <node COLOR="#338800" CREATED="1748871820220" ID="ID_446849123" MODIFIED="1749336257348" TEXT="typedefs durch using ersetzen">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
</node> </node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871829578" ID="ID_308061484" MODIFIED="1748883860119" TEXT="Meta-Wertfunktionen in constexpr &#xfc;berf&#xfc;hren"> <node COLOR="#338800" CREATED="1748871829578" ID="ID_308061484" MODIFIED="1749336409239" TEXT="Meta-Wertfunktionen in constexpr &#xfc;berf&#xfc;hren">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
</node> </node>
<node CREATED="1748871856256" ID="ID_304666403" MODIFIED="1748900585714" TEXT="Tests ggfs vervollst&#xe4;ndigen"> <node COLOR="#338800" CREATED="1748871856256" ID="ID_304666403" MODIFIED="1749336274575" TEXT="Tests ggfs vervollst&#xe4;ndigen">
<icon BUILTIN="yes"/> <icon BUILTIN="yes"/>
</node> </node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748900565184" ID="ID_1203054358" MODIFIED="1748900572521" TEXT="ExpectString verwenden"> <node COLOR="#338800" CREATED="1748900565184" ID="ID_1203054358" MODIFIED="1749336262676" TEXT="ExpectString verwenden">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
</node> </node>
</node> </node>
</node> </node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1749177155817" ID="ID_253850750" MODIFIED="1749177176623" TEXT="dann den Themenkomplex &#xbb;Funktionen&#xab; angehen"> <node COLOR="#338800" CREATED="1749177155817" ID="ID_253850750" MODIFIED="1749265047728" TEXT="dann den Themenkomplex &#xbb;Funktionen&#xab; angehen">
<icon BUILTIN="pencil"/> <icon BUILTIN="button_ok"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1749177180341" ID="ID_1746274296" MODIFIED="1749177280835"> <node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1749177180341" ID="ID_1746274296" MODIFIED="1749177280835">
<richcontent TYPE="NODE"><html> <richcontent TYPE="NODE"><html>
<head/> <head/>
@ -165587,8 +165611,14 @@ Since then others have made contributions, see the log for the history.</font></
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
</node> </node>
</node> </node>
<node COLOR="#338800" CREATED="1749265055449" ID="ID_1617513184" MODIFIED="1749265074876" TEXT="dann in der Kern-Codebasis alle Verwendungen schwenken">
<icon BUILTIN="button_ok"/>
</node> </node>
<node COLOR="#338800" CREATED="1748873216115" ID="ID_1189899594" MODIFIED="1748879258348" TEXT="Big anti-Bang: NullType &#x27fc; Nil"> <node COLOR="#338800" CREATED="1749265075819" ID="ID_1509578336" MODIFIED="1749340800423" TEXT="schlie&#xdf;lich die alten Definitionen und Br&#xfc;cken entfernen">
<icon BUILTIN="button_ok"/>
</node>
</node>
<node COLOR="#338800" CREATED="1748873216115" FOLDED="true" ID="ID_1189899594" MODIFIED="1749340910868" TEXT="Big anti-Bang: NullType &#x27fc; Nil">
<icon BUILTIN="button_ok"/> <icon BUILTIN="button_ok"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1748873298068" ID="ID_132055056" MODIFIED="1748873322310" TEXT="182 usages..."> <node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1748873298068" ID="ID_132055056" MODIFIED="1748873322310" TEXT="182 usages...">
<font NAME="SansSerif" SIZE="10"/> <font NAME="SansSerif" SIZE="10"/>
@ -165597,8 +165627,8 @@ Since then others have made contributions, see the log for the history.</font></
<font NAME="SansSerif" SIZE="7"/> <font NAME="SansSerif" SIZE="7"/>
</node> </node>
</node> </node>
<node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1748873250610" ID="ID_7395466" MODIFIED="1748873280467" TEXT="Big-Bang: TySeq &#x27fc; Types"> <node COLOR="#338800" CREATED="1748873250610" ID="ID_7395466" MODIFIED="1749340803860" TEXT="Big-Bang: TySeq &#x27fc; Types">
<icon BUILTIN="hourglass"/> <icon BUILTIN="button_ok"/>
</node> </node>
</node> </node>
</node> </node>