---

/root/src/subsynth/syn/Util/Singleton.h

Go to the documentation of this file.

#ifndef _SYN_SINGLETON_H_
#define _SYN_SINGLETON_H_

#include <stdlib.h> // for NULL, duh...

namespace syn
{
   
   template< class singleClass >
   class Singleton
   {
   public:
      inline static singleClass* instance( void )        
      {                                                 
         // WARNING! race condition possibility, creation of static vars 
         // are not thread safe.  This is only an issue when creating
         // your first thread, since it uses a singleton thread manager,
         // the two threads might both try to call instance at the same time
         // which then the creation of the following mutex would not be certain.
         //static vpr::Mutex singleton_lock1;       
         static singleClass* the_instance1 = NULL;   
                                     
         if (NULL == the_instance1)                 
         {                                            
            //vpr::Guard<vpr::Mutex> guard( singleton_lock1 );
            if (NULL == the_instance1)        
            { the_instance1 = new singleClass; }         
         }                                      
         return the_instance1;                     
      }

   protected:
      Singleton()
      {
      }

      virtual ~Singleton()
      {
      }
   };
}; // end of namespace vpr


//
// Non-locking version
//
/*
#define vprSingletonHeader( TYPE )                               \
public:                                                          \
   static TYPE* instance( void )                                 \
   {                                                             \
      static TYPE* the_instance = NULL;                          \
      if (the_instance == NULL)                                  \
      {                                                          \
         std::cout << "Creating instance of: TYPE" << std::endl; \
         the_instance = new TYPE;                                \
      }                                                          \
      return the_instance;                                       \
   }

#define vprSingletonHeaderWithInitFunc( TYPE, INIT_FUNC_NAME )   \
public:                                                          \
   static TYPE* instance( void )                                 \
   {                                                             \
      static TYPE* the_instance = NULL;                          \
      if (the_instance == NULL)                                  \
      {                                                          \
         std::cout << "Creating instance of: TYPE" << std::endl; \
         the_instance = new TYPE;                                \
         the_instance->INIT_FUNC_NAME();                         \
      }                                                          \
      return the_instance;                                       \
   }

#define vprSingletonImp( TYPE ) ;
*/

#endif

---