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 Rec = Record<GenNode>;
using RecRef = RecordRef<GenNode>; using RecRef = RecordRef<GenNode>;
using MakeRec = Rec::Mutator; using MakeRec = Rec::Mutator;
using DataValues = meta::Types<int using DataValues = meta::TyOLD<int
,int64_t ,int64_t
,short ,short
,char ,char

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

@ -575,7 +575,7 @@ namespace func{
using Ret = typename _Fun<SIG>::Ret; using Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::List; using ArgsList = typename Args::List;
using ValList = typename VAL::List; using ValList = typename VAL::List;
using ValTypes = typename Types<ValList>::Seq; using ValTypes = typename TyOLD<ValList>::Seq;
enum { ARG_CNT = count<ArgsList>::value enum { ARG_CNT = count<ArgsList>::value
, VAL_CNT = count<ValList> ::value , VAL_CNT = count<ValList> ::value
@ -587,8 +587,8 @@ namespace func{
using LeftReduced = typename Splice<ArgsList, ValList>::Back; using LeftReduced = typename Splice<ArgsList, ValList>::Back;
using RightReduced = typename Splice<ArgsList, ValList, ROFFSET>::Front; using RightReduced = typename Splice<ArgsList, ValList, ROFFSET>::Front;
using ArgsL = typename Types<LeftReduced>::Seq; using ArgsL = typename TyOLD<LeftReduced>::Seq;
using ArgsR = typename Types<RightReduced>::Seq; using ArgsR = typename TyOLD<RightReduced>::Seq;
// build a list, where each of the *remaining* arguments is replaced by a placeholder marker // build a list, where each of the *remaining* arguments is replaced by a placeholder marker
@ -600,8 +600,8 @@ namespace func{
using LeftReplaced = typename Splice<ArgsList, TrailingPlaceholders, VAL_CNT>::List; using LeftReplaced = typename Splice<ArgsList, TrailingPlaceholders, VAL_CNT>::List;
using RightReplaced = typename Splice<ArgsList, LeadingPlaceholders, 0 >::List; using RightReplaced = typename Splice<ArgsList, LeadingPlaceholders, 0 >::List;
using LeftReplacedTypes = typename Types<LeftReplaced>::Seq; using LeftReplacedTypes = typename TyOLD<LeftReplaced>::Seq;
using RightReplacedTypes = typename Types<RightReplaced>::Seq; using RightReplacedTypes = typename TyOLD<RightReplaced>::Seq;
// create a "builder" helper, which accepts exactly the value tuple elements // create a "builder" helper, which accepts exactly the value tuple elements
// and puts them at the right location, while default-constructing the remaining // and puts them at the right location, while default-constructing the remaining
@ -679,7 +679,7 @@ namespace func{
using Args = typename _Fun<SIG>::Args; using Args = typename _Fun<SIG>::Args;
using Ret = typename _Fun<SIG>::Ret; using Ret = typename _Fun<SIG>::Ret;
using ArgsList = typename Args::List; using ArgsList = typename Args::List;
using ValList = typename Types<X>::List; using ValList = typename TyOLD<X>::List;
enum { ARG_CNT = count<ArgsList>::value }; enum { ARG_CNT = count<ArgsList>::value };
@ -694,8 +694,8 @@ namespace func{
>::List; >::List;
using ReducedArgs = typename Append<RemainingFront, RemainingBack>::List; using ReducedArgs = typename Append<RemainingFront, RemainingBack>::List;
using PreparedArgTypes = typename Types<PreparedArgs>::Seq; using PreparedArgTypes = typename TyOLD<PreparedArgs>::Seq;
using RemainingArgs = typename Types<ReducedArgs>::Seq; using RemainingArgs = typename TyOLD<ReducedArgs>::Seq;
using ReducedSig = typename BuildFunType<Ret,RemainingArgs>::Sig; using ReducedSig = typename BuildFunType<Ret,RemainingArgs>::Sig;
@ -844,10 +844,10 @@ namespace func{
*/ */
template<typename...ARG> template<typename...ARG>
inline inline
typename _Sig<void, Types<ARG...>>::Applicator typename _Sig<void, TyOLD<ARG...>>::Applicator
tupleApplicator (std::tuple<ARG...>& args) 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); return TupleApplicator<Signature> (args);
} }
@ -860,7 +860,7 @@ namespace func{
apply (SIG& f, std::tuple<ARG...>& args) apply (SIG& f, std::tuple<ARG...>& args)
{ {
typedef typename _Fun<SIG>::Ret Ret; // 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 return TupleApplicator<Signature> (args) (f); // in order to get better error messages here
} }
@ -871,10 +871,10 @@ namespace func{
* function result. */ * function result. */
template<typename SIG, typename...ARG> template<typename SIG, typename...ARG>
inline inline
typename _Clo<SIG,Types<ARG...>>::Type typename _Clo<SIG,TyOLD<ARG...>>::Type
closure (SIG& f, std::tuple<ARG...>& args) 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); 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 ///////////////////////////////////////////////////////////////////////////////////TICKET #987 : the following specialisations become obsolete with the old-style type-sequence
template< typename RET> template< typename RET>
struct BuildFunType<RET, Types<> > struct BuildFunType<RET, TyOLD<> >
{ {
using Sig = RET(void); using Sig = RET(void);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -367,7 +367,7 @@ namespace meta{
template< typename RET template< typename RET
, typename A1 , typename A1
> >
struct BuildFunType<RET, Types<A1>> struct BuildFunType<RET, TyOLD<A1>>
{ {
using Sig = RET(A1); using Sig = RET(A1);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -380,7 +380,7 @@ namespace meta{
, typename A1 , typename A1
, typename A2 , typename A2
> >
struct BuildFunType<RET, Types<A1,A2>> struct BuildFunType<RET, TyOLD<A1,A2>>
{ {
using Sig = RET(A1,A2); using Sig = RET(A1,A2);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -394,7 +394,7 @@ namespace meta{
, typename A2 , typename A2
, typename A3 , typename A3
> >
struct BuildFunType<RET, Types<A1,A2,A3>> struct BuildFunType<RET, TyOLD<A1,A2,A3>>
{ {
using Sig = RET(A1,A2,A3); using Sig = RET(A1,A2,A3);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -409,7 +409,7 @@ namespace meta{
, typename A3 , typename A3
, typename A4 , 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 Sig = RET(A1,A2,A3,A4);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -425,7 +425,7 @@ namespace meta{
, typename A4 , typename A4
, typename A5 , 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 Sig = RET(A1,A2,A3,A4,A5);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -442,7 +442,7 @@ namespace meta{
, typename A5 , typename A5
, typename A6 , 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 Sig = RET(A1,A2,A3,A4,A5,A6);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -460,7 +460,7 @@ namespace meta{
, typename A6 , typename A6
, typename A7 , 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 Sig = RET(A1,A2,A3,A4,A5,A6,A7);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -479,7 +479,7 @@ namespace meta{
, typename A7 , typename A7
, typename A8 , 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 Sig = RET(A1,A2,A3,A4,A5,A6,A7,A8);
using Fun = _Fun<Sig>; using Fun = _Fun<Sig>;
@ -499,7 +499,7 @@ namespace meta{
, typename A8 , typename A8
, typename A9 , 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 Sig = RET(A1,A2,A3,A4,A5,A6,A7,A8,A9);
using Fun = _Fun<Sig>; 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. * prior to rebinding to the `std::tuple` type.
*/ */
template<typename...TYPES> 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; using Type = typename BuildTupleType<VariadicSeq>::Type;
}; };
@ -162,14 +162,14 @@ namespace meta {
template<class H, typename TAIL> template<class H, typename TAIL>
struct BuildTupleType<Node<H, 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; using Type = typename BuildTupleType<Seq>::Type;
}; };
template<> template<>
struct BuildTupleType<NullType> struct BuildTupleType<NullType>
{ {
using Type = typename BuildTupleType<Types<>>::Type; using Type = typename BuildTupleType<TyOLD<>>::Type;
}; };
} }
@ -195,13 +195,13 @@ namespace meta {
template<typename...TYPES> template<typename...TYPES>
struct RebindTupleTypes struct RebindTupleTypes
{ {
using Seq = typename Types<TYPES...>::Seq; using Seq = typename TyOLD<TYPES...>::Seq;
using List = typename Seq::List; using List = typename Seq::List;
}; };
template<typename...TYPES> template<typename...TYPES>
struct RebindTupleTypes<std::tuple<TYPES...>> struct RebindTupleTypes<std::tuple<TYPES...>>
{ {
using Seq = typename Types<TYPES...>::Seq; using Seq = typename TyOLD<TYPES...>::Seq;
using List = typename Seq::List; using List = typename Seq::List;
}; };
@ -356,7 +356,7 @@ namespace meta {
, class TUP , class TUP
, uint i , uint i
> >
class BuildTupleAccessor< _X_, Types<>, TUP, i> class BuildTupleAccessor< _X_, TyOLD<>, TUP, i>
{ {
public: public:
using Product = _X_<NullType, TUP, TUP, i>; // Note: i == tuple size using Product = _X_<NullType, TUP, TUP, i>; // Note: i == tuple size
@ -421,7 +421,7 @@ namespace meta {
inline std::string inline std::string
dump (std::tuple<TYPES...> const& tuple) dump (std::tuple<TYPES...> const& tuple)
{ {
using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, Types<TYPES...>>; using BuildAccessor = BuildTupleAccessor<TupleElementDisplayer, TyOLD<TYPES...>>;
using Displayer = typename BuildAccessor::Product ; using Displayer = typename BuildAccessor::Product ;
return static_cast<Displayer const&> (tuple) return static_cast<Displayer const&> (tuple)

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

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

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

@ -113,23 +113,23 @@ namespace meta {
, class T19=NullType , class T19=NullType
, class T20=NullType , class T20=NullType
> >
class Types class TyOLD
{ {
typedef typename Types< T02, T03, T04 typedef typename TyOLD< T02, T03, T04
, T05, T06, T07, T08 , T05, T06, T07, T08
, T09, T10, T11, T12 , T09, T10, T11, T12
, T13, T14, T15, T16 , T13, T14, T15, T16
, T17, T18, T19, T20>::List ListTail; , T17, T18, T19, T20>::List ListTail;
public: public:
using List = Node<T01, ListTail>; using List = Node<T01, ListTail>;
using Seq = Types; using Seq = TyOLD;
}; };
template<> template<>
struct Types<> struct TyOLD<>
{ {
using List = NullType; using List = NullType;
using Seq = Types<>; using Seq = TyOLD<>;
}; };
@ -150,7 +150,7 @@ namespace meta {
struct TySeq struct TySeq
{ {
using Seq = TySeq; using Seq = TySeq;
using List = typename Types<TYPES...>::List; using List = typename TyOLD<TYPES...>::List;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND(End) -- to be obsoleted //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #987 temporary WORKAROUND(End) -- to be obsoleted
}} // namespace lib::meta }} // namespace lib::meta

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

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

2
src/lib/visitor.hpp
View file

@ -171,7 +171,7 @@ namespace visitor {
} }
}; };
using typelist::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; } namespace mobject { class MObject; }
typedef lib::meta::Types < mobject::Placement<mobject::MObject>* typedef lib::meta::TyOLD < mobject::Placement<mobject::MObject>*
, lib::P<asset::Asset>* , lib::P<asset::Asset>*
> ::List > ::List
WrapperTypes; WrapperTypes;

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

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

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

@ -61,7 +61,7 @@ namespace steam {
* the list of all concrete types participating in the * the list of all concrete types participating in the
* rule based config query system * rule based config query system
*/ */
typedef lib::meta::Types < steam::mobject::session::Fork typedef lib::meta::TyOLD < steam::mobject::session::Fork
, steam::asset::Pipe , steam::asset::Pipe
, const steam::asset::ProcPatt , const steam::asset::ProcPatt
, steam::asset::Timeline , 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 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 : BA
{ {
RET RET
@ -111,7 +111,7 @@ namespace control {
template< class TAR, class BA, class RET template< class TAR, class BA, class RET
, typename T1 , 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 : BA
{ {
RET RET
@ -126,7 +126,7 @@ namespace control {
, typename T1 , typename T1
, typename T2 , 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 : BA
{ {
RET RET
@ -142,7 +142,7 @@ namespace control {
, typename T2 , typename T2
, typename T3 , 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 : BA
{ {
RET RET
@ -159,7 +159,7 @@ namespace control {
, typename T3 , typename T3
, typename T4 , 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 : BA
{ {
RET RET
@ -177,7 +177,7 @@ namespace control {
, typename T4 , typename T4
, typename T5 , 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 : BA
{ {
RET RET
@ -196,7 +196,7 @@ namespace control {
, typename T5 , typename T5
, typename T6 , 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 : BA
{ {
RET RET
@ -216,7 +216,7 @@ namespace control {
, typename T6 , typename T6
, typename T7 , 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 : BA
{ {
RET RET
@ -237,7 +237,7 @@ namespace control {
, typename T7 , typename T7
, typename T8 , 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 : BA
{ {
RET RET
@ -259,7 +259,7 @@ namespace control {
, typename T8 , typename T8
, typename T9 , 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 : BA
{ {
RET RET
@ -302,7 +302,7 @@ namespace control {
template< class TAR, class BA, class RET 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 : BA
{ {
RET RET
@ -316,7 +316,7 @@ namespace control {
template< class TAR, class BA, class RET template< class TAR, class BA, class RET
, typename T1 , 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 : BA
{ {
RET RET
@ -331,7 +331,7 @@ namespace control {
, typename T1 , typename T1
, typename T2 , 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 : BA
{ {
RET RET
@ -347,7 +347,7 @@ namespace control {
, typename T2 , typename T2
, typename T3 , 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 : BA
{ {
RET RET
@ -364,7 +364,7 @@ namespace control {
, typename T3 , typename T3
, typename T4 , 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 : BA
{ {
RET RET
@ -382,7 +382,7 @@ namespace control {
, typename T4 , typename T4
, typename T5 , 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 : BA
{ {
RET RET
@ -401,7 +401,7 @@ namespace control {
, typename T5 , typename T5
, typename T6 , 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 : BA
{ {
RET RET
@ -421,7 +421,7 @@ namespace control {
, typename T6 , typename T6
, typename T7 , 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 : BA
{ {
RET RET
@ -442,7 +442,7 @@ namespace control {
, typename T7 , typename T7
, typename T8 , 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 : BA
{ {
RET RET
@ -464,7 +464,7 @@ namespace control {
, typename T8 , typename T8
, typename T9 , 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 : BA
{ {
RET RET
@ -524,7 +524,7 @@ namespace control {
template<typename...TYPES> template<typename...TYPES>
struct _Type<std::tuple<TYPES...> > struct _Type<std::tuple<TYPES...> >
{ {
using Args = typename Types<TYPES...>::Seq; using Args = typename TyOLD<TYPES...>::Seq;
using Ret = void; using Ret = void;
using Sig = typename BuildFunType<void, Args>::Sig; using Sig = typename BuildFunType<void, Args>::Sig;
using ArgTuple = std::tuple<TYPES...>; using ArgTuple = std::tuple<TYPES...>;

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

@ -78,7 +78,7 @@ namespace control {
using lib::meta::_Fun; using lib::meta::_Fun;
using lib::meta::NullType; using lib::meta::NullType;
using lib::meta::Types; using lib::meta::TyOLD;
using lib::meta::Tuple; 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::BuildFunType;
using lib::meta::_Fun; using lib::meta::_Fun;
using lib::meta::Types; using lib::meta::TyOLD;
using lib::meta::Append; using lib::meta::Append;
using lib::meta::SplitLast; using lib::meta::SplitLast;
@ -77,7 +77,7 @@ namespace control {
using Args = typename _Fun<SIG>::Args; using Args = typename _Fun<SIG>::Args;
using ArgList = typename Args::List; using ArgList = typename Args::List;
using ExtendedArglist = typename Append<ArgList, MEM>::List; using ExtendedArglist = typename Append<ArgList, MEM>::List;
using ExtendedArgs = typename Types<ExtendedArglist>::Seq; using ExtendedArgs = typename TyOLD<ExtendedArglist>::Seq;
public: public:
using OperateSig = typename BuildFunType<void, Args>::Sig; using OperateSig = typename BuildFunType<void, Args>::Sig;
@ -118,7 +118,7 @@ namespace control {
using Memento = RET; using Memento = RET;
using ExtendedArglist = typename Append<ARG, Memento>::List; using ExtendedArglist = typename Append<ARG, Memento>::List;
using ExtendedArgs = typename Types<ExtendedArglist>::Seq; using ExtendedArgs = typename TyOLD<ExtendedArglist>::Seq;
using OperateSig = typename BuildFunType<void, ARG>::Sig; using OperateSig = typename BuildFunType<void, ARG>::Sig;
using CaptureSig = typename BuildFunType<Ret,ARG>::Sig; using CaptureSig = typename BuildFunType<Ret,ARG>::Sig;
@ -132,7 +132,7 @@ namespace control {
using Memento = typename SplitLast<Args>::Type; using Memento = typename SplitLast<Args>::Type;
using OperationArglist = typename SplitLast<Args>::List; 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 OperateSig = typename BuildFunType<void, OperationArgs>::Sig;
using CaptureSig = typename BuildFunType<Ret,OperationArgs>::Sig; using CaptureSig = typename BuildFunType<Ret,OperationArgs>::Sig;

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

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

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

@ -58,7 +58,7 @@ namespace steam {
namespace mobject { namespace mobject {
namespace builder { namespace builder {
typedef Types< session::Root, typedef TyOLD< session::Root,
session::Clip, session::Clip,
session::Effect, session::Effect,
session::Binding, session::Binding,

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

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

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

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

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

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

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

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

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

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

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

@ -46,7 +46,7 @@ namespace test{
using lib::wrapper::ItemWrapper; using lib::wrapper::ItemWrapper;
using steam::asset::meta::TimeGrid; using steam::asset::meta::TimeGrid;
using lib::meta::Types; using lib::meta::TyOLD;
using lib::meta::InstantiateChainedCombinations; using lib::meta::InstantiateChainedCombinations;
using LERR_(UNCONNECTED); using LERR_(UNCONNECTED);
@ -475,8 +475,8 @@ namespace test{
void void
TimeControl_test::verifyMatrix_of_MutationCases (TimeValue const& origVal, TimeValue const& change) TimeControl_test::verifyMatrix_of_MutationCases (TimeValue const& origVal, TimeValue const& change)
{ {
typedef Types<Duration,TimeSpan,QuTime> KindsOfTarget; // time entities to receive value changes typedef TyOLD<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<TimeValue,Time,Duration,TimeSpan,QuTime> KindsOfSource; // time entities to be used as change values
typedef InstantiateChainedCombinations< KindsOfTarget typedef InstantiateChainedCombinations< KindsOfTarget
, KindsOfSource , KindsOfSource
, TestCase // template to be instantiated for each type , 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 class Babbler
: public Applicable< Babbler, : public Applicable< Babbler,
Types<Boss,BigBoss>::List, // treat this types TyOLD<Boss,BigBoss>::List, // treat this types
VerboseVisitor<Tool> // intermediary base class VerboseVisitor<Tool> // intermediary base class
> >
{ {
@ -114,7 +114,7 @@ namespace test2 {
*/ */
class Blatherer class Blatherer
: public Applicable< Blatherer, : public Applicable< Blatherer,
Types<Visionary>::List, // get calls to Visionary dispatched TyOLD<Visionary>::List, // get calls to Visionary dispatched
VerboseVisitor<Hastalavista> // note: different tool base class VerboseVisitor<Hastalavista> // note: different tool base class
> >
{ {

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

@ -74,7 +74,7 @@ namespace test1 {
class Babbler class Babbler
: public Applicable< 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 , VerboseVisitor
> >
{ {

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

@ -111,7 +111,7 @@ namespace test {
void void
bindRandArgument (CommandImpl& cmd) bindRandArgument (CommandImpl& cmd)
{ {
typedef Types<int> ArgType; typedef TyOLD<int> ArgType;
TypedArguments<Tuple<ArgType>> arg (std::make_tuple (rani (10000))); TypedArguments<Tuple<ArgType>> arg (std::make_tuple (rani (10000)));
cmd.setArguments (arg); cmd.setArguments (arg);
CHECK (cmd.canExec()); CHECK (cmd.canExec());

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

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

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

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

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

@ -210,7 +210,7 @@ namespace test {
CHECK (!isSameObject (*pImpl, *clone)); CHECK (!isSameObject (*pImpl, *clone));
CHECK (!pImpl->canExec()); CHECK (!pImpl->canExec());
typedef Types<int> ArgType; typedef TyOLD<int> ArgType;
TypedArguments<Tuple<ArgType>> arg{Tuple<ArgType>(98765)}; TypedArguments<Tuple<ArgType>> arg{Tuple<ArgType>(98765)};
pImpl->setArguments(arg); pImpl->setArguments(arg);
CHECK (pImpl->canExec()); 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);
CHECK (!com->canExec()); CHECK (!com->canExec());
typedef Types<int> ArgType; typedef TyOLD<int> ArgType;
const int ARGR{1 + rani (1000)}; const int ARGR{1 + rani (1000)};
Tuple<ArgType> tuple(ARGR); Tuple<ArgType> tuple(ARGR);
TypedArguments<Tuple<ArgType>> arg(tuple); 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 * so it will call the \c onUnknown(Buildable&) instead
*/ */
class TestTool class TestTool
: public Applicable<TestTool, Types<Clip, DummyMO>::List> : public Applicable<TestTool, TyOLD<Clip, DummyMO>::List>
{ {
public: public:
string log_; string log_;

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

@ -41,7 +41,7 @@ namespace test {
namespace { // what follows is a simulated (simplified) version namespace { // what follows is a simulated (simplified) version
// of the complete Session + SessionManager setup..... // of the complete Session + SessionManager setup.....
using lib::meta::Types; using lib::meta::TyOLD;
using lib::meta::InstantiateChained; using lib::meta::InstantiateChained;
@ -161,7 +161,7 @@ namespace test {
struct TSessManagerImpl; struct TSessManagerImpl;
typedef TSessionServices< Types<InternalAPI_1,InternalAPI_2> typedef TSessionServices< TyOLD<InternalAPI_1,InternalAPI_2>
, TSessManagerImpl , TSessManagerImpl
, TSessionImpl , TSessionImpl
> SessionImplAPI; > 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<2>
, Num<3> , Num<3>
>::List List1; >::List List1;
typedef Types< Num<5> typedef TyOLD< Num<5>
, Num<6> , Num<6>
, Num<7> , Num<7>
>::List List2; >::List List2;
@ -153,10 +153,10 @@ namespace test {
{ {
cout << "\t:\n\t: ---Apply---\n"; cout << "\t:\n\t: ---Apply---\n";
Tuple<Types<>> tup0 ; Tuple<TyOLD<>> tup0 ;
Tuple<Types<int>> tup1 (11); Tuple<TyOLD<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12); Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13); Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
DUMPVAL (tup0); DUMPVAL (tup0);
DUMPVAL (tup1); DUMPVAL (tup1);
DUMPVAL (tup2); DUMPVAL (tup2);
@ -183,10 +183,10 @@ namespace test {
void void
check_applyFunc () check_applyFunc ()
{ {
Tuple<Types<>> tup0 ; Tuple<TyOLD<>> tup0 ;
Tuple<Types<int>> tup1 (11); Tuple<TyOLD<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12); Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13); Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
function<int()> functor0 (fun0); function<int()> functor0 (fun0);
function<int(int)> functor1 (fun1); function<int(int)> functor1 (fun1);
function<int(int,int)> functor2 (fun2); function<int(int,int)> functor2 (fun2);
@ -215,10 +215,10 @@ namespace test {
{ {
cout << "\t:\n\t: ---Bind----\n"; cout << "\t:\n\t: ---Bind----\n";
Tuple<Types<>> tup0 ; Tuple<TyOLD<>> tup0 ;
Tuple<Types<int>> tup1 (11); Tuple<TyOLD<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12); Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13); Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
typedef function<int()> BoundFun; typedef function<int()> BoundFun;
@ -248,10 +248,10 @@ namespace test {
void void
check_bindFunc () check_bindFunc ()
{ {
Tuple<Types<>> tup0 ; Tuple<TyOLD<>> tup0 ;
Tuple<Types<int>> tup1 (11); Tuple<TyOLD<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12); Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13); Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
function<int()> unbound_functor0 (fun0); function<int()> unbound_functor0 (fun0);
function<int(int)> unbound_functor1 (fun1); function<int(int)> unbound_functor1 (fun1);
function<int(int,int)> unbound_functor2 (fun2); function<int(int,int)> unbound_functor2 (fun2);
@ -285,10 +285,10 @@ namespace test {
void void
build_closure () build_closure ()
{ {
Tuple<Types<>> tup0 ; Tuple<TyOLD<>> tup0 ;
Tuple<Types<int>> tup1 (11); Tuple<TyOLD<int>> tup1 (11);
Tuple<Types<int,int>> tup2 (11,12); Tuple<TyOLD<int,int>> tup2 (11,12);
Tuple<Types<int,int,int>> tup3 (11,12,13); Tuple<TyOLD<int,int,int>> tup3 (11,12,13);
FunctionClosure<int()> clo0 (fun0,tup0); FunctionClosure<int()> clo0 (fun0,tup0);
FunctionClosure<int(int)> clo1 (fun1,tup1); FunctionClosure<int(int)> clo1 (fun1,tup1);
@ -327,7 +327,7 @@ namespace test {
// finally combine all techniques.... // finally combine all techniques....
using NumberzArg = Types<List2>::Seq; using NumberzArg = TyOLD<List2>::Seq;
using NumberzSig = BuildFunType<int,NumberzArg>::Sig; using NumberzSig = BuildFunType<int,NumberzArg>::Sig;
Tuple<NumberzArg> numberzTup (Num<5>(22), Num<6>(33), Num<7>(44)); 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--- // // 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) PartialArg arg(num18, PH1(), PH2()); // Value for partial application (the placeholders are default constructed)
fun_23 = std::bind (f, get<0>(arg) // now extract the values to bind from this tuple fun_23 = std::bind (f, get<0>(arg) // now extract the values to bind from this tuple
@ -216,7 +216,7 @@ namespace test {
// Version3: let the PApply-template do the work for us--- // // 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)); Tuple<ArgTypes> args_to_bind (Num<1>(18));
fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind); fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind);
@ -279,7 +279,7 @@ namespace test {
// covering the general case of partial function closure: // covering the general case of partial function closure:
typedef Num<5> Sig54321(Num<5>, Num<4>, Num<3>, Num<2>, Num<1>); // Signature of the 5-argument function typedef Num<5> Sig54321(Num<5>, Num<4>, Num<3>, Num<2>, Num<1>); // Signature of the 5-argument function
typedef Num<5> Sig54 (Num<5>, Num<4>); // ...closing the last 3 arguments should yield this 2-argument function typedef Num<5> Sig54 (Num<5>, Num<4>); // ...closing the last 3 arguments should yield this 2-argument function
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... // Close the trailing 3 arguments of the 5-argument function...
function<Sig54> fun_54 = PApply<Sig54321, Args2Close>::bindBack(fun15<5,4,3,2,1>, function<Sig54> fun_54 = PApply<Sig54321, Args2Close>::bindBack(fun15<5,4,3,2,1>,

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

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

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

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

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

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

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

@ -43,14 +43,14 @@ namespace test {
namespace { // test data namespace { // test data
typedef Types< Num<1> typedef TyOLD< Num<1>
, Num<3> , Num<3>
, Num<5> , Num<5>
> Types1; > Types1;
typedef Types< Num<2> typedef TyOLD< Num<2>
, Num<4> , Num<4>
> Types2; > Types2;
typedef Types< Num<7>> Types3; typedef TyOLD< Num<7>> Types3;
@ -125,7 +125,7 @@ namespace test {
Prepend prep (22, 11,33,Num<5>()); Prepend prep (22, 11,33,Num<5>());
DUMPVAL (prep); 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 typedef Tuple<NullType> NulL; // list-style empty Tuple
NulT nulT; // and these, too, can be instantiated NulT nulT; // and these, too, can be instantiated

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

@ -31,7 +31,7 @@ using lib::idi::EntryID;
using lib::diff::Rec; using lib::diff::Rec;
using lib::diff::MakeRec; using lib::diff::MakeRec;
using lib::diff::GenNode; using lib::diff::GenNode;
using lib::meta::Types; using lib::meta::TyOLD;
using lib::meta::Tuple; using lib::meta::Tuple;
using lib::meta::buildTuple; using lib::meta::buildTuple;
using lib::time::Duration; using lib::time::Duration;
@ -82,8 +82,8 @@ namespace test {
void void
show_simpleUsage() show_simpleUsage()
{ {
using NiceTypes = Types<string, int>; using NiceTypes = TyOLD<string, int>;
using UgglyTypes = Types<EntryID<long>, Symbol, int, int64_t, double, Duration>; // various conversions and an immutable type (Duration) 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 args = MakeRec().scope("lalü", 42);
Rec urgs = MakeRec().scope("lalü", "lala", 12, 34, 5.6, Time(7,8,9)); Rec urgs = MakeRec().scope("lalü", "lala", 12, 34, 5.6, Time(7,8,9));
@ -101,19 +101,19 @@ namespace test {
{ {
Rec args = MakeRec().scope("surprise", 42); 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 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 Unsigned = TyOLD<string, uint>;
using Floating = Types<string, float>; using Floating = TyOLD<string, float>;
using Narrowing = Types<string, short>; 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<Unsigned> (args)); // dangerous conversion from signed to unsigned int is prohibited
VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args)); // conversion from integral to floating point element is prohibited VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args)); // conversion from integral to floating point element is prohibited
VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args)); // narrowing conversion from int to short is prohibited VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args)); // narrowing conversion from int to short is prohibited
// yet other (non-numeric) conversions are still possible // yet other (non-numeric) conversions are still possible
Rec timeArg = MakeRec().scope(Time(1,2,3,4)); Rec timeArg = MakeRec().scope(Time(1,2,3,4));
using TupStr = Types<string>; using TupStr = TyOLD<string>;
Tuple<TupStr> tup = buildTuple<TupStr> (timeArg); Tuple<TupStr> tup = buildTuple<TupStr> (timeArg);
CHECK (std::get<string> (tup) == "4:03:02.001"); CHECK (std::get<string> (tup) == "4:03:02.001");
@ -126,7 +126,7 @@ namespace test {
VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args)); VERIFY_ERROR (WRONG_TYPE, buildTuple<Floating> (args));
VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args)); VERIFY_ERROR (WRONG_TYPE, buildTuple<Narrowing> (args));
using ToSizeT = 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 VERIFY_ERROR (WRONG_TYPE, (buildTuple<ToSizeT> (args))); // not even conversion to size_t is allowed
struct Dummy 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. 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 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<2>
, Num<3> , Num<3>
>::List List1; >::List List1;
typedef Types< Num<5> typedef TyOLD< Num<5>
, Num<6> , Num<6>
, Num<7> , Num<7>
>::List List2; >::List List2;
@ -173,7 +173,7 @@ namespace test {
void void
check_splice () 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... // will "paste" the list OLi "on top" of another Typelist...
typedef Splice<NullType, NullType> Overl01; typedef Splice<NullType, NullType> Overl01;
@ -216,7 +216,7 @@ namespace test {
DISPLAY (Overl13); 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, 0>::Front Front1;
typedef Splice<List1, OLi2, 1>::Front Front2; typedef Splice<List1, OLi2, 1>::Front Front2;
typedef Splice<List1, OLi2, 5>::Front Front3; typedef Splice<List1, OLi2, 5>::Front Front3;
@ -244,7 +244,7 @@ namespace test {
typedef SplitLast<List1>::Type Elm; typedef SplitLast<List1>::Type Elm;
typedef SplitLast<List1>::List Prefix; typedef SplitLast<List1>::List Prefix;
typedef Types<Elm>::List ElmL; typedef TyOLD<Elm>::List ElmL;
DISPLAY (Prefix); DISPLAY (Prefix);
DISPLAY (ElmL); DISPLAY (ElmL);
@ -253,13 +253,13 @@ namespace test {
typedef SplitLast<ElmL>::List NPrefix; typedef SplitLast<ElmL>::List NPrefix;
DISPLAY (NPrefix); DISPLAY (NPrefix);
DISPLAY (Types<Elm1>); DISPLAY (TyOLD<Elm1>);
typedef SplitLast<NullType>::Type Nil; typedef SplitLast<NullType>::Type Nil;
typedef SplitLast<NullType>::List NList; typedef SplitLast<NullType>::List NList;
DISPLAY (NList); DISPLAY (NList);
DISPLAY (Types<Nil>); DISPLAY (TyOLD<Nil>);
} }
@ -278,7 +278,7 @@ namespace test {
typedef Dissect<LL>::Head Head; typedef Dissect<LL>::Head Head;
typedef Dissect<LL>::End End; 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; typedef PrefixAll<NullType,List1> Prefix3;
DISPLAY (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; typedef PrefixAll<Num<111>,List_of_Lists> Prefix4;
DISPLAY (Prefix4); DISPLAY (Prefix4);
@ -336,14 +336,14 @@ namespace test {
typedef Distribute<Num<11>, List1> Dist1; typedef Distribute<Num<11>, List1> Dist1;
DISPLAY (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; typedef Distribute<Prefixes, Num<0>> Dist2;
DISPLAY (Dist2); DISPLAY (Dist2);
typedef Distribute<Prefixes, List1> Dist3; typedef Distribute<Prefixes, List1> Dist3;
DISPLAY (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); 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<2>
, Block<3> , Block<3>
, Block<5> , 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 , uint
, int64_t , int64_t
, uint64_t , uint64_t
>::List TheList; >::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 namespace { // test data
typedef Types< Num<1> typedef TyOLD< Num<1>
, Num<2> , Num<2>
, Num<3> , Num<3>
> Types1; > Types1;
typedef Types< Num<7> typedef TyOLD< Num<7>
, Num<8> , Num<8>
, Num<9> , Num<9>
> Types2; > Types2;
@ -99,12 +99,12 @@ namespace test {
typedef Append<Types1::List, Types2::List>::List LL; typedef Append<Types1::List, Types2::List>::List LL;
DISPLAY (LL); DISPLAY (LL);
typedef Types<LL>::Seq Seq; typedef TyOLD<LL>::Seq Seq;
typedef Seq::List SeqList; typedef Seq::List SeqList;
DISPLAY (Seq); DISPLAY (Seq);
DISPLAY (SeqList); DISPLAY (SeqList);
typedef Types<NodeNull>::Seq NulS; typedef TyOLD<NodeNull>::Seq NulS;
DISPLAY (NulS); DISPLAY (NulS);
} }
@ -118,10 +118,10 @@ namespace test {
typedef Prepend<NullType, Types1> Prepend2; typedef Prepend<NullType, Types1> Prepend2;
DISPLAY(Prepend2); DISPLAY(Prepend2);
typedef Prepend<Num<5>, Types<> > Prepend3; typedef Prepend<Num<5>, TyOLD<> > Prepend3;
DISPLAY(Prepend3); DISPLAY(Prepend3);
typedef Prepend<NullType, Types<> > Prepend4; typedef Prepend<NullType, TyOLD<> > Prepend4;
DISPLAY(Prepend4); DISPLAY(Prepend4);
} }
@ -130,7 +130,7 @@ namespace test {
check_shift () check_shift ()
{ {
typedef Append<Types2::List, Types1::List>::List LL; 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,0>::Type Seq_0; DISPLAY (Seq_0);
typedef Shifted<Seq,1>::Type Seq_1; DISPLAY (Seq_1); 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,5>::Type Seq_5; DISPLAY (Seq_5);
typedef Shifted<Seq,6>::Type Seq_6; DISPLAY (Seq_6); typedef Shifted<Seq,6>::Type Seq_6; DISPLAY (Seq_6);
typedef Types<Shifted<Seq,0>::Head> Head_0; DISPLAY (Head_0); typedef TyOLD<Shifted<Seq,0>::Head> Head_0; DISPLAY (Head_0);
typedef Types<Shifted<Seq,1>::Head> Head_1; DISPLAY (Head_1); typedef TyOLD<Shifted<Seq,1>::Head> Head_1; DISPLAY (Head_1);
typedef Types<Shifted<Seq,2>::Head> Head_2; DISPLAY (Head_2); typedef TyOLD<Shifted<Seq,2>::Head> Head_2; DISPLAY (Head_2);
typedef Types<Shifted<Seq,3>::Head> Head_3; DISPLAY (Head_3); typedef TyOLD<Shifted<Seq,3>::Head> Head_3; DISPLAY (Head_3);
typedef Types<Shifted<Seq,4>::Head> Head_4; DISPLAY (Head_4); typedef TyOLD<Shifted<Seq,4>::Head> Head_4; DISPLAY (Head_4);
typedef Types<Shifted<Seq,5>::Head> Head_5; DISPLAY (Head_5); typedef TyOLD<Shifted<Seq,5>::Head> Head_5; DISPLAY (Head_5);
typedef Types<Shifted<Seq,6>::Head> Head_6; DISPLAY (Head_6); typedef TyOLD<Shifted<Seq,6>::Head> Head_6; DISPLAY (Head_6);
} }
@ -154,7 +154,7 @@ namespace test {
check_split () check_split ()
{ {
typedef Append<Types1::List, Types2::List>::List LL; typedef Append<Types1::List, Types2::List>::List LL;
typedef Types<LL>::Seq Seq; typedef TyOLD<LL>::Seq Seq;
DISPLAY (Seq); DISPLAY (Seq);
typedef Split<Seq>::List List; DISPLAY(List); typedef Split<Seq>::List List; DISPLAY(List);
@ -166,7 +166,7 @@ namespace test {
typedef Split<Seq>::Head Head; typedef Split<Seq>::Head Head;
typedef Split<Seq>::End End; 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{ namespace test{
using ::Test; using ::Test;
using meta::Types; using meta::TyOLD;
using lib::time::Time; using lib::time::Time;
using lib::time::TimeVar; using lib::time::TimeVar;
@ -43,7 +43,7 @@ namespace test{
// Test fixture... // Test fixture...
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"> <node BACKGROUND_COLOR="#d2beaf" COLOR="#5c4d6e" CREATED="1739743240214" ID="ID_1756740911" MODIFIED="1739743248263" TEXT="geplant: Namen austauschen">
<icon BUILTIN="hourglass"/> <icon BUILTIN="hourglass"/>
</node> </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> </node>
<node CREATED="1540682674455" ID="ID_1625152878" MODIFIED="1557498707236" TEXT="Typliste filtern"> <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>
</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>
<node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1742175299968" ID="ID_1393531242" MODIFIED="1742175305316" TEXT="C++20"> <node BACKGROUND_COLOR="#fdfdcf" COLOR="#ff0000" CREATED="1742175299968" ID="ID_1393531242" MODIFIED="1742175305316" TEXT="C++20">
<icon BUILTIN="flag-pink"/> <icon BUILTIN="flag-pink"/>