1 // Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // SALOME Utils : general SALOME's definitions and tools
24 // File : Utils_SINGLETON.hxx
25 // Author : Antoine YESSAYAN, EDF
29 # if !defined( __SINGLETON__H__ )
30 # define __SINGLETON__H__
32 #include "SALOME_Utils.hxx"
34 # include "Utils_DESTRUCTEUR_GENERIQUE.hxx"
41 * A singleton is a data which is created and deleted only once in the application.
42 * The C++ compiler allow the user to create static data before the first executable statement.
43 * They are deleted after the last statement.statement.
45 * The SINGLETON_ template class deals with dynamic singleton. It is useful for functor objects.
46 * For example, an object which, when created, connects the application to a system and
47 * disconnects the application at deletion.
52 * To create a single instance a POINT_ object :
54 * # include "Utils_SINGLETON.hxx"
56 * ptrPoint = SINGLETON_<POINT_>::Instance() ;
59 * <B>Design description</B>
61 * -# the user creates an object of class TYPE By using a class method : SINGLETON_<TYPE>::Instance() which
62 * returns a pointer to the single object ;
63 * -# this class method uses the default constructor to create an object ;
64 * -# at the same time, this class method reate a destructor object which is added to the generic list
65 * of destructors objects to be executed at the end of the application (atexit) ;
66 * -# at the end of the application process all the deletions are performed by the Nettoyage() C function
67 * which execute the destructions objects then deletes the destructions objects themselves ;
68 * -# the Nettoyage() C function is recorded using atexit() C function through the creation of a static
69 * single object ATEXIT_().
73 template <class TYPE> class SINGLETON_
78 static TYPE *Instance( void ); //!< Singleton dynamic creation using the default builder
79 static bool IsAlreadyExisting( void ); //!< returns True if the singleton is already existing
80 static int Destruction( void ); //!< destroys the Singleton before the end of the application process
85 static SINGLETON_ *PtrSingleton ;
90 } ; /* class SINGLETON_<TYPE> */
95 template <class TYPE> SINGLETON_<TYPE> *SINGLETON_<TYPE>::PtrSingleton=NULL ;
100 * The class method Instance :
101 * -# creates an object of class TYPE ;
102 * -# creates a destruction object DESTRUCTEUR_DE_<TYPE> which is appended to the list of destruction objects to be
104 * -# returns a pointer to the created object.
106 * Note that the two created objects are deleted at the end of the process in the function Nettoyage().
108 template <class TYPE> TYPE *SINGLETON_<TYPE>::Instance( void )
110 if ( ! PtrSingleton )
112 //MESSAGE("SINGLETON_<TYPE>::Instance( void )") ;
113 PtrSingleton = new SINGLETON_<TYPE> ;
114 new DESTRUCTEUR_DE_<TYPE>( PtrSingleton->_Instance ) ;
116 return &PtrSingleton->_Instance ;
120 template <class TYPE> bool SINGLETON_<TYPE>::IsAlreadyExisting( void )
122 return PtrSingleton ? true : false ;
128 template <class TYPE> SINGLETON_<TYPE>::SINGLETON_( void )
130 //MESSAGE("CREATION d'un SINGLETON_") ;
137 The method SINGLETON_<TYPE>::Destruction can be called by the user. If it is not
138 the function nettoyage() calls it atexit.
140 N.B. : the singleton objects are destroyed in the reverse order of there creation.
142 template <class TYPE> int SINGLETON_<TYPE>::Destruction( void )
145 //BEGIN_OF("SINGLETON_<TYPE>::Destruction( void )") ;
148 //MESSAGE("Destruction du SINGLETON_") ;
151 std::list<DESTRUCTEUR_GENERIQUE_ *>::iterator k ;
152 for( k=DESTRUCTEUR_GENERIQUE_::Destructeurs->begin() ; k!=DESTRUCTEUR_GENERIQUE_::Destructeurs->end();k++)
154 if ( *k == PtrSingleton->_Instance )
156 DESTRUCTEUR_GENERIQUE_::Destructeurs->erase( k ) ;
160 delete PtrSingleton ;
161 PtrSingleton = NULL ;
163 //END_OF("SINGLETON_<TYPE>::Destruction( void )") ;
168 template <class TYPE> SINGLETON_<TYPE>::~SINGLETON_()
170 //MESSAGE("passage dans SINGLETON_<TYPE>::~SINGLETON_( void )") ;
173 # endif /* # if !defined( __SINGLETON__H__ ) */