momentan stehe ich vor dem Folgenden Problem:

// Ich mache irgendwo sowas 
// wobei das TYPELIST_3(Type1, Type2,Type3) zu dem Typen "Typelist" wird
typedef TL::GenSactterHierarchy<TYPELIST_3(Type1, Type2,Type3), Holder> WidgetInfo;

WidgetInfo obj;

template <int i, class H>
typename FieldTrait<H>::At<i>::Result& 
Field(H& obj)
{
        /// So soll der Aufruf funktionieren.
	typedef typename FieldTrait<H>::At<i>::Result Result;
}

Irgendwie bekomme ich den "FieldTrait" nicht ordentlich hin.
H = Typelist

template <class TList>
	struct FieldTrait;

	template <class T, class U>
	struct FieldTrait<Typelist<T,U> >
	{
		typedef TypelistAt At; /// geht netürlich nicht 
	};

Ich weiß nicht wie ich das At dazu bringe, einen Templateparameter zu nehmen,
ohne FieldTrait einen weitern geben zu müssen.

Ahhh ich glaub ich habs... moment... NO

http://en.wikipedia.org/wiki/C%2B%2B11#Alias_templates

Ich glaub ich hab aber Hilfe gefunden....
Also hab ein Beispiel gefunden.

Es geht darum die This pointer aus dem Objekt wieder raus zu bekommen, wo mit GenSattern erzeugt worden ist...
(Also auf ne schöne Art und Weise... ich hab schon ne lösung gepostet in den vorigen Posts, die ist aber nicht zufriedenstellend. Zumindest versuche ich es jetzt schöner zu machen. )

template <class TList>
struct FieldTrait;

template <class T, class U>
struct FieldTrait<Typelist<T,U> >
{
    template <int i>
    struct At
    {
        typedef Typelist Result;
    };
}; 

...

template <int i, class H>
typename FieldTrait<H>::template At<i>::Result& Field(H& obj)
{
...
}

Wow das ist aber cool

EDIT: Das muss ich mir erstmal länger anschauen, glaub 100% ist es das nicht, aber Ev. bringts mich in die richtige Richtung.

Na ja ob ich da jetzt using oder typedef schreibe ist für mich erstmal nicht so wichtig. (Ich hätte gerne eine Banane, hier hat du nen schuh.. !! Was soll ich mit nem schuh ?? Der schmeckt nach käse und der ist genau so gelb wie ne banane... ) Wobei mein post wohl eher zu vergleichen ist mit "Ich mag was gelbes" *lach*

Ich glaube, du hast die Sprungfedern am Schuh übersehen. Du kannst so nämlich template-typedefs machen:

template <class TList>
    struct FieldTrait;

    template <class T, class U>
    struct FieldTrait<Typelist<T,U> >
    {
        template<class T1, class U1> using At = TypelistAt<T1, U1>;
    };

EDIT: Lass mich raten... mit At<int i> willst du auf den i-ten Typ zugreifen?

Aber mein compiler kann grad kein schuh.... *lach*...
Ich schmeiß mich weg... ich finds lustig irgendwie...

Werd mir das using aber in jedem Fall noch anschauen....
Gerade mag ich mich eben auf das fokusieren was ich tue...
Einfach als erklärung wiso das using bei mir irgendwie nicht zum Thema passte.
Das kann immer gut auch unwissenheit meinerseits sein...

Tut jetzt.

Kann jetzt endlich sowas schreiben:

Holder<Type1> &H_int    = TL::Field<0>(obj);
 Holder<Type2> &H_double = TL::Field<1>(obj);
 Holder<Type3> &H_char	 = TL::Field<2>(obj);

Das ist verdammt coool.
Werte das mal als Programmiertechnik...
Als nächstes kommt design muster für welches man das super anwenden kann.
Wobei ich galube das das für manche ziemlich offensichtlich ist.
Ich bin begeistert.
Wow - einfach genial...