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'
- 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
into the `lib::meta::Types<ARGS...>` ([yellow-background]#⚠ still broken in 2024#
see https://issues.lumiera.org/ticket/987[#987], use `lib::meta::TySeq` from 'meta/typelist.hpp' as workaround...)
into the `lib::meta::Types<ARGS...>`
+
apply functor to each tuple element::
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);
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 WupSig = _Fun<Wup>::Sig;
@ -130,7 +130,7 @@ main (int, char**)
SHOW_EXPR (sizeof(bup))
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 ();
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 RecRef = RecordRef<GenNode>;
using MakeRec = Rec::Mutator;
using DataValues = meta::TySeq<int
using DataValues = meta::Types<int
,int64_t
,short
,char

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

@ -294,7 +294,7 @@ namespace func{
using Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::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>()
, VAL_CNT = count<ValList>()
@ -306,8 +306,8 @@ namespace func{
using LeftReduced = typename Splice<ArgsList, ValList>::Back;
using RightReduced = typename Splice<ArgsList, ValList, ROFFSET>::Front;
using ArgsL = typename TySeq<LeftReduced>::Seq;
using ArgsR = typename TySeq<RightReduced>::Seq;
using ArgsL = typename Types<LeftReduced>::Seq;
using ArgsR = typename Types<RightReduced>::Seq;
// 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 RightReplaced = typename Splice<ArgsList, LeadingPlaceholders, 0 >::List;
using LeftReplacedTypes = typename TySeq<LeftReplaced>::Seq;
using RightReplacedTypes = typename TySeq<RightReplaced>::Seq;
using LeftReplacedTypes = typename Types<LeftReplaced>::Seq;
using RightReplacedTypes = typename Types<RightReplaced>::Seq;
// create a "builder" helper, which accepts exactly the value tuple elements
// 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 Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::List;
using ValList = typename TySeq<X>::List;
using ValList = typename Types<X>::List;
enum { ARG_CNT = count<ArgsList>() };
@ -423,8 +423,8 @@ namespace func{
using PreparedArgs = Prefix<PreparedArgsRaw, ARG_CNT>;
using ReducedArgs = typename Append<RemainingFront, RemainingBack>::List;
using PreparedArgTypes = typename TySeq<PreparedArgs>::Seq;
using RemainingArgs = typename TySeq<ReducedArgs>::Seq;
using PreparedArgTypes = typename Types<PreparedArgs>::Seq;
using RemainingArgs = typename Types<ReducedArgs>::Seq;
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
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
  under the terms of the GNU General Public License as published by the
@ -13,25 +13,66 @@
/** @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
** 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
** is still lacking in this area. (C++11 significantly improved this situation).
** As an \em pragmatic fix, we define here a collection of templates, specialising
** them in a very repetitive way for up to 9 function arguments. Doing so enables
** us to capture a function, access the return type and argument types as a typelist,
** eventually to manipulate them and re-build a different signature, or to create
** specifically tailored bindings.
** Functors, especially in the form of Lambdas, can be used to parametrise a common
** skeleton of computation logic to make it work with concrete implementation parts
** tied directly to the actual usage. A _functor centric_ approach places the focus
** on the _computation structure_ and often complements the more _object centric_ one,
** where relations and responsibilities are structured and built from building blocks
** with fixed type relations.
**
** If the following code makes you feel like vomiting, please look away,
** and rest assured: you aren't alone.
** However, handling arbitrary functions as part of a common structure scheme requires
** 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
** and use variadic templates to represent the arguments /////////////////////////////////TICKET #994
** The _trait template_ [_Fun](\ref lib::meta::_Fun) is the entrance point to
** 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 typelist.hpp
** @see tuple.hpp
@ -55,24 +96,25 @@ namespace meta{
using std::function;
/**
* Helper for uniform access to function signature types.
* Extract the type information contained in a function or functor type,
/**************************************************************************//**
* Trait template for uniform access to function signature types.
* Extracts the type information contained in a function or functor type,
* so it can be manipulated by metaprogramming. This template works on
* anything _function like_, irrespective if the parameter is given
* as function reference, function pointer, member function pointer,
* functor object, `std::function` or lambda. The embedded typedefs
* allow to pick up
* allow to expose
* - `Ret` : the return type
* - `Args`: the sequence of argument types as type sequence `Types<ARGS...>`
* - `Sig` : the bare function signature type
* - `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
* 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 primary, catch-all case gets activated whenever on functor objects, i.e. anything
* with an `operator()`.
* The primary, catch-all case gets activated whenever used on functor objects
* proper, i.e. anything with an `operator()`.
* The following explicit specialisations handle the other cases, which are
* not objects, but primitive types (function (member) pointers and references).
* @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 the function call operator is templated
* - on *generic lambdas*
* - on results of std::bind
* All these cases will activate the base (false) case, as if the
* tested subject was not a function at all. Generally speaking,
* it is _not possible_ to probe a generic lambda or templated function,
@ -116,7 +159,7 @@ namespace meta{
: std::true_type
{
using Ret = RET;
using Args = TySeq<ARGS...>;
using Args = Types<ARGS...>;
using Sig = RET(ARGS...);
using Functor = std::function<Sig>;
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 */
template<typename FUN>
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
#endif

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

@ -93,7 +93,7 @@ namespace meta{
static auto
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
return wrapBuilder (func::PApply<TupleBuilderSig, ClosedTypes>::bindFront (buildRecord, move(boundArgs)));
}
@ -104,7 +104,7 @@ namespace meta{
static auto
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)...);
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
** Metaprogramming with tuples-of-types and the `std::tuple` record.
** The metaprogramming part of this header complements typelist.hpp and allows
** some additional manipulations on type sequences, especially to integrate
** with the Tuples provided by the standard library.
** This header complements typelist.hpp and provides a bridge from type sequences
** to the tuple type provided by the standard library, including traits and
** 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
** 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
** Furthermore, a generic iteration construct is provided, to instantiate
** a generic Lambda for each element of a given tuple, which allows to write
** generic code »for each tuple element«.
**
** @see control::CommandDef usage example
** @see TupleHelper_test
@ -142,27 +135,15 @@ namespace meta {
{ };
template<typename...TYPES>
struct BuildTupleType<TySeq<TYPES...>>
struct BuildTupleType<Types<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>
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;
};
@ -195,13 +176,13 @@ namespace meta {
template<typename...TYPES>
struct RebindTupleTypes
{
using Seq = typename TySeq<TYPES...>::Seq;
using Seq = typename Types<TYPES...>::Seq;
using List = typename Seq::List;
};
template<typename...TYPES>
struct RebindTupleTypes<std::tuple<TYPES...>>
{
using Seq = typename TySeq<TYPES...>::Seq;
using Seq = typename Types<TYPES...>::Seq;
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<class,class,class, uint> class _X_
, class TUP
, uint i
>
class BuildTupleAccessor< _X_, TySeq<>, TUP, i>
class BuildTupleAccessor< _X_, Types<>, TUP, i>
{
public:
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
dump (std::tuple<TYPES...> const& tuple)
{
using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, TySeq<TYPES...>>;
using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, Types<TYPES...>>;
using Displayer = typename BuildAccessor::Product ;
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...>>
{
template<size_t i>
using TargetType = typename Pick<TySeq<TYPES...>, i>::Type;
using TargetType = typename Pick<Types<TYPES...>, i>::Type;
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
** realm of type metaprogramming; this approach was pioneered with the
** **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
** in the Loki library, and was in the following years integrated with
** 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_
** 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 TypeListManip_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
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<...>`
*/
/** variadic sequence of types */
template<typename...TYPES>
struct TySeq;
struct Types;
template<typename T, typename...TS>
struct TySeq<T,TS...>
struct Types<T,TS...>
{
using List = Node<T, typename TySeq<TS...>::List>;
using Seq = TySeq;
using List = Node<T, typename Types<TS...>::List>;
using Seq = Types;
};
template<>
struct TySeq<>
struct Types<>
{
using List = Nil;
using Seq = TySeq<>;
using Seq = Types<>;
};
}} // namespace lib::meta

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

@ -22,17 +22,6 @@
** - shifting a type sequence
** - 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 typelist.hpp
** @see typelist-util.hpp
@ -88,11 +77,7 @@ namespace meta {
: SizConst<sizeof...(TYPES)>
{ };
template<class... TYPES>
struct count<TySeq<TYPES...>>
: SizConst<sizeof...(TYPES)>
{ };
template<class... TYPES>
struct count<TyOLD<TYPES...>>
struct count<Types<TYPES...>>
: SizConst<sizeof...(TYPES)>
{ };
@ -101,78 +86,15 @@ namespace meta {
* Helper: prepend a type to an existing type sequence,
* thus shifting all elements within the sequence
* 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>
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>
struct Prepend<T, TySeq<TYPES...>>
struct Prepend<T, Types<TYPES...>>
{
using Seq = TySeq<T, TYPES...>;
using List = typename TySeq<T, TYPES...>::List;
using Seq = Types<T, TYPES...>;
using List = typename Types<T, TYPES...>::List;
};
@ -180,157 +102,73 @@ namespace meta {
/**
* Additional specialisation of the basic type sequence type,
* 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>
struct TySeq< Node<H,T> >
struct Types< Node<H,T> >
{
using List = Node<H,T>;
using Seq = typename Prepend< H
, typename TySeq<T>::Seq
, typename Types<T>::Seq
>::Seq;
};
template<>
struct TySeq<Nil>
struct Types<Nil>
{
using List = Nil;
using Seq = TySeq<>;
using Seq = Types<>;
};
template<>
struct TySeq<NilNode>
: TySeq<Nil>
struct Types<NilNode>
: 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
* @todo support variadic type-seq ////////////////////////////////////////////////////////////////TICKET #987 : make lib::meta::Types<TYPES...> variadic, then replace this by a single variadic template
*/
template<class TYPES>
struct Split;
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : this specialisation handles the variadic case and will be the only definition in future
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 First = TySeq<T1>;
using Tail = TySeq<TS...>;
using First = Types<T1>;
using Tail = Types<TS...>;
// for finding the end we need the help of typelist-util.hpp
using PrefixList = typename PickLast<List>::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 Last = TySeq<End>;
using Last = Types<End>;
};
template<>
struct Split<TySeq<>>
struct Split<Types<>>
{
using List = Nil;
using Head = Nil;
using First = TySeq<>;
using Tail = TySeq<>;
using First = Types<>;
using Tail = Types<>;
// for finding the end we need the help of typelist-util.hpp
using PrefixList = Nil;
using TailList = Nil;
using Prefix = TySeq<>;
using Last = TySeq<>;
using Prefix = Types<>;
using Last = Types<>;
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
*/
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;
};
template<typename...TYPES, size_t i>
struct Pick<TySeq<TYPES...>, i>
{
using Type = typename Shifted<TySeq<TYPES...>, i>::Head;
using Type = typename Shifted<Types<TYPES...>, i>::Head;
};
@ -388,7 +221,7 @@ namespace meta {
template<typename T>
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
** and react specifically on some concrete pattern of argument types.
**
** @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 control::CommandDef usage example
** @remark in Lumiera, over time three different approaches were developed for
** handling sequences of types in metaprogramming; some of these techniques
** are better suited for specific kinds of tasks than others
** - templates with variadic arguments (e.g. std::tuple) can be manipulated directly
** - a type-sequence `Types<T...>` can be primed / rebound from other variadic templates
** - Loki-style type-lists are created from type-sequences and enable elaborate manipulations
** @see feed-manifold.hpp advanced usage example in the Render Engine
** @see TupleHelper_test
** @see typelist.hpp
** @see function.hpp
@ -140,32 +135,8 @@ namespace meta {
};
/** build an index number sequence from a type sequence */
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND -- to be obsoleted
template<typename...TYPES>
struct BuildIdxIter<TyOLD<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...>>
struct BuildIdxIter<Types<TYPES...>>
: BuildIdxIter<TYPES...>
{ };
@ -196,11 +167,11 @@ namespace meta {
{
static constexpr size_t SIZ = 1;
using Idx = std::index_sequence<SIZ>;
using Seq = TySeq<X>;
using Seq = Types<X>;
using Tup = std::tuple<X>;
template<template<class> class META>
using Apply = TySeq<META<X>>;
using Apply = Types<META<X>>;
template<template<typename...> class O>
using Rebind = O<X>;
template<template<class> class PRED>
@ -211,15 +182,15 @@ namespace meta {
/** Partial specialisation to handle type sequences */
template<typename...TYPES>
struct ElmTypes<TySeq<TYPES...>>
struct ElmTypes<Types<TYPES...>>
{
static constexpr size_t SIZ = sizeof...(TYPES);
using Idx = std::make_index_sequence<SIZ>;
using Seq = TySeq<TYPES...>;
using Seq = Types<TYPES...>;
using Tup = std::tuple<TYPES...>;
template<template<class> class META>
using Apply = TySeq<META<TYPES>...>;
using Apply = Types<META<TYPES>...>;
template<template<typename...> class O>
using Rebind = typename lib::meta::RebindVariadic<O, Seq>::Type;
@ -242,7 +213,7 @@ namespace meta {
template<size_t...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;
@ -315,7 +286,7 @@ namespace meta {
return lib::meta::count<typename TTX::List>();
else
{ // 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>());
}
};

2
src/lib/parse.hpp
View file

@ -392,7 +392,7 @@ namespace util {
: tuple<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...>;
SeqModel() = default;

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

@ -166,7 +166,7 @@ namespace time {
/* == Descriptor to define Support for specific formats == */
using lib::meta::TySeq;
using lib::meta::Types;
using lib::meta::Node;
using lib::meta::Nil;
@ -238,7 +238,7 @@ namespace time {
: Supported
{
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
using std::remove_reference;
using meta::TySeq;
using meta::Types;
using meta::Node;
using meta::Nil;
@ -159,8 +159,8 @@ namespace lib {
};
template<class...TYPES, template<class> class _P_>
struct FirstMatchingType<TySeq<TYPES...>, _P_>
: FirstMatchingType<typename TySeq<TYPES...>::List, _P_>
struct FirstMatchingType<Types<TYPES...>, _P_>
: FirstMatchingType<typename Types<TYPES...>::List, _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; }
using WrapperTypes = lib::meta::TySeq< mobject::Placement<mobject::MObject>*
using WrapperTypes = lib::meta::Types< mobject::Placement<mobject::MObject>*
, lib::P<asset::Asset>*
> ::List;
}

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

@ -207,7 +207,7 @@ namespace interact {
using lib::meta::_Fun;
using lib::meta::Split;
using lib::meta::Tuple;
using lib::meta::TySeq;
using lib::meta::Types;
using lib::meta::func::PApply;
typedef typename _Fun<FUN>::Ret Ret;
@ -219,7 +219,7 @@ namespace interact {
"Allocator function must accept UICoordinates (where to create/locate) as first argument");
static_assert (std::is_convertible<Ret, UICoord>::value,
"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");

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

@ -63,7 +63,7 @@ namespace model {
namespace error = lumiera::error;
using interact::UICoord;
using lib::meta::TySeq;
using lib::meta::Types;
using std::string;
class Tangible;
@ -91,7 +91,7 @@ namespace model {
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 */
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
* 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
, const steam::asset::ProcPatt
, 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
** within the CommandMutation (functor).
**
** @todo switch to variadic templates. Requires a rework of Types<...> /////////////////////////////////////TICKET #967
**
** @see Command
** @see CommandDef
** @see argument-tuple-accept-test.cpp
@ -69,19 +67,14 @@ namespace control {
using std::make_tuple;
//
// _______________________________________________________________________________________________________________
/** @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
*/
/** @internal mix in a function operator */
template< class TAR, class BA, class RET
, typename TYPES
>
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>
struct AcceptArgs<TAR,BA,RET, TySeq<ARGS...> >
struct AcceptArgs<TAR,BA,RET, Types<ARGS...> >
: BA
{
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
> //____________________________________
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
*/
/** @internal mix in a \c bind() function */
template< class TAR, class BA, class RET
, typename TYPES
>
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>
struct AcceptBind<TAR,BA,RET, TySeq<ARGS...> >
struct AcceptBind<TAR,BA,RET, Types<ARGS...> >
: BA
{
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 \c bind() functions
/** @internal mix in complete set of templated `bind()` functions
*/
template< class TAR, class BA, class RET>
struct AcceptAnyBind
@ -524,7 +150,7 @@ namespace control {
template<typename...TYPES>
struct _Type<std::tuple<TYPES...> >
{
using Args = typename TyOLD<TYPES...>::Seq;
using Args = typename Types<TYPES...>::Seq;
using Ret = void;
using Sig = typename BuildFunType<void, Args>::Sig;
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::_Fun;
using lib::meta::TySeq;
using lib::meta::Types;
using lib::meta::Append;
using lib::meta::PickLast;
@ -77,7 +77,7 @@ namespace control {
using Args = typename _Fun<SIG>::Args;
using ArgList = typename Args::List;
using ExtendedArglist = typename Append<ArgList, MEM>::List;
using ExtendedArgs = typename TySeq<ExtendedArglist>::Seq;
using ExtendedArgs = typename Types<ExtendedArglist>::Seq;
public:
using OperateSig = typename BuildFunType<void, Args>::Sig;
@ -118,7 +118,7 @@ namespace control {
using Memento = RET;
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 CaptureSig = typename BuildFunType<Ret,ARG>::Sig;
@ -132,7 +132,7 @@ namespace control {
using Memento = typename PickLast<Args>::Type;
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 CaptureSig = typename BuildFunType<Ret,OperationArgs>::Sig;

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

@ -88,7 +88,7 @@ namespace control {
using lib::Symbol;
using std::shared_ptr;
using lib::meta::Tuple;
using lib::meta::TySeq;
using lib::meta::Types;
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::ElmTypes;
using lib::meta::Tagged;
using lib::meta::TySeq;
using lib::meta::Types;
using lib::meta::Nil;
using std::is_pointer;
using std::is_reference;
@ -563,7 +563,7 @@ namespace engine {
};
using ElmsI = typename _Proc::ElmsI;
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?
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 builder {
using BuilderTargetTypes = TySeq< session::Root
using BuilderTargetTypes = Types< session::Root
, session::Clip
, session::Effect
, 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

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

@ -113,7 +113,7 @@ namespace mobject {
{ VTABLE = sizeof(size_t)
, SPEC_SIZ = VTABLE
+ mp::maxSize<
mp::TySeq< PID, lumiera_uid, uint>::List>()
mp::Types< PID, lumiera_uid, uint>::List>()
};
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
* global Session PImpl
*/
using SessionImplAPI = SessionServices< TySeq< SessionServiceFetch
using SessionImplAPI = SessionServices< Types< SessionServiceFetch
, SessionServiceMutate
, SessionServiceExploreScope
, SessionServiceMockIndex

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

@ -78,7 +78,7 @@ namespace mobject {
namespace session {
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)
{
SupportStandardTimecode just_fine;
Supported just_smpte = Supported::formats< TySeq<Smpte> >();
Supported just_simple = Supported::formats< TySeq<Frames,Seconds> >();
Supported just_smpte = Supported::formats< Types<Smpte> >();
Supported just_simple = Supported::formats< Types<Frames,Seconds> >();
Supported& support1 (just_fine);
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 steam::asset::meta::TimeGrid;
using lib::meta::TySeq;
using lib::meta::Types;
using lib::meta::InstantiateChainedCombinations;
using LERR_(UNCONNECTED);
@ -475,8 +475,8 @@ namespace test{
void
TimeControl_test::verifyMatrix_of_MutationCases (TimeValue const& origVal, TimeValue const& change)
{
using KindsOfTarget = TySeq<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 KindsOfTarget = Types<Duration,TimeSpan,QuTime> ; // time entities to receive value changes
using KindsOfSource = Types<TimeValue,Time,Duration,TimeSpan,QuTime>; // time entities to be used as change values
using TestMatrix = InstantiateChainedCombinations< KindsOfTarget
, KindsOfSource
, 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
: public Applicable< Babbler,
TySeq<Boss,BigBoss>::List, // treat this types
Types<Boss,BigBoss>::List, // treat this types
VerboseVisitor<Tool> // intermediary base class
>
{
@ -114,7 +114,7 @@ namespace test2 {
*/
class 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
>
{
@ -137,7 +137,8 @@ namespace test2 {
*/
class VisitingToolExtended_test : public Test
{
virtual void run(Arg)
virtual void
run(Arg)
{
known_visitor_known_class();
visitor_not_visiting_some_class();

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

@ -58,6 +58,7 @@ namespace test1 {
class Leader : public Visionary
{
/* can not be visited */
};
@ -74,8 +75,8 @@ namespace test1 {
class Babbler
: public Applicable< Babbler
, TySeq<Boss,BigBoss,Visionary>::List // dispatch calls to this types
, VerboseVisitor
, Types<Boss,BigBoss,Visionary>::List // dispatch calls to this types
, VerboseVisitor // (base class / interface)
>
{
public:
@ -83,9 +84,9 @@ namespace test1 {
void treat (BigBoss&) { talk_to("Big Boss"); }
};
// note the following details:
// note the following fine points:
// - 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;
// masquerade as HomoSapiens...
HomoSapiens& homo1 (x1);
HomoSapiens& homo2 (x2);
HomoSapiens& homo1{x1};
HomoSapiens& homo2{x2};
cout << "=== Babbler meets Boss and BigBoss ===\n";
Babbler bab;
VisitingTool& vista (bab);
VisitingTool& vista{bab};
homo1.apply (vista);
homo2.apply (vista);
}
@ -141,7 +142,6 @@ namespace test1 {
homo1.apply (vista); // silent error handler (not Applicable to HomoSapiens)
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
bindRandArgument (CommandImpl& cmd)
{
using ArgType = TySeq<int>;
TypedArguments<Tuple<ArgType>> arg (std::make_tuple (rani (10000)));
TypedArguments<std::tuple<int>> arg {std::make_tuple (rani (10000))};
cmd.setArguments (arg);
CHECK (cmd.canExec());
}
@ -126,7 +125,7 @@ namespace test {
void
verifySeparation (PCmdImpl orig, PCmdImpl copy)
{
CHECK (orig && copy);
CHECK (orig and copy);
CHECK (orig->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_undo> Fun_u;
using ArgTuple = Tuple<TySeq<char>>;
using ArgTuple = std::tuple<char>;
using ArgHolder = OpClosure<Sig_oper>;
using MemHolder = MementoTie<Sig_oper, string>;
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) );
// 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};
CmdClosure& closure (closed_over);
@ -154,7 +154,7 @@ namespace test {
VERIFY_ERROR (UNBOUND_ARGUMENTS, undoFunctor(nullClosure) );
VERIFY_ERROR (UNBOUND_ARGUMENTS, undoFunctor.captureState(nullClosure) );
Tuple<TySeq<>> param;
Tuple<Types<>> param;
SimpleClosure<void()> clo{param};
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
// 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);
CHECK (1+cnt_inst == registry.instance_count());
@ -210,8 +210,8 @@ namespace test {
CHECK (!isSameObject (*pImpl, *clone));
CHECK (!pImpl->canExec());
using ArgType = TySeq<int>;
TypedArguments<Tuple<ArgType>> arg{Tuple<ArgType>(98765)};
using ArgTuple = std::tuple<int>;
TypedArguments<ArgTuple> arg{ArgTuple{98765}};
pImpl->setArguments(arg);
CHECK (pImpl->canExec());

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

@ -168,10 +168,10 @@ namespace test {
CHECK (com);
CHECK (not com->canExec());
using ArgType = TySeq<int>;
using ArgTuple = std::tuple<int>;
const int ARGR{1 + rani (1000)};
Tuple<ArgType> tuple(ARGR);
TypedArguments<Tuple<ArgType>> arg(tuple);
ArgTuple argTup{ARGR};
TypedArguments<ArgTuple> arg{argTup};
com->setArguments(arg);
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
*/
class TestTool
: public Applicable<TestTool, TySeq<Clip, DummyMO>::List>
: public Applicable<TestTool, Types<Clip, DummyMO>::List>
{
public:
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
// of the complete Session + SessionManager setup.....
using lib::meta::TySeq;
using lib::meta::Types;
using lib::meta::InstantiateChained;
@ -161,7 +161,7 @@ namespace test {
struct TSessManagerImpl;
using SessionImplAPI = TSessionServices< TySeq<InternalAPI_1,InternalAPI_2>
using SessionImplAPI = TSessionServices< Types<InternalAPI_1,InternalAPI_2>
, TSessManagerImpl
, TSessionImpl
>;

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

@ -46,8 +46,8 @@ namespace test {
namespace { // test data
using List1 = TySeq<Num<1>, Num<2>, Num<3> >::List;
using List2 = TySeq<Num<5>, Num<6>, Num<7> >::List;
using List1 = Types<Num<1>, Num<2>, Num<3> >::List;
using List2 = Types<Num<5>, Num<6>, Num<7> >::List;
/** special test fun
@ -140,10 +140,10 @@ namespace test {
{
cout << "\t:\n\t: ---Bind----\n";
Tuple<TySeq<>> tup0 ;
Tuple<TySeq<int>> tup1 (11);
Tuple<TySeq<int,int>> tup2 (11,12);
Tuple<TySeq<int,int,int>> tup3 (11,12,13);
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
DUMPVAL (tup0);
DUMPVAL (tup1);
DUMPVAL (tup2);
@ -167,10 +167,10 @@ namespace test {
void
check_bindFunc ()
{
Tuple<TySeq<>> tup0 ;
Tuple<TySeq<int>> tup1 (11);
Tuple<TySeq<int,int>> tup2 (11,12);
Tuple<TySeq<int,int,int>> tup3 (11,12,13);
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
function<int()> unbound_functor0 (fun0);
function<int(int)> unbound_functor1 (fun1);
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--- //
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)
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--- //
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)};
fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind);
@ -281,7 +281,7 @@ namespace test {
// 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> 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...
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....
typedef TySeq< Num<1>
typedef Types< Num<1>
, Num<3>
, Num<5>
> Types1;
typedef TySeq< Num<2>
typedef Types< Num<2>
, Num<4>
, Num<6>
> Types2;

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

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

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

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

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

@ -44,14 +44,14 @@ namespace test {
namespace { // test data
typedef TySeq< Num<1>
typedef Types< Num<1>
, Num<3>
, Num<5>
> Types1;
typedef TySeq< Num<2>
typedef Types< Num<2>
, Num<4>
> Types2;
typedef TySeq< Num<7>> Types3;
typedef Types< Num<7>> Types3;
@ -132,7 +132,7 @@ namespace test {
Prepend prep (22, 11,33,Num<5>());
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
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::MakeRec;
using lib::diff::GenNode;
using lib::meta::TySeq;
using lib::meta::Types;
using lib::meta::Tuple;
using lib::meta::buildTuple;
using lib::time::Duration;
@ -82,8 +82,8 @@ namespace test {
void
show_simpleUsage()
{
using NiceTypes = TySeq<string, int>;
using UgglyTypes = TySeq<EntryID<long>, Symbol, int, int64_t, double, Duration>; // various conversions and an immutable type (Duration)
using NiceTypes = Types<string, int>;
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 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);
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
using Unsigned = TySeq<string, uint>;
using Floating = TySeq<string, float>;
using Narrowing = TySeq<string, short>;
using Unsigned = Types<string, uint>;
using Floating = Types<string, float>;
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<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
// yet other (non-numeric) conversions are still possible
Rec timeArg = MakeRec().scope(Time(1,2,3,4));
using TupStr = TySeq<string>;
using TupStr = Types<string>;
Tuple<TupStr> tup = buildTuple<TupStr> (timeArg);
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<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
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.
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
using List1 = TySeq< Num<1>
using List1 = Types< Num<1>
, Num<2>
, Num<3>
>::List;
using List2 = TySeq< Num<5>
using List2 = Types< Num<5>
, Num<6>
, Num<7>
>::List;
@ -158,7 +158,7 @@ namespace test {
using Elm = PickLast<List1>::Type;
using Prefix = PickLast<List1>::List;
using ElmL = TySeq<Elm>::List;
using ElmL = Types<Elm>::List;
EXPECT (Prefix, "-<1>-<2>-");
EXPECT (ElmL , "-<3>-" );
@ -166,7 +166,7 @@ namespace test {
using Elm1 = PickLast<ElmL>::Type;
using NPrefix = PickLast<ElmL>::List;
EXPECT (TySeq<Elm1>, "-<3>-");
EXPECT (Types<Elm1>, "-<3>-");
EXPECT (NPrefix , "-");
using NilSplit = PickLast<Nil>::Type;
@ -204,16 +204,16 @@ namespace test {
void
verify_splice ()
{ // various base lists
using BaLi1 = TySeq<Num<1>>::List; EXPECT (BaLi1, "-<1>-");
using BaLi2 = TySeq<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 BaLi5 = TySeq<Num<1>,Num<2>,Num<3>,Num<4>,Num<5>>::List;
using BaLi1 = Types<Num<1>>::List; EXPECT (BaLi1, "-<1>-");
using BaLi2 = Types<Num<1>,Num<2>>::List; EXPECT (BaLi2, "-<1>-<2>-");
using BaLi3 = Types<Num<1>,Num<2>,Num<3>>::List; EXPECT (BaLi3, "-<1>-<2>-<3>-");
using BaLi5 = Types<Num<1>,Num<2>,Num<3>,Num<4>,Num<5>>::List;
EXPECT (BaLi5, "-<1>-<2>-<3>-<4>-<5>-");
// will "paste" those overlay lists "on top" the base typelists...
using OLi1 = TySeq<Num<9>>::List; EXPECT (OLi1, "-<9>-");
using OLi2 = TySeq<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 OLi1 = Types<Num<9>>::List; EXPECT (OLi1, "-<9>-");
using OLi2 = Types<Num<9>,Num<8>>::List; EXPECT (OLi2, "-<9>-<8>-");
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 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,
// 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
using List_of_Lists = TySeq<List1::List
using List_of_Lists = Types<List1::List
,Num<0> // ◁—————————————— this one is a regular element
,List2::List>::List;
EXPECT (List_of_Lists,
@ -573,7 +573,7 @@ namespace test {
"\n\t" "+---<11>-<2>-+"
"\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>>;
EXPECT (Dist2, "\n\t" "+---<11>-<0>-+"
"\n\t" "+---<22>-<0>-+"
@ -590,7 +590,7 @@ namespace test {
"\n\t" "+---<33>-<2>-+"
"\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>-+"
"\n\t" "+---<5>-<6>-<7>-+-");
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<8>
, 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
, int64_t
, uint64_t
>::List;
using EmptyList = TySeq< >::List;
using EmptyList = Types< >::List;

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

@ -43,14 +43,14 @@ namespace test {
namespace { // type-sequences to test with
typedef TySeq< Num<1>
using Types1 = Types< Num<1>
, Num<2>
, Num<3>
> Types1;
typedef TySeq< Num<7>
>;
using Types2 = Types< Num<7>
, Num<8>
, Num<9>
> Types2;
>;
} // (End) test data
@ -96,12 +96,12 @@ namespace test {
using LL = Append<Types1::List, Types2::List>::List;
EXPECT (LL, "-<1>-<2>-<3>-<7>-<8>-<9>-");
using Seq = TySeq<LL>::Seq;
using Seq = Types<LL>::Seq;
using SeqList = Seq::List;
EXPECT (Seq, "-<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, "-");
}
@ -111,8 +111,8 @@ namespace test {
{
using Prepend1 = Prepend<Num<5>, Types1 >; EXPECT (Prepend1, "-<5>-<1>-<2>-<3>-");
using Prepend2 = Prepend<Nil, Types1 >; EXPECT (Prepend2, "-<·>-<1>-<2>-<3>-");
using Prepend3 = Prepend<Num<5>, TySeq<>>; EXPECT (Prepend3, "-<5>-");
using Prepend4 = Prepend<Nil, TySeq<>>; EXPECT (Prepend4, "-");
using Prepend3 = Prepend<Num<5>, Types<>>; EXPECT (Prepend3, "-<5>-");
using Prepend4 = Prepend<Nil, Types<>>; EXPECT (Prepend4, "-");
}
@ -120,7 +120,7 @@ namespace test {
check_shift ()
{
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_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_6 = Shifted<Seq,6>::Type; EXPECT (Seq_6, "-");
using Head_0 = TySeq<Shifted<Seq,0>::Head>; EXPECT (Head_0, "-<7>-");
using Head_1 = TySeq<Shifted<Seq,1>::Head>; EXPECT (Head_1, "-<8>-");
using Head_2 = TySeq<Shifted<Seq,2>::Head>; EXPECT (Head_2, "-<9>-");
using Head_3 = TySeq<Shifted<Seq,3>::Head>; EXPECT (Head_3, "-<1>-");
using Head_4 = TySeq<Shifted<Seq,4>::Head>; EXPECT (Head_4, "-<2>-");
using Head_5 = TySeq<Shifted<Seq,5>::Head>; EXPECT (Head_5, "-<3>-");
using Head_6 = TySeq<Shifted<Seq,6>::Head>; EXPECT (Head_6, "-" );
using Head_7 = TySeq<Shifted<Seq,7>::Head>; EXPECT (Head_7, "-" );
using Head_0 = Types<Shifted<Seq,0>::Head>; EXPECT (Head_0, "-<7>-");
using Head_1 = Types<Shifted<Seq,1>::Head>; EXPECT (Head_1, "-<8>-");
using Head_2 = Types<Shifted<Seq,2>::Head>; EXPECT (Head_2, "-<9>-");
using Head_3 = Types<Shifted<Seq,3>::Head>; EXPECT (Head_3, "-<1>-");
using Head_4 = Types<Shifted<Seq,4>::Head>; EXPECT (Head_4, "-<2>-");
using Head_5 = Types<Shifted<Seq,5>::Head>; EXPECT (Head_5, "-<3>-");
using Head_6 = Types<Shifted<Seq,6>::Head>; EXPECT (Head_6, "-" );
using Head_7 = Types<Shifted<Seq,7>::Head>; EXPECT (Head_7, "-" );
}
@ -145,7 +145,7 @@ namespace test {
check_split ()
{
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 First = Split<Seq>::First; EXPECT (First , "-<1>-" );
@ -156,10 +156,10 @@ namespace test {
using Head = Split<Seq>::Head;
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 NoHead = Split<TySeq<>>::Head; EXPECT (NoHead, "-");
using NoList = Split<Types<>>::List; EXPECT (NoList, "-");
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>;
CHECK (2 == S1::SIZ);
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::Idx >() == "integer_sequence<ulong, 0ul, 1ul>"_expect);
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_>;
CHECK (showType< S1AR >() == "__and_<is_pointer<int>, is_pointer<double> >"_expect);
@ -98,12 +98,12 @@ namespace test {
using S0 = ElmTypes<T0>;
CHECK (1 == S0::SIZ);
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::Idx >() == "integer_sequence<ulong, 1ul>"_expect);
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>;
CHECK (showType< S0AA >() == "__and_<is_pointer<int*> >"_expect);
@ -121,12 +121,12 @@ namespace test {
using S2 = ElmTypes<T2>;
CHECK (3 == S2::SIZ);
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::Idx >() == "integer_sequence<ulong, 0ul, 1ul, 2ul>"_expect);
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>;
CHECK (showType< S2AA >() == "__and_<is_pointer<int*>, is_pointer<int*>, is_pointer<int*> >"_expect);
@ -144,11 +144,11 @@ namespace test {
using S3 = ElmTypes<T3>;
CHECK (3 == S3::SIZ);
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);
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>;
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{
using ::Test;
using meta::TySeq;
using meta::Types;
using lib::time::Time;
using lib::time::TimeVar;
@ -43,7 +43,7 @@ namespace test{
// Test fixture...
using TestVariant = Variant<TySeq<bool,int,string,Time>>;
using TestVariant = Variant<Types<bool,int,string,Time>>;

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

@ -294,8 +294,7 @@ namespace test {
{
using Ret = typename lib::meta::_Fun<SIG>::Ret;
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, ArgsX>::Seq;
using SigTypes = typename lib::meta::Prepend<Ret, Args>::Seq;
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"/>
</node>
<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"/>
<node COLOR="#435e98" CREATED="1744755518679" ID="ID_1083442460" MODIFIED="1744755532011" TEXT="lib::Several hat sich gut etabliert">
<icon BUILTIN="ksmiletris"/>
@ -161972,7 +161972,8 @@ actively maintained upstream. Please remove gdl from Debian.</pre>
</node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1439176875682" ID="ID_1482098521" MODIFIED="1742175232490" TEXT="Debian/Trixie">
<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">
<icon BUILTIN="button_ok"/>
<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 BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1742175611912" ID="ID_16098937" MODIFIED="1747359127313" TEXT="etwas aufr&#xe4;umen">
<icon BUILTIN="pencil"/>
<node COLOR="#338800" CREATED="1742175611912" ID="ID_16098937" MODIFIED="1749341021068" TEXT="etwas aufr&#xe4;umen">
<icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1742175621250" FOLDED="true" ID="ID_1886919024" MODIFIED="1745860228467" TEXT="boost-filesystem loswerden!">
<icon BUILTIN="button_ok"/>
<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;"/>
</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"/>
<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>
<head>
<body>
@ -163099,7 +163100,7 @@ Since then others have made contributions, see the log for the history.</font></
</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"/>
<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"/>
@ -163201,7 +163202,7 @@ Since then others have made contributions, see the log for the history.</font></
</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="#4c3b8b" DESTINATION="ID_1554376708" ENDARROW="Default" ENDINCLINATION="219;519;" ID="Arrow_ID_589652743" SOURCE="ID_219954631" STARTARROW="None" STARTINCLINATION="326;-188;"/>
<icon BUILTIN="yes"/>
@ -163807,7 +163808,7 @@ Since then others have made contributions, see the log for the history.</font></
</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"/>
<node COLOR="#338800" CREATED="1748561872884" ID="ID_962941766" MODIFIED="1748563677391" TEXT="Ansatzpunkte">
<icon BUILTIN="idea"/>
@ -163855,11 +163856,17 @@ Since then others have made contributions, see the log for the history.</font></
<icon BUILTIN="ksmiletris"/>
</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">
<arrowlink COLOR="#fd26d0" DESTINATION="ID_1135941103" ENDARROW="Default" ENDINCLINATION="-1048;89;" ID="Arrow_ID_1050531240" STARTARROW="None" STARTINCLINATION="-1120;-23;"/>
<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="#265efd" DESTINATION="ID_1135941103" ENDARROW="Default" ENDINCLINATION="-1048;89;" ID="Arrow_ID_1050531240" STARTARROW="None" STARTINCLINATION="-1120;-23;"/>
<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"/>
<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 COLOR="#435e98" CREATED="1748609941535" ID="ID_309992355" MODIFIED="1748738408223" TEXT="Status feststellen">
<icon BUILTIN="yes"/>
@ -164234,10 +164241,10 @@ Since then others have made contributions, see the log for the history.</font></
</node>
<node CREATED="1748731316160" ID="ID_1388202310" MODIFIED="1748731324655" TEXT="hash-fnv.h|c"/>
</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"/>
<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"/>
<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"/>
@ -164355,7 +164362,7 @@ Since then others have made contributions, see the log for the history.</font></
</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;"/>
<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 ">
@ -164392,8 +164399,8 @@ Since then others have made contributions, see the log for the history.</font></
</html></richcontent>
<icon BUILTIN="button_ok"/>
</node>
<node BACKGROUND_COLOR="#eee5c3" COLOR="#990000" CREATED="1748826894390" ID="ID_1736451439" MODIFIED="1748826903420" TEXT="Zonen f&#xfc;r Umstellung identifizieren">
<icon BUILTIN="flag-yellow"/>
<node BACKGROUND_COLOR="#d1d3d8" COLOR="#524398" CREATED="1748826894390" FOLDED="true" ID="ID_1736451439" MODIFIED="1749340895600" TEXT="Zonen f&#xfc;r Umstellung identifizieren">
<icon BUILTIN="yes"/>
<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="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>
</node>
<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_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;"/>
@ -165424,33 +165431,50 @@ Since then others have made contributions, see the log for the history.</font></
</node>
<node CREATED="1748830139501" ID="ID_622177889" MODIFIED="1748830160252" TEXT="ElmTypes ist nur f&#xfc;r neue (variadisch) definiert"/>
</node>
<node CREATED="1748829176262" ID="ID_1246318914" MODIFIED="1748829178958" TEXT="Variant"/>
<node CREATED="1748829201135" ID="ID_1330371655" MODIFIED="1748829203111" TEXT="Visitor"/>
<node CREATED="1748829220424" ID="ID_795696886" MODIFIED="1748829224836" TEXT="Session-Command">
<node COLOR="#435e98" CREATED="1748829176262" ID="ID_1246318914" MODIFIED="1749340864846" TEXT="Variant"/>
<node COLOR="#435e98" CREATED="1748829201135" ID="ID_1330371655" MODIFIED="1749340864846" TEXT="Visitor"/>
<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="1748829241698" ID="ID_1502522588" MODIFIED="1748829249189" TEXT="dann sollte big-Bang m&#xf6;glich sein"/>
</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>
<node CREATED="1748829316732" ID="ID_733906672" MODIFIED="1748829324434" TEXT="Timecode-formate"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748829331775" ID="ID_1553022384" MODIFIED="1748900515205" TEXT="Tests">
<icon BUILTIN="pencil"/>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1748829335663" ID="ID_953757498" MODIFIED="1748900529301" TEXT="jeweils bei Bezug mit umstellen">
<node COLOR="#435e98" CREATED="1748829316732" ID="ID_733906672" MODIFIED="1749340869312" TEXT="Timecode-formate"/>
<node COLOR="#338800" CREATED="1748829331775" FOLDED="true" ID="ID_1553022384" MODIFIED="1749340860142" TEXT="Tests">
<icon BUILTIN="button_ok"/>
<node COLOR="#435e98" CREATED="1748829335663" ID="ID_953757498" MODIFIED="1749336247762" TEXT="jeweils bei Bezug mit umstellen">
<icon BUILTIN="yes"/>
</node>
<node CREATED="1748829344620" ID="ID_1034418764" MODIFIED="1748883769361" TEXT="im Einzelnen">
<icon BUILTIN="list"/>
<node CREATED="1748829369449" MODIFIED="1748829369449" TEXT="FormatSupport_test"/>
<node CREATED="1748829384655" MODIFIED="1748829384655" TEXT="TimeControl_test"/>
<node CREATED="1748829402514" MODIFIED="1748829402514" TEXT="VisitingTool_test"/>
<node CREATED="1748829412897" MODIFIED="1748829412897" TEXT="CommandCloneBuilder_test"/>
<node CREATED="1748829420654" MODIFIED="1748829420654" TEXT="CommandEquality_test"/>
<node CREATED="1748829427640" MODIFIED="1748829427640" TEXT="CommandMutation_test"/>
<node CREATED="1748829435006" MODIFIED="1748829435006" TEXT="CommandRegistry_test"/>
<node CREATED="1748829442778" MODIFIED="1748829442778" TEXT="HandlingPatternBasics_test"/>
<node CREATED="1748829453011" MODIFIED="1748829453011" TEXT="BuilderTool_test"/>
<node CREATED="1748829468217" MODIFIED="1748829468217" TEXT="SessionServiceAccess_test"/>
<node COLOR="#435e98" CREATED="1748829369449" ID="ID_1712572941" MODIFIED="1749296147872" TEXT="FormatSupport_test"/>
<node COLOR="#435e98" CREATED="1748829384655" ID="ID_818292101" MODIFIED="1749297906698" TEXT="TimeControl_test"/>
<node COLOR="#435e98" CREATED="1748829402514" ID="ID_1475154957" MODIFIED="1749298311811" TEXT="VisitingTool_test"/>
<node COLOR="#5b280f" CREATED="1748829412897" ID="ID_1140250977" MODIFIED="1749298480081" TEXT="CommandCloneBuilder_test">
<icon BUILTIN="button_cancel"/>
<node COLOR="#744398" CREATED="1749298484082" HGAP="22" ID="ID_1296599024" MODIFIED="1749336241334" TEXT="std::tuple stat type-seq verwendet" VSHIFT="5">
<arrowlink COLOR="#8526c8" DESTINATION="ID_783380997" ENDARROW="None" ENDINCLINATION="54;5;" ID="Arrow_ID_829287253" STARTARROW="None" STARTINCLINATION="5;20;"/>
<arrowlink COLOR="#9e6ac3" DESTINATION="ID_556747715" ENDARROW="None" ENDINCLINATION="102;11;" ID="Arrow_ID_1444297637" STARTARROW="None" STARTINCLINATION="13;57;"/>
<font NAME="SansSerif" SIZE="9"/>
</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">
<linktarget COLOR="#a9b4c1" DESTINATION="ID_142039126" ENDARROW="Default" ENDINCLINATION="726;0;" ID="Arrow_ID_535671141" SOURCE="ID_240022720" STARTARROW="None" STARTINCLINATION="726;0;"/>
</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">
<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 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">
<linktarget COLOR="#a9b4c1" DESTINATION="ID_653647632" ENDARROW="Default" ENDINCLINATION="135;-20;" ID="Arrow_ID_1807168701" SOURCE="ID_145174722" STARTARROW="None" STARTINCLINATION="235;315;"/>
</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">
<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 CREATED="1748829607017" MODIFIED="1748829607017" TEXT="Variant_test"/>
<node COLOR="#435e98" CREATED="1748829607017" ID="ID_596384261" MODIFIED="1749265034416" TEXT="Variant_test"/>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871733811" ID="ID_1327114043" MODIFIED="1748871745451" TEXT="schrittweise umarbeiten...">
<icon BUILTIN="pencil"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871746934" ID="ID_1013283697" MODIFIED="1748883821476" TEXT="mit einfachen Typ-Listen anfangen">
<icon BUILTIN="pencil"/>
<node COLOR="#338800" CREATED="1748871733811" FOLDED="true" ID="ID_1327114043" MODIFIED="1749340906083" TEXT="schrittweise umarbeiten...">
<icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1748871746934" ID="ID_1013283697" MODIFIED="1749265043727" TEXT="mit einfachen Typ-Listen anfangen">
<icon BUILTIN="button_ok"/>
<node COLOR="#338800" CREATED="1748871760093" ID="ID_234969081" MODIFIED="1748883829134" TEXT="alle Konvertierungspfade aufgedoppelt">
<icon BUILTIN="button_ok"/>
</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">
<icon BUILTIN="pencil"/>
<node COLOR="#338800" CREATED="1748871777734" ID="ID_543292197" MODIFIED="1749265045831" TEXT="die zugeh&#xf6;rigen Tests auf die neuen Typ-Sequenzen umstellen">
<icon BUILTIN="button_ok"/>
</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"/>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871820220" ID="ID_446849123" MODIFIED="1748883860119" TEXT="typedefs durch using ersetzen">
<icon BUILTIN="pencil"/>
<node COLOR="#338800" CREATED="1748871820220" ID="ID_446849123" MODIFIED="1749336257348" TEXT="typedefs durch using ersetzen">
<icon BUILTIN="button_ok"/>
</node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748871829578" ID="ID_308061484" MODIFIED="1748883860119" TEXT="Meta-Wertfunktionen in constexpr &#xfc;berf&#xfc;hren">
<icon BUILTIN="pencil"/>
<node COLOR="#338800" CREATED="1748871829578" ID="ID_308061484" MODIFIED="1749336409239" TEXT="Meta-Wertfunktionen in constexpr &#xfc;berf&#xfc;hren">
<icon BUILTIN="button_ok"/>
</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"/>
</node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1748900565184" ID="ID_1203054358" MODIFIED="1748900572521" TEXT="ExpectString verwenden">
<icon BUILTIN="pencil"/>
<node COLOR="#338800" CREATED="1748900565184" ID="ID_1203054358" MODIFIED="1749336262676" TEXT="ExpectString verwenden">
<icon BUILTIN="button_ok"/>
</node>
</node>
</node>
<node BACKGROUND_COLOR="#eef0c5" COLOR="#990000" CREATED="1749177155817" ID="ID_253850750" MODIFIED="1749177176623" TEXT="dann den Themenkomplex &#xbb;Funktionen&#xab; angehen">
<icon BUILTIN="pencil"/>
<node COLOR="#338800" CREATED="1749177155817" ID="ID_253850750" MODIFIED="1749265047728" TEXT="dann den Themenkomplex &#xbb;Funktionen&#xab; angehen">
<icon BUILTIN="button_ok"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1749177180341" ID="ID_1746274296" MODIFIED="1749177280835">
<richcontent TYPE="NODE"><html>
<head/>
@ -165587,8 +165611,14 @@ Since then others have made contributions, see the log for the history.</font></
<icon BUILTIN="button_ok"/>
</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 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"/>
<node BACKGROUND_COLOR="#e0ceaa" COLOR="#690f14" CREATED="1748873298068" ID="ID_132055056" MODIFIED="1748873322310" TEXT="182 usages...">
<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"/>
</node>
</node>
<node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1748873250610" ID="ID_7395466" MODIFIED="1748873280467" TEXT="Big-Bang: TySeq &#x27fc; Types">
<icon BUILTIN="hourglass"/>
<node COLOR="#338800" CREATED="1748873250610" ID="ID_7395466" MODIFIED="1749340803860" TEXT="Big-Bang: TySeq &#x27fc; Types">
<icon BUILTIN="button_ok"/>
</node>
</node>
</node>