[C con Clase] Ayuda definición templates y structs

[Jorge Vega Sanchez]

*********************************************
CODE
*********************************************
#ifndef WLPDSTM_TLS_H_
#define WLPDSTM_TLS_H_

namespace wlpdstm {

     ///////////////////////
     // invoke init start //
     ///////////////////////

     template<typename T, bool INIT = true>
     struct GlobalInitInvoker {
         static void GlobalInit() {
             T::GlobalInit();
         }
     };

     template<typename T>
     struct GlobalInitInvoker<T, false> {
         static void GlobalInit() {
             // do nothing
         }
     };

     template<typename T, bool INIT = true>
     struct ThreadInitInvoker {
         static void ThreadInit(T *obj) {
             obj->ThreadInit();
         }
     };

     template<typename T>
     struct ThreadInitInvoker<T, false> {
         static void ThreadInit(T *obj) {
             // do nothing
         }
     };
}
     /////////////////////
     // invoke init end //
     /////////////////////

#ifdef USE_PTHREAD_TLS

#include <pthread.h>

namespace wlpdstm {
     /**
      * This is a TLS class that will put one instance of templated
      * class into TLS storage and provide access to it. Assumption here
      * is that the TLS class exposes default constructor. If this is
      * not the case this class should be slightly changed.
      *
      */
     template<class T, bool GLOBAL_INIT, bool THREAD_INIT>
     class Tls {
         public:
             static void GlobalInit();
             static void ThreadInit();
             static T *Get();

         private:
             static ::pthread_key_t tlsKey;
             static ::pthread_key_t initKey;
     };
}

template<class T, bool GLOBAL_INIT, bool THREAD_INIT> ::pthread_key_t  
wlpdstm::Tls<T, GLOBAL_INIT, THREAD_INIT>::tlsKey;
template<class T, bool GLOBAL_INIT, bool THREAD_INIT> ::pthread_key_t  
wlpdstm::Tls<T, GLOBAL_INIT, THREAD_INIT>::initKey;

template<class T, bool GLOBAL_INIT, bool THREAD_INIT>
inline void wlpdstm::Tls<T, GLOBAL_INIT, THREAD_INIT>::GlobalInit() {
     ::pthread_key_create(&tlsKey, NULL);
     GlobalInitInvoker<T, GLOBAL_INIT>::GlobalInit();

     // not locally initialized
     ::pthread_key_create(&initKey, NULL);
     ::pthread_setspecific(initKey, (const void *)false);
}

template<class T, bool GLOBAL_INIT, bool THREAD_INIT>
inline void wlpdstm::Tls<T, GLOBAL_INIT, THREAD_INIT>::ThreadInit() {
     bool initialized = (bool)::pthread_getspecific(initKey);

     if(!initialized) {
         T *obj = new T();
         ::pthread_setspecific(tlsKey, (const void *)obj);
         ThreadInitInvoker<T, THREAD_INIT>::ThreadInit(obj);
         ::pthread_setspecific(initKey, (const void *)true);
     }
}

template<class T, bool GLOBAL_INIT, bool THREAD_INIT>
inline T *wlpdstm::Tls<T, GLOBAL_INIT, THREAD_INIT>::Get() {
     return (T *)::pthread_getspecific(tlsKey);
}

#else

namespace wlpdstm {
     template<class T, bool GLOBAL_INIT, bool THREAD_INIT>
     class Tls {
         public:
             static void GlobalInit() {
                 GlobalInitInvoker<T, GLOBAL_INIT>::GlobalInit();
             }

             static void ThreadInit() {
                 if(!init) {
                     val = new T();
                     ThreadInitInvoker<T, THREAD_INIT>::ThreadInit(val);
                     init = true;
                 }
             }

             static T *Get() {
                 return val;
             }

         private:
             static __thread T *val;
             static __thread bool init;
     };
}

template<class T, bool GLOBAL_INIT, bool THREAD_INIT> __thread T*  
wlpdstm::Tls<T, GLOBAL_INIT, THREAD_INIT>::val;
template<class T, bool GLOBAL_INIT, bool THREAD_INIT> __thread bool  
wlpdstm::Tls<T, GLOBAL_INIT, THREAD_INIT>::init;

#endif

#endif // WLPDSTM_TLS_H_
*********************************************

Buenas y gracias de antemano a todo aquel que se lea un poco este  
código que he puesto.
TEngo dudas sobre las definición de los tipos de datos, creo que no  
comprendo bien los define, template y los structs, porque me parece  
ver redundancias por todos lados.

DUDAS:
1ª Linea 24. No comprendo este template. No se supone que un template  
es para crear una estructura facilemnte repetible, tipo plantilla o  
algo así. No entiendo que hace un template justo antes de una  
definición de este 'struct'.

2ª Lineas 62 y 63. Definición de variables privadas dentro de una  
clase. Que significa '::' delante de la definición de las variables.

3º Líneas 67 y 68. No comprendo estos 2 templates.

4º Lineas 92 a 95. EL template con el 'inline' seguido. SE supone que  
un inline es una función de tamaño muy pequeño y que definimos de esta  
manera para mayor limpieza. Pero en este inline no encuentro el nombre  
de la función, para después invocarlo. Aparte no entiendo el comando  
después del inline, no veo declaración de variables.

5ªLinea 42 --> #ifdef USE_PTHREAD_TLS --> ESto es una instrucción para  
el pre-compilador. Se supone que si la variable USE_PTHREAD_TLS='1' se  
compila lo que esta a continuación y sino no. Lo que no entiendo es  
que en este fichero no se da valor a esa variable. Si estamos  
compilando y se supone que las variables no tienen valor, algunas sí,  
como sabe el compilador que tiene que compilar.

Gracias de antemano.
Soy un poco novato ocn esto de c++.



------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.conclase.net/pipermail/cconclase_listas.conclase.net/attachments/20090721/b44628fa/attachment.html>