benn/lumiera_
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean-up: prepare for variadic Type-Sequences (see #987)

Browse source 
Attempting to reduce the remaining pre-C++11 workarounds before upgrade to C++20...

As a first step: rename the old type-sequence implementation into `TyOLD`
to make it clearly distinguishable; a new variadic implementation `TySeq`
was already introduced as partial workaround, and the next steps
will be to switch over essential parts of the type-sequence library.
This commit is contained in:
Fischlurch 2025-06-02 02:24:09 +02:00
parent 1da5d57098
commit 7aa1698a95
47 changed files with 238 additions and 193 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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::Types<int
using DataValues = meta::TyOLD<int
,int64_t
,short
,char

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

@ -575,7 +575,7 @@ namespace func{
using Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::List;
using ValList = typename VAL::List;
using ValTypes = typename Types<ValList>::Seq;
using ValTypes = typename TyOLD<ValList>::Seq;
enum { ARG_CNT = count<ArgsList>::value
, VAL_CNT = count<ValList> ::value
@ -587,8 +587,8 @@ namespace func{
using LeftReduced = typename Splice<ArgsList, ValList>::Back;
using RightReduced = typename Splice<ArgsList, ValList, ROFFSET>::Front;
using ArgsL = typename Types<LeftReduced>::Seq;
using ArgsR = typename Types<RightReduced>::Seq;
using ArgsL = typename TyOLD<LeftReduced>::Seq;
using ArgsR = typename TyOLD<RightReduced>::Seq;
// build a list, where each of the *remaining* arguments is replaced by a placeholder marker
@ -600,8 +600,8 @@ namespace func{
using LeftReplaced = typename Splice<ArgsList, TrailingPlaceholders, VAL_CNT>::List;
using RightReplaced = typename Splice<ArgsList, LeadingPlaceholders, 0 >::List;
using LeftReplacedTypes = typename Types<LeftReplaced>::Seq;
using RightReplacedTypes = typename Types<RightReplaced>::Seq;
using LeftReplacedTypes = typename TyOLD<LeftReplaced>::Seq;
using RightReplacedTypes = typename TyOLD<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
@ -679,7 +679,7 @@ namespace func{
using Args = typename _Fun<SIG>::Args;
using Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::List;
using ValList = typename Types<X>::List;
using ValList = typename TyOLD<X>::List;
enum { ARG_CNT = count<ArgsList>::value };
@ -694,8 +694,8 @@ namespace func{
>::List;
using ReducedArgs = typename Append<RemainingFront, RemainingBack>::List;
using PreparedArgTypes = typename Types<PreparedArgs>::Seq;
using RemainingArgs = typename Types<ReducedArgs>::Seq;
using PreparedArgTypes = typename TyOLD<PreparedArgs>::Seq;
using RemainingArgs = typename TyOLD<ReducedArgs>::Seq;
using ReducedSig = typename BuildFunType<Ret,RemainingArgs>::Sig;
@ -844,10 +844,10 @@ namespace func{
*/
template<typename...ARG>
inline
typename _Sig<void, Types<ARG...>>::Applicator
typename _Sig<void, TyOLD<ARG...>>::Applicator
tupleApplicator (std::tuple<ARG...>& args)
{
typedef typename _Sig<void,Types<ARG...>>::Type Signature;
typedef typename _Sig<void,TyOLD<ARG...>>::Type Signature;
return TupleApplicator<Signature> (args);
}
@ -860,7 +860,7 @@ namespace func{
apply (SIG& f, std::tuple<ARG...>& args)
{
typedef typename _Fun<SIG>::Ret Ret; //
typedef typename _Sig<Ret,Types<ARG...>>::Type Signature; // Note: deliberately re-building the Signature Type
typedef typename _Sig<Ret,TyOLD<ARG...>>::Type Signature; // Note: deliberately re-building the Signature Type
return TupleApplicator<Signature> (args) (f); // in order to get better error messages here
}
@ -871,10 +871,10 @@ namespace func{
* function result. */
template<typename SIG, typename...ARG>
inline
typename _Clo<SIG,Types<ARG...>>::Type
typename _Clo<SIG,TyOLD<ARG...>>::Type
closure (SIG& f, std::tuple<ARG...>& args)
{
typedef typename _Clo<SIG,Types<ARG...>>::Type Closure;
typedef typename _Clo<SIG,TyOLD<ARG...>>::Type Closure;
return Closure (f,args);
}

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

@ -355,7 +355,7 @@ namespace meta{
///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisations become obsolete with the old-style type-sequence
template< typename RET>
struct BuildFunType<RET, Types<> >
struct BuildFunType<RET, TyOLD<> >
{
using Sig = RET(void);
using Fun = _Fun<Sig>;
@ -367,7 +367,7 @@ namespace meta{
template< typename RET
, typename A1
>
struct BuildFunType<RET, Types<A1>>
struct BuildFunType<RET, TyOLD<A1>>
{
using Sig = RET(A1);
using Fun = _Fun<Sig>;
@ -380,7 +380,7 @@ namespace meta{
, typename A1
, typename A2
>
struct BuildFunType<RET, Types<A1,A2>>
struct BuildFunType<RET, TyOLD<A1,A2>>
{
using Sig = RET(A1,A2);
using Fun = _Fun<Sig>;
@ -394,7 +394,7 @@ namespace meta{
, typename A2
, typename A3
>
struct BuildFunType<RET, Types<A1,A2,A3>>
struct BuildFunType<RET, TyOLD<A1,A2,A3>>
{
using Sig = RET(A1,A2,A3);
using Fun = _Fun<Sig>;
@ -409,7 +409,7 @@ namespace meta{
, typename A3
, typename A4
>
struct BuildFunType<RET, Types<A1,A2,A3,A4>>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4>>
{
using Sig = RET(A1,A2,A3,A4);
using Fun = _Fun<Sig>;
@ -425,7 +425,7 @@ namespace meta{
, typename A4
, typename A5
>
struct BuildFunType<RET, Types<A1,A2,A3,A4,A5>>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4,A5>>
{
using Sig = RET(A1,A2,A3,A4,A5);
using Fun = _Fun<Sig>;
@ -442,7 +442,7 @@ namespace meta{
, typename A5
, typename A6
>
struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6>>
struct BuildFunType<RET, TyOLD<A1,A2,A3,A4,A5,A6>>
{
using Sig = RET(A1,A2,A3,A4,A5,A6);
using Fun = _Fun<Sig>;
@ -460,7 +460,7 @@ namespace meta{
, typename A6
, typename A7
>
struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6,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>;
@ -479,7 +479,7 @@ namespace meta{
, typename A7
, typename A8
>
struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6,A7,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>;
@ -499,7 +499,7 @@ namespace meta{
, typename A8
, typename A9
>
struct BuildFunType<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8,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>;

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

@ -152,9 +152,9 @@ namespace meta {
* prior to rebinding to the `std::tuple` type.
*/
template<typename...TYPES>
struct BuildTupleType<Types<TYPES...>>
struct BuildTupleType<TyOLD<TYPES...>>
{
using VariadicSeq = typename StripNullType<Types<TYPES...>>::Seq;
using VariadicSeq = typename StripNullType<TyOLD<TYPES...>>::Seq;
using Type = typename BuildTupleType<VariadicSeq>::Type;
};
@ -162,14 +162,14 @@ namespace meta {
template<class H, typename TAIL>
struct BuildTupleType<Node<H, TAIL>>
{
using Seq = typename Types< Node<H,TAIL>>::Seq;
using Seq = typename TyOLD< Node<H,TAIL>>::Seq;
using Type = typename BuildTupleType<Seq>::Type;
};
template<>
struct BuildTupleType<NullType>
{
using Type = typename BuildTupleType<Types<>>::Type;
using Type = typename BuildTupleType<TyOLD<>>::Type;
};
}
@ -195,13 +195,13 @@ namespace meta {
template<typename...TYPES>
struct RebindTupleTypes
{
using Seq = typename Types<TYPES...>::Seq;
using Seq = typename TyOLD<TYPES...>::Seq;
using List = typename Seq::List;
};
template<typename...TYPES>
struct RebindTupleTypes<std::tuple<TYPES...>>
{
using Seq = typename Types<TYPES...>::Seq;
using Seq = typename TyOLD<TYPES...>::Seq;
using List = typename Seq::List;
};
@ -356,7 +356,7 @@ namespace meta {
, class TUP
, uint i
>
class BuildTupleAccessor< _X_, Types<>, TUP, i>
class BuildTupleAccessor< _X_, TyOLD<>, TUP, i>
{
public:
using Product = _X_<NullType, TUP, TUP, i>; // Note: i == tuple size
@ -421,7 +421,7 @@ namespace meta {
inline std::string
dump (std::tuple<TYPES...> const& tuple)
{
using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, Types<TYPES...>>;
using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, TyOLD<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<Types<TYPES...>, i>::Type;
using TargetType = typename Pick<TyOLD<TYPES...>, i>::Type;
template<size_t i>

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

@ -113,23 +113,23 @@ namespace meta {
, class T19=NullType
, class T20=NullType
>
class Types
class TyOLD
{
typedef typename Types< T02, T03, T04
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 = Types;
using Seq = TyOLD;
};
template<>
struct Types<>
struct TyOLD<>
{
using List = NullType;
using Seq = Types<>;
using Seq = TyOLD<>;
};
@ -150,7 +150,7 @@ namespace meta {
struct TySeq
{
using Seq = TySeq;
using List = typename Types<TYPES...>::List;
using List = typename TyOLD<TYPES...>::List;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND(End) -- to be obsoleted
}} // namespace lib::meta

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

@ -111,14 +111,14 @@ namespace meta {
, typename T20
, typename IGN
>
struct Prepend<T01, Types< T02,T03,T04,T05
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 Types< T01,T02,T03,T04,T05
typedef TyOLD< T01,T02,T03,T04,T05
, T06,T07,T08,T09,T10
, T11,T12,T13,T14,T15
, T16,T17,T18,T19,T20 > Seq;
@ -133,12 +133,12 @@ namespace meta {
* allowing to re-create a (flat) type sequence from a typelist.
*/
template<class H, class T>
struct Types< Node<H,T> >
struct TyOLD< Node<H,T> >
{
typedef Node<H,T> List;
typedef typename Prepend< H
, typename Types<T>::Seq
, typename TyOLD<T>::Seq
>::Seq Seq;
};
@ -154,7 +154,7 @@ namespace meta {
struct Prepend<T, TySeq<TYPES...>>
{
using Seq = TySeq<T, TYPES...>;
using List = typename Types<T, TYPES...>::List;
using List = typename TyOLD<T, TYPES...>::List;
};
template<class H, class T>
@ -186,15 +186,15 @@ namespace meta {
struct StripNullType;
template<typename T, typename...TYPES>
struct StripNullType<Types<T,TYPES...>>
struct StripNullType<TyOLD<T,TYPES...>>
{
using TailSeq = typename StripNullType<Types<TYPES...>>::Seq;
using TailSeq = typename StripNullType<TyOLD<TYPES...>>::Seq;
using Seq = typename Prepend<T, TailSeq>::Seq;
};
template<typename...TYPES>
struct StripNullType<Types<NullType, TYPES...>>
struct StripNullType<TyOLD<NullType, TYPES...>>
{
using Seq = TySeq<>; // NOTE: this causes the result to be a TySeq
};
@ -274,22 +274,22 @@ namespace meta {
, typename T19
, typename T20
>
struct Split<Types< T01,T02,T03,T04,T05
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
Types< T01,T02,T03,T04,T05
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 Types< T01 > First;
typedef Types< T02,T03,T04,T05
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;
@ -299,9 +299,9 @@ namespace meta {
typedef typename SplitLast<List>::List PrefixList;
typedef typename Tail::List TailList;
typedef typename Types<PrefixList>::Seq Prefix;
typedef typename TyOLD<PrefixList>::Seq Prefix;
typedef typename SplitLast<List>::Type End;
typedef Types<End> Last;
typedef TyOLD<End> Last;
};
@ -334,9 +334,9 @@ namespace meta {
* @see typelist-manip.hpp
*/
template<typename...TYPES, size_t i>
struct Pick<Types<TYPES...>, i>
struct Pick<TyOLD<TYPES...>, i>
{
using Type = typename lib::meta::Shifted<Types<TYPES...>, i>::Head;
using Type = typename lib::meta::Shifted<TyOLD<TYPES...>, i>::Head;
};
template<typename...TYPES, size_t i>
struct Pick<TySeq<TYPES...>, i>

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

@ -141,10 +141,10 @@ namespace meta {
/** build an index number sequence from a type sequence */
template<typename...TYPES>
struct BuildIdxIter<Types<TYPES...>>
struct BuildIdxIter<TyOLD<TYPES...>>
{
///////////////////////TICKET #987 : since Types<T...> is not variadic, need to strip NullType here (instead of just using sizeof...(TYPES)
enum {SIZ = lib::meta::count<typename Types<TYPES...>::List>::value };
enum {SIZ = lib::meta::count<typename TyOLD<TYPES...>::List>::value };
using Builder = BuildIndexSeq<SIZ>;
using Ascending = typename Builder::Ascending;

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

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

6
src/lib/variant.hpp
View file

@ -99,7 +99,7 @@ namespace lib {
using std::remove_reference;
using meta::NullType;
using meta::Types;
using meta::TyOLD;
using meta::Node;
@ -159,8 +159,8 @@ namespace lib {
};
template<class...TYPES, template<class> class _P_>
struct FirstMatchingType<Types<TYPES...>, _P_>
: FirstMatchingType<typename Types<TYPES...>::List, _P_>
struct FirstMatchingType<TyOLD<TYPES...>, _P_>
: FirstMatchingType<typename TyOLD<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::Types; // convenience for the user of "Applicable"
using typelist::TyOLD; // convenience for the user of "Applicable"

2
src/lib/wrapperptr.hpp
View file

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

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::Types;
using lib::meta::TyOLD;
using std::string;
class Tangible;
@ -91,7 +91,7 @@ namespace model {
protected:
using RawResult = lib::Variant<Types<model::Tangible*, Gtk::Widget*>>;
using RawResult = lib::Variant<TyOLD<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
*/
typedef lib::meta::Types < steam::mobject::session::Fork
typedef lib::meta::TyOLD < steam::mobject::session::Fork
, steam::asset::Pipe
, const steam::asset::ProcPatt
, steam::asset::Timeline

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

@ -97,7 +97,7 @@ namespace control {
template< class TAR, class BA, class RET
> //____________________________________
struct AcceptArgs<TAR,BA,RET, Types<> > ///< Accept dummy binding (0 Arguments)
struct AcceptArgs<TAR,BA,RET, TyOLD<> > ///< Accept dummy binding (0 Arguments)
: BA
{
RET
@ -111,7 +111,7 @@ namespace control {
template< class TAR, class BA, class RET
, typename T1
> //_______________________________
struct AcceptArgs<TAR,BA,RET, Types<T1> > ///< Accept binding for 1 Argument
struct AcceptArgs<TAR,BA,RET, TyOLD<T1> > ///< Accept binding for 1 Argument
: BA
{
RET
@ -126,7 +126,7 @@ namespace control {
, typename T1
, typename T2
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2> > ///< Accept binding for 2 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2> > ///< Accept binding for 2 Arguments
: BA
{
RET
@ -142,7 +142,7 @@ namespace control {
, typename T2
, typename T3
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2,T3> > ///< Accept binding for 3 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3> > ///< Accept binding for 3 Arguments
: BA
{
RET
@ -159,7 +159,7 @@ namespace control {
, typename T3
, typename T4
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2,T3,T4> > ///< Accept binding for 4 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4> > ///< Accept binding for 4 Arguments
: BA
{
RET
@ -177,7 +177,7 @@ namespace control {
, typename T4
, typename T5
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2,T3,T4,T5> > ///< Accept binding for 5 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5> > ///< Accept binding for 5 Arguments
: BA
{
RET
@ -196,7 +196,7 @@ namespace control {
, typename T5
, typename T6
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6> > ///< Accept binding for 6 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6> > ///< Accept binding for 6 Arguments
: BA
{
RET
@ -216,7 +216,7 @@ namespace control {
, typename T6
, typename T7
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6,T7> > ///< Accept binding for 7 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7> > ///< Accept binding for 7 Arguments
: BA
{
RET
@ -237,7 +237,7 @@ namespace control {
, typename T7
, typename T8
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6,T7,T8> > ///< Accept binding for 8 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8> > ///< Accept binding for 8 Arguments
: BA
{
RET
@ -259,7 +259,7 @@ namespace control {
, typename T8
, typename T9
> //________________________________
struct AcceptArgs<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6,T7,T8,T9> > ///< Accept binding for 9 Arguments
struct AcceptArgs<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8,T9> > ///< Accept binding for 9 Arguments
: BA
{
RET
@ -302,7 +302,7 @@ namespace control {
template< class TAR, class BA, class RET
> //____________________________________
struct AcceptBind<TAR,BA,RET, Types<> > ///< Accept dummy binding (0 Arguments)
struct AcceptBind<TAR,BA,RET, TyOLD<> > ///< Accept dummy binding (0 Arguments)
: BA
{
RET
@ -316,7 +316,7 @@ namespace control {
template< class TAR, class BA, class RET
, typename T1
> //_______________________________
struct AcceptBind<TAR,BA,RET, Types<T1> > ///< Accept binding for 1 Argument
struct AcceptBind<TAR,BA,RET, TyOLD<T1> > ///< Accept binding for 1 Argument
: BA
{
RET
@ -331,7 +331,7 @@ namespace control {
, typename T1
, typename T2
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2> > ///< Accept binding for 2 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2> > ///< Accept binding for 2 Arguments
: BA
{
RET
@ -347,7 +347,7 @@ namespace control {
, typename T2
, typename T3
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2,T3> > ///< Accept binding for 3 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3> > ///< Accept binding for 3 Arguments
: BA
{
RET
@ -364,7 +364,7 @@ namespace control {
, typename T3
, typename T4
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2,T3,T4> > ///< Accept binding for 4 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4> > ///< Accept binding for 4 Arguments
: BA
{
RET
@ -382,7 +382,7 @@ namespace control {
, typename T4
, typename T5
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2,T3,T4,T5> > ///< Accept binding for 5 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5> > ///< Accept binding for 5 Arguments
: BA
{
RET
@ -401,7 +401,7 @@ namespace control {
, typename T5
, typename T6
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6> > ///< Accept binding for 6 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6> > ///< Accept binding for 6 Arguments
: BA
{
RET
@ -421,7 +421,7 @@ namespace control {
, typename T6
, typename T7
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6,T7> > ///< Accept binding for 7 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7> > ///< Accept binding for 7 Arguments
: BA
{
RET
@ -442,7 +442,7 @@ namespace control {
, typename T7
, typename T8
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6,T7,T8> > ///< Accept binding for 8 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8> > ///< Accept binding for 8 Arguments
: BA
{
RET
@ -464,7 +464,7 @@ namespace control {
, typename T8
, typename T9
> //________________________________
struct AcceptBind<TAR,BA,RET, Types<T1,T2,T3,T4,T5,T6,T7,T8,T9> > ///< Accept binding for 9 Arguments
struct AcceptBind<TAR,BA,RET, TyOLD<T1,T2,T3,T4,T5,T6,T7,T8,T9> > ///< Accept binding for 9 Arguments
: BA
{
RET
@ -524,7 +524,7 @@ namespace control {
template<typename...TYPES>
struct _Type<std::tuple<TYPES...> >
{
using Args = typename Types<TYPES...>::Seq;
using Args = typename TyOLD<TYPES...>::Seq;
using Ret = void;
using Sig = typename BuildFunType<void, Args>::Sig;
using ArgTuple = std::tuple<TYPES...>;

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

@ -78,7 +78,7 @@ namespace control {
using lib::meta::_Fun;
using lib::meta::NullType;
using lib::meta::Types;
using lib::meta::TyOLD;
using lib::meta::Tuple;

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::Types;
using lib::meta::TyOLD;
using lib::meta::Append;
using lib::meta::SplitLast;
@ -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 Types<ExtendedArglist>::Seq;
using ExtendedArgs = typename TyOLD<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 Types<ExtendedArglist>::Seq;
using ExtendedArgs = typename TyOLD<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 SplitLast<Args>::Type;
using OperationArglist = typename SplitLast<Args>::List;
using OperationArgs = typename Types<OperationArglist>::Seq;
using OperationArgs = typename TyOLD<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::Types;
using lib::meta::TyOLD;
using FuncPtr = void*;

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

@ -58,7 +58,7 @@ namespace steam {
namespace mobject {
namespace builder {
typedef Types< session::Root,
typedef TyOLD< 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::Types; // convenience for the users of "Applicable"
using lib::meta::TyOLD; // 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::Types< PID, lumiera_uid, uint>::List>::value
mp::TyOLD< PID, lumiera_uid, uint>::List>::value
};
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
*/
typedef SessionServices< Types< SessionServiceFetch
typedef SessionServices< TyOLD< 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::Types;
using lib::meta::TyOLD;
/**

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< Types<Smpte> >();
Supported just_simple = Supported::formats< Types<Frames,Seconds> >();
Supported just_smpte = Supported::formats< TyOLD<Smpte> >();
Supported just_simple = Supported::formats< TyOLD<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::Types;
using lib::meta::TyOLD;
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)
{
typedef Types<Duration,TimeSpan,QuTime> KindsOfTarget; // time entities to receive value changes
typedef Types<TimeValue,Time,Duration,TimeSpan,QuTime> KindsOfSource; // time entities to be used as change values
typedef TyOLD<Duration,TimeSpan,QuTime> KindsOfTarget; // time entities to receive value changes
typedef TyOLD<TimeValue,Time,Duration,TimeSpan,QuTime> KindsOfSource; // time entities to be used as change values
typedef InstantiateChainedCombinations< KindsOfTarget
, KindsOfSource
, TestCase // template to be instantiated for each type

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

@ -65,7 +65,7 @@ namespace test2 {
class Babbler
: public Applicable< Babbler,
Types<Boss,BigBoss>::List, // treat this types
TyOLD<Boss,BigBoss>::List, // treat this types
VerboseVisitor<Tool> // intermediary base class
>
{
@ -114,7 +114,7 @@ namespace test2 {
*/
class Blatherer
: public Applicable< Blatherer,
Types<Visionary>::List, // get calls to Visionary dispatched
TyOLD<Visionary>::List, // get calls to Visionary dispatched
VerboseVisitor<Hastalavista> // note: different tool base class
>
{

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

@ -74,7 +74,7 @@ namespace test1 {
class Babbler
: public Applicable< Babbler
, Types<Boss,BigBoss,Visionary>::List // dispatch calls to this types
, TyOLD<Boss,BigBoss,Visionary>::List // dispatch calls to this types
, VerboseVisitor
>
{

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

@ -111,7 +111,7 @@ namespace test {
void
bindRandArgument (CommandImpl& cmd)
{
typedef Types<int> ArgType;
typedef TyOLD<int> ArgType;
TypedArguments<Tuple<ArgType>> arg (std::make_tuple (rani (10000)));
cmd.setArguments (arg);
CHECK (cmd.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<Types<char>>;
using ArgTuple = Tuple<TyOLD<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<Types<int>> param = std::make_tuple (23);
Tuple<TyOLD<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<Types<> > param;
Tuple<TyOLD<> > param;
SimpleClosure<void()> clo{param};
CHECK (!mementoHolder);

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

@ -210,7 +210,7 @@ namespace test {
CHECK (!isSameObject (*pImpl, *clone));
CHECK (!pImpl->canExec());
typedef Types<int> ArgType;
typedef TyOLD<int> ArgType;
TypedArguments<Tuple<ArgType>> arg{Tuple<ArgType>(98765)};
pImpl->setArguments(arg);
CHECK (pImpl->canExec());

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

@ -168,7 +168,7 @@ namespace test {
CHECK (com);
CHECK (!com->canExec());
typedef Types<int> ArgType;
typedef TyOLD<int> ArgType;
const int ARGR{1 + rani (1000)};
Tuple<ArgType> tuple(ARGR);
TypedArguments<Tuple<ArgType>> arg(tuple);

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, Types<Clip, DummyMO>::List>
: public Applicable<TestTool, TyOLD<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::Types;
using lib::meta::TyOLD;
using lib::meta::InstantiateChained;
@ -161,7 +161,7 @@ namespace test {
struct TSessManagerImpl;
typedef TSessionServices< Types<InternalAPI_1,InternalAPI_2>
typedef TSessionServices< TyOLD<InternalAPI_1,InternalAPI_2>
, TSessManagerImpl
, TSessionImpl
> SessionImplAPI;

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

@ -52,11 +52,11 @@ namespace test {
typedef Types< Num<1>
typedef TyOLD< Num<1>
, Num<2>
, Num<3>
>::List List1;
typedef Types< Num<5>
typedef TyOLD< Num<5>
, Num<6>
, Num<7>
>::List List2;
@ -153,10 +153,10 @@ namespace test {
{
cout << "\t:\n\t: ---Apply---\n";
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
Tuple<TyOLD<>> tup0 ;
Tuple<TyOLD<int>> tup1 (11);
Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
DUMPVAL (tup0);
DUMPVAL (tup1);
DUMPVAL (tup2);
@ -183,10 +183,10 @@ namespace test {
void
check_applyFunc ()
{
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
Tuple<TyOLD<>> tup0 ;
Tuple<TyOLD<int>> tup1 (11);
Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
function<int()> functor0 (fun0);
function<int(int)> functor1 (fun1);
function<int(int,int)> functor2 (fun2);
@ -215,10 +215,10 @@ namespace test {
{
cout << "\t:\n\t: ---Bind----\n";
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
Tuple<TyOLD<>> tup0 ;
Tuple<TyOLD<int>> tup1 (11);
Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
typedef function<int()> BoundFun;
@ -248,10 +248,10 @@ namespace test {
void
check_bindFunc ()
{
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
Tuple<TyOLD<>> tup0 ;
Tuple<TyOLD<int>> tup1 (11);
Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<TyOLD<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);
@ -285,10 +285,10 @@ namespace test {
void
build_closure ()
{
Tuple<Types<>> tup0 ;
Tuple<Types<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13);
Tuple<TyOLD<>> tup0 ;
Tuple<TyOLD<int>> tup1 (11);
Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
FunctionClosure<int()> clo0 (fun0,tup0);
FunctionClosure<int(int)> clo1 (fun1,tup1);
@ -327,7 +327,7 @@ namespace test {
// finally combine all techniques....
using NumberzArg = Types<List2>::Seq;
using NumberzArg = TyOLD<List2>::Seq;
using NumberzSig = BuildFunType<int,NumberzArg>::Sig;
Tuple<NumberzArg> numberzTup (Num<5>(22), Num<6>(33), Num<7>(44));

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

@ -200,7 +200,7 @@ namespace test {
// Version2: extract the binding arguments from a tuple--- //
using PartialArg = Tuple<Types<Num<1>, PH1, PH2>>; // Tuple type to hold the binding values. Note the placeholder types
using PartialArg = Tuple<TyOLD<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
@ -216,7 +216,7 @@ namespace test {
// Version3: let the PApply-template do the work for us--- //
typedef Types<Num<1>> ArgTypes; // now package just the argument(s) to be applied into a tuple
typedef TyOLD<Num<1>> ArgTypes; // 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);
@ -279,7 +279,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
typedef Types<Num<3>,Num<2>,Num<1>> Args2Close; // Tuple type to hold the 3 argument values used for the closure
typedef TyOLD<Num<3>,Num<2>,Num<1>> Args2Close; // 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 Types< Num<1>
typedef TyOLD< Num<1>
, Num<3>
, Num<5>
> Types1;
typedef Types< Num<2>
typedef TyOLD< 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
};
typedef Types< Block<1>
typedef TyOLD< Block<1>
, Block<2>
, Block<3>
, Block<5>

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

@ -203,13 +203,13 @@ namespace test {
//-------------------------------------------------TEST-types--
typedef Types< int
typedef TyOLD< int
, uint
, int64_t
, uint64_t
>::List TheList;
typedef Types< >::List EmptyList;
typedef TyOLD< >::List EmptyList;
//-------------------------------------------------TEST-types--

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

@ -43,14 +43,14 @@ namespace test {
namespace { // test data
typedef Types< Num<1>
typedef TyOLD< Num<1>
, Num<3>
, Num<5>
> Types1;
typedef Types< Num<2>
typedef TyOLD< Num<2>
, Num<4>
> Types2;
typedef Types< Num<7>> Types3;
typedef TyOLD< Num<7>> Types3;
@ -125,7 +125,7 @@ namespace test {
Prepend prep (22, 11,33,Num<5>());
DUMPVAL (prep);
typedef Tuple<Types<> > NulT; // plain-flat empty Tuple
typedef Tuple<TyOLD<> > NulT; // plain-flat empty Tuple
typedef Tuple<NullType> NulL; // 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::Types;
using lib::meta::TyOLD;
using lib::meta::Tuple;
using lib::meta::buildTuple;
using lib::time::Duration;
@ -82,8 +82,8 @@ namespace test {
void
show_simpleUsage()
{
using NiceTypes = Types<string, int>;
using UgglyTypes = Types<EntryID<long>, Symbol, int, int64_t, double, Duration>; // various conversions and an immutable type (Duration)
using NiceTypes = TyOLD<string, int>;
using UgglyTypes = TyOLD<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));
@ -101,19 +101,19 @@ namespace test {
{
Rec args = MakeRec().scope("surprise", 42);
using TooMany = Types<string, int, long>;
using TooMany = TyOLD<string, int, long>;
VERIFY_ERROR (WRONG_TYPE, buildTuple<TooMany> (args)); // number of types in tuple exceeds capacity of the supplied argument record
using Unsigned = Types<string, uint>;
using Floating = Types<string, float>;
using Narrowing = Types<string, short>;
using Unsigned = TyOLD<string, uint>;
using Floating = TyOLD<string, float>;
using Narrowing = TyOLD<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 = Types<string>;
using TupStr = TyOLD<string>;
Tuple<TupStr> tup = buildTuple<TupStr> (timeArg);
CHECK (std::get<string> (tup) == "4:03:02.001");
@ -126,7 +126,7 @@ namespace test {
VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args));
VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args));
using ToSizeT = Types<string, size_t>;
using ToSizeT = TyOLD<string, size_t>;
VERIFY_ERROR (WRONG_TYPE, (buildTuple<ToSizeT> (args))); // not even conversion to size_t is allowed
struct Dummy
@ -138,7 +138,7 @@ namespace test {
{ }
};
using WithDummy = Types<string, Dummy>;
using WithDummy = TyOLD<string, Dummy>;
Tuple<WithDummy> tup2 = buildTuple<WithDummy> (hashArg); // while any type explicitly constructible from LUID are permitted.
VERIFY_ERROR (WRONG_TYPE, buildTuple<WithDummy> (args)); // building a Dummy from int(42) is disallowed, of course

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

@ -52,11 +52,11 @@ namespace test {
typedef Types< Num<1>
typedef TyOLD< Num<1>
, Num<2>
, Num<3>
>::List List1;
typedef Types< Num<5>
typedef TyOLD< Num<5>
, Num<6>
, Num<7>
>::List List2;
@ -173,7 +173,7 @@ namespace test {
void
check_splice ()
{
typedef Types<Num<9>,Num<8>>::List OLi;
typedef TyOLD<Num<9>,Num<8>>::List OLi;
// will "paste" the list OLi "on top" of another Typelist...
typedef Splice<NullType, NullType> Overl01;
@ -216,7 +216,7 @@ namespace test {
DISPLAY (Overl13);
typedef Types<Num<99>>::List OLi2;
typedef TyOLD<Num<99>>::List OLi2;
typedef Splice<List1, OLi2, 0>::Front Front1;
typedef Splice<List1, OLi2, 1>::Front Front2;
typedef Splice<List1, OLi2, 5>::Front Front3;
@ -244,7 +244,7 @@ namespace test {
typedef SplitLast<List1>::Type Elm;
typedef SplitLast<List1>::List Prefix;
typedef Types<Elm>::List ElmL;
typedef TyOLD<Elm>::List ElmL;
DISPLAY (Prefix);
DISPLAY (ElmL);
@ -253,13 +253,13 @@ namespace test {
typedef SplitLast<ElmL>::List NPrefix;
DISPLAY (NPrefix);
DISPLAY (Types<Elm1>);
DISPLAY (TyOLD<Elm1>);
typedef SplitLast<NullType>::Type Nil;
typedef SplitLast<NullType>::List NList;
DISPLAY (NList);
DISPLAY (Types<Nil>);
DISPLAY (TyOLD<Nil>);
}
@ -278,7 +278,7 @@ namespace test {
typedef Dissect<LL>::Head Head;
typedef Dissect<LL>::End End;
typedef Types<Head,End> HeadEnd; DISPLAY(HeadEnd);
typedef TyOLD<Head,End> HeadEnd; DISPLAY(HeadEnd);
}
@ -318,7 +318,7 @@ namespace test {
typedef PrefixAll<NullType,List1> Prefix3;
DISPLAY (Prefix3);
typedef Types<List1::List,Num<0>,List2::List>::List List_of_Lists;
typedef TyOLD<List1::List,Num<0>,List2::List>::List List_of_Lists;
typedef PrefixAll<Num<111>,List_of_Lists> Prefix4;
DISPLAY (Prefix4);
@ -336,14 +336,14 @@ namespace test {
typedef Distribute<Num<11>, List1> Dist1;
DISPLAY (Dist1);
typedef Types<Num<11>,Num<22>,Num<33>>::List Prefixes;
typedef TyOLD<Num<11>,Num<22>,Num<33>>::List Prefixes;
typedef Distribute<Prefixes, Num<0>> Dist2;
DISPLAY (Dist2);
typedef Distribute<Prefixes, List1> Dist3;
DISPLAY (Dist3);
typedef Distribute<Prefixes, Types<List1::List,List2::List>::List> Dist4;
typedef Distribute<Prefixes, TyOLD<List1::List,List2::List>::List> Dist4;
DISPLAY (Dist4);
}

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

@ -40,7 +40,7 @@ namespace test {
};
typedef Types< Block<1>
typedef TyOLD< Block<1>
, Block<2>
, Block<3>
, Block<5>

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

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

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

@ -44,11 +44,11 @@ namespace test {
namespace { // test data
typedef Types< Num<1>
typedef TyOLD< Num<1>
, Num<2>
, Num<3>
> Types1;
typedef Types< Num<7>
typedef TyOLD< Num<7>
, Num<8>
, Num<9>
> Types2;
@ -99,12 +99,12 @@ namespace test {
typedef Append<Types1::List, Types2::List>::List LL;
DISPLAY (LL);
typedef Types<LL>::Seq Seq;
typedef TyOLD<LL>::Seq Seq;
typedef Seq::List SeqList;
DISPLAY (Seq);
DISPLAY (SeqList);
typedef Types<NodeNull>::Seq NulS;
typedef TyOLD<NodeNull>::Seq NulS;
DISPLAY (NulS);
}
@ -118,10 +118,10 @@ namespace test {
typedef Prepend<NullType, Types1> Prepend2;
DISPLAY(Prepend2);
typedef Prepend<Num<5>, Types<> > Prepend3;
typedef Prepend<Num<5>, TyOLD<> > Prepend3;
DISPLAY(Prepend3);
typedef Prepend<NullType, Types<> > Prepend4;
typedef Prepend<NullType, TyOLD<> > Prepend4;
DISPLAY(Prepend4);
}
@ -130,7 +130,7 @@ namespace test {
check_shift ()
{
typedef Append<Types2::List, Types1::List>::List LL;
typedef Types<LL>::Seq Seq;
typedef TyOLD<LL>::Seq Seq;
typedef Shifted<Seq,0>::Type Seq_0; DISPLAY (Seq_0);
typedef Shifted<Seq,1>::Type Seq_1; DISPLAY (Seq_1);
@ -140,13 +140,13 @@ namespace test {
typedef Shifted<Seq,5>::Type Seq_5; DISPLAY (Seq_5);
typedef Shifted<Seq,6>::Type Seq_6; DISPLAY (Seq_6);
typedef Types<Shifted<Seq,0>::Head> Head_0; DISPLAY (Head_0);
typedef Types<Shifted<Seq,1>::Head> Head_1; DISPLAY (Head_1);
typedef Types<Shifted<Seq,2>::Head> Head_2; DISPLAY (Head_2);
typedef Types<Shifted<Seq,3>::Head> Head_3; DISPLAY (Head_3);
typedef Types<Shifted<Seq,4>::Head> Head_4; DISPLAY (Head_4);
typedef Types<Shifted<Seq,5>::Head> Head_5; DISPLAY (Head_5);
typedef Types<Shifted<Seq,6>::Head> Head_6; DISPLAY (Head_6);
typedef TyOLD<Shifted<Seq,0>::Head> Head_0; DISPLAY (Head_0);
typedef TyOLD<Shifted<Seq,1>::Head> Head_1; DISPLAY (Head_1);
typedef TyOLD<Shifted<Seq,2>::Head> Head_2; DISPLAY (Head_2);
typedef TyOLD<Shifted<Seq,3>::Head> Head_3; DISPLAY (Head_3);
typedef TyOLD<Shifted<Seq,4>::Head> Head_4; DISPLAY (Head_4);
typedef TyOLD<Shifted<Seq,5>::Head> Head_5; DISPLAY (Head_5);
typedef TyOLD<Shifted<Seq,6>::Head> Head_6; DISPLAY (Head_6);
}
@ -154,7 +154,7 @@ namespace test {
check_split ()
{
typedef Append<Types1::List, Types2::List>::List LL;
typedef Types<LL>::Seq Seq;
typedef TyOLD<LL>::Seq Seq;
DISPLAY (Seq);
typedef Split<Seq>::List List; DISPLAY(List);
@ -166,7 +166,7 @@ namespace test {
typedef Split<Seq>::Head Head;
typedef Split<Seq>::End End;
typedef Types<Head,End> HeadEnd; DISPLAY(HeadEnd);
typedef TyOLD<Head,End> HeadEnd; DISPLAY(HeadEnd);
}

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

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

45
wiki/thinkPad.ichthyo.mm
View file

@ -58642,6 +58642,10 @@
<node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1739743240214" ID="ID_1756740911" MODIFIED="1739743248263" TEXT="geplant: Namen austauschen">
<icon BUILTIN="hourglass"/>
</node>
<node CREATED="1748826315559" ID="ID_575940847" MODIFIED="1748826459126" TEXT="gehe das Thema jetzt vor C++20 an">
<arrowlink COLOR="#4c5dd7" DESTINATION="ID_358783348" ENDARROW="Default" ENDINCLINATION="-1131;-56;" ID="Arrow_ID_470275962" STARTARROW="None" STARTINCLINATION="-4286;314;"/>
<icon BUILTIN="yes"/>
</node>
</node>
</node>
<node CREATED="1540682674455" ID="ID_1625152878" MODIFIED="1557498707236" TEXT="Typliste filtern">
@ -164188,6 +164192,47 @@ 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">
<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 ">
<icon BUILTIN="info"/>
</node>
<node CREATED="1748826541021" ID="ID_1606562967" MODIFIED="1748826643902" TEXT="Ziel: vor der Umstellung auf C++20 sollen solche Altlasten weitgehend aufger&#xe4;umt sein">
<richcontent TYPE="NOTE"><html>
<head/>
<body>
<p>
Zwar wird daran die Compilation mit C++20 nicht scheitern, aber danach d&#252;rfte doch ein gewisser Aufbruch stattfinden &#8212; und solche problematischen Reste der Zeit vor C++11 geraten dann zunehmend zum Hindernis.
</p>
</body>
</html></richcontent>
</node>
<node CREATED="1748826645643" ID="ID_298681004" MODIFIED="1748826712364" TEXT="Habe bereits vor einiger Zeit die Grundlagen gelegt f&#xfc;r einen schrittweisen &#xdc;bergang">
<richcontent TYPE="NOTE"><html>
<head/>
<body>
<p>
...indem ich den bisherigen &#187;Workaround&#171; in den wichtigsten Definitionen unmittelbar daneben gestellt habe; teilweise k&#246;nnen beide F&#228;lle bereits koexistieren
</p>
</body>
</html></richcontent>
</node>
<node CREATED="1748826715182" ID="ID_480113665" MODIFIED="1748826910245">
<richcontent TYPE="NODE"><html>
<head/>
<body>
<p>
Vorbereitung: alten Typ umbenennen: <font color="#3d2bb6" face="Monospaced"><b>Types</b>&lt;TY...&gt; </font>in<font color="#3d2bb6" face="Monospaced">&#160;</font><font color="#942bb6" face="Monospaced"><b>TyOLD</b>&lt;TY...&gt;</font>
</p>
</body>
</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>
</node>
</node>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1742175299968" ID="ID_1393531242" MODIFIED="1742175305316" TEXT="C++20">
<icon BUILTIN="flag-pink"/>