I can't understand how this C++ template work

Question

I am reading the source code of a library. But I can't understand how this template definition works:

template <class A>
struct Use{
    template <class T> struct AsVertexType: public T{typedef A VertexType;  typedef VertexType * VertexPointer  ;};
    template <class T> struct AsEdgeType: public T{typedef A EdgeType;          typedef EdgeType *  EdgePointer         ;};
    template <class T> struct AsFaceType: public T{typedef A FaceType;          typedef FaceType * FacePointer          ;};
    template <class T> struct AsTetraType: public T{typedef A TetraType;        typedef TetraType * TetraPointer        ;};
    template <class T> struct AsHEdgeType: public T{typedef A HEdgeType;        typedef HEdgeType * HEdgePointer        ;};
};

And this is how to declaire a class using Use<> template:

struct MyUsedTypes : public vcg::UsedTypes< vcg::Use<MyVertex> :: AsVertexType,
                                            vcg::Use<MyEdge>   :: AsEdgeType,
                                            vcg::Use<MyFace>   :: AsFaceType> {};

In the Use<> template definition, there are two unknown type A and T.

Take vcg::Use<MyVertex>::AsVertexType as example, I think A is MyVertex, but what is T?

---

Supplement

Here is definition of template UsedTypes

template < template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
           template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver,
           template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
           template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver >
class UsedTypes
    : public Arity12<DummyTypes,
                     Use< Vertex< UsedTypes<A, B, C, D , E, F, G, H> > > :: template AsVertexType,
                     Use< Edge  < UsedTypes<A, B, C, D , E, F, G, H> > > :: template AsEdgeType,
                     Use< Face  < UsedTypes<A, B, C, D , E, F, G, H> > > :: template AsFaceType,
                     Use< HEdge < UsedTypes<A, B, C, D , E, F, G, H> > > :: template AsHEdgeType,
                     A, B, C, D, E, F, G, H > {};

And a series of Arity template definition. It's like a Mathematical Induction

template < class Base,
           template <typename> class A >
class Arity1: public A<Base> {};


template < class Base,
           template <typename> class A,
           template <typename> class B > 
class Arity2: public B<Arity1<Base, A>> {};


template < class Base,
           template <typename> class A, template <typename> class B,
           template <typename> class C > 
class Arity3: public C<Arity2<Base, A, B>> {};
   .
   .
   .
template < class Base,
           template <typename> class A, template <typename> class B,
           template <typename> class C, template <typename> class D,
           template <typename> class E, template <typename> class F,
           template <typename> class G, template <typename> class H,
           template <typename> class I, template <typename> class J,
           template <typename> class K, template <typename> class L >
class Arity12: public L<Arity11<Base, A, B, C, D, E, F, G, H, I, J, K>> {};

It's still hard to tell what the template parameter T is.

Answer 1

vcg::Use<MyVertex> ::AsVertexType is a template, and when given to vcg::UsedTypes as a template parameter, constitutes a template template parameter - if you search for that term you'll find lots of explanations. It's up to the vcg::UsedTypes template to decide whether to use the AsVertexType template, and with what T parameter(s).

Answer 2

It looks like vcg::UsedTypes takes templates as its template arguments. So T will be whichever type or types UsedTypes uses the templates with.