Import Geant4 10.0.0 source tree

source/global/management/include/G4ThreadLocalSingleton.hh

@@ -0,0 +1,176 @@
+//
+// ********************************************************************
+// * License and Disclaimer                                           *
+// *                                                                  *
+// * The  Geant4 software  is  copyright of the Copyright Holders  of *
+// * the Geant4 Collaboration.  It is provided  under  the terms  and *
+// * conditions of the Geant4 Software License,  included in the file *
+// * LICENSE and available at  http://cern.ch/geant4/license .  These *
+// * include a list of copyright holders.                             *
+// *                                                                  *
+// * Neither the authors of this software system, nor their employing *
+// * institutes,nor the agencies providing financial support for this *
+// * work  make  any representation or  warranty, express or implied, *
+// * regarding  this  software system or assume any liability for its *
+// * use.  Please see the license in the file  LICENSE  and URL above *
+// * for the full disclaimer and the limitation of liability.         *
+// *                                                                  *
+// * This  code  implementation is the result of  the  scientific and *
+// * technical work of the GEANT4 collaboration.                      *
+// * By using,  copying,  modifying or  distributing the software (or *
+// * any work based  on the software)  you  agree  to acknowledge its *
+// * use  in  resulting  scientific  publications,  and indicate your *
+// * acceptance of all terms of the Geant4 Software license.          *
+// ********************************************************************
+//
+// $Id$
+//
+// ---------------------------------------------------------------
+// GEANT 4 class header file
+//
+// Class Description:
+//   This class implements a thread-private "singleton". Being thread
+//   private the singleton is not a singleton in the term, but a different
+//   instance existis for each thread.
+//   This class is a wrapper around the real object that we need to
+//   make singleton.
+//
+// Limitation:
+//   The object that is made thread-private singleton, should not
+//   contain any G4ThreadLocal data member. Note that in general,
+//   if object is to be thread-private it is unnecessary to mark
+//   any data-member as G4ThreadLocal.
+//   
+// Performance issues:
+//   This class uses locks and mutexes.
+//
+// Example:
+//   This is the singleton patter often found in G4 (sequential):
+//   class G4Class {
+//      private:
+//         static G4Class* instance;
+//         G4Class() { ... }
+//      public:
+//         static G4Class* GetInstance() {
+//              static G4Class theInstance;
+//              if ( instance == 0 ) instance = &theInstance;
+//              return instance;
+//         }
+//  };
+//  This is transformed to the following to implement a thread-local
+//  singleton:
+//   class G4Class {
+//      private:
+//         static G4ThreadLocal G4Class* instance;
+//         G4Class() { ... }
+//      public:
+//         static G4Class* GetInstance() {
+//              if ( instance == 0 ) instance = new G4Class;
+//              return instance;
+//         }
+//  };
+//  Note that this class also has a memory leak.
+//
+//  This class can be used as follows:
+//   class G4Class {
+//      friend class G4ThreadLocalSingleton<G4Class>;
+//      private:
+//         G4Class() { ... }
+//      public:
+//         static G4Class* GetInstance() {
+//              static G4ThreadLocalSingleton<G4Class> instance;
+//              return instance.Instance();
+//         }
+//  };
+//  Each thread has its own instance of G4Class.
+//  Deletion of G4Class instances is done at end of program.
+//  Note the "friend" statement.
+//
+// History:
+//  28 October 2013: A. Dotti - First implementation
+
+#ifndef G4TLSSINGLETON_HH
+#define G4TLSSINGLETON_HH
+
+//Debug this code
+//#define g4tlssdebug 1
+
+#include "G4Cache.hh"
+#include <list>
+
+//Forward declaration. See G4AutoDelete.hh
+namespace G4AutoDelete {
+  template<class T>
+  void Register(T*);
+}
+
+template<class T>
+class G4ThreadLocalSingleton : private G4Cache<T*> {
+  friend void G4AutoDelete::Register<T>(T*);
+public:
+  G4ThreadLocalSingleton();
+  //Creates thread-local singleton manager
+
+  ~G4ThreadLocalSingleton(); 
+
+  T* Instance() const; 
+  //Returns a pointer to a thread-private instance of T
+
+private:
+  G4ThreadLocalSingleton( G4ThreadLocalSingleton& rhs);// {}
+  void Register(T* i) const; 
+
+  void Clear();
+
+  mutable std::list<T*> instances;
+  mutable G4Mutex listm;
+};
+
+
+//=============================================================
+// Implementation details follow
+//=============================================================
+#include "G4AutoLock.hh"
+template<class T>
+G4ThreadLocalSingleton<T>::G4ThreadLocalSingleton() : G4Cache<T*>() {
+  G4MUTEXINIT(listm);
+  G4Cache<T*>::Put(static_cast<T*>(0)); 
+}
+
+template<class T>
+G4ThreadLocalSingleton<T>::~G4ThreadLocalSingleton() {
+  Clear();
+}
+
+template<class T>
+T* G4ThreadLocalSingleton<T>::Instance() const {
+    T* instance = G4Cache<T*>::Get();
+    if ( instance == static_cast<T*>(0) ) {
+      instance = new T;
+      G4Cache<T*>::Put( instance );
+      Register(instance);
+    }
+    return instance;
+  }
+
+template<class T>
+G4ThreadLocalSingleton<T>::G4ThreadLocalSingleton( G4ThreadLocalSingleton&) {}
+template<class T>
+void G4ThreadLocalSingleton<T>::Register(T* i) const {
+  G4AutoLock l(&listm);
+  instances.push_back(i);
+}
+
+
+template<class T>
+void G4ThreadLocalSingleton<T>::Clear() {
+    G4AutoLock l(&listm);
+    while ( ! instances.empty() ) 
+    {
+      T* thisinst = instances.front();
+      instances.pop_front();
+      if ( thisinst != 0 ) delete thisinst;
+    }
+  }
+
+#endif //G4TLSSINGLETON_HH