src/Utils/Utils_DESTRUCTEUR_GENERIQUE.hxx

   1 //  SALOME Utils : general SALOME's definitions and tools
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   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.
  10 //
  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.
  15 //
  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
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : Utils_DESTRUCTEUR_GENERIQUE.hxx
  25 //  Author : Antoine YESSAYAN, EDF
  26 //  Module : SALOME
  27 //  $Header$
  28
  29 # if !defined( __DESTRUCTEUR_GENERIQUE__H__ )
  30 # define __DESTRUCTEUR_GENERIQUE__H__
  31
  32 # include <list>
  33 #include <cassert>
  34 # include <CORBA.h>
  35 //# include "utilities.h"
  36
  37 /*!\class DESTRUCTEUR_GENERIQUE_
  38  *
  39  * <B>Definition</B>
  40  *
  41  * The DESTRUCTEUR_GENERIQUE_ abstract class describes the comportement of any destruction object.
  42  * Tis type is used to create a list of miscellaneous destruction object.
  43  *
  44  * <B>Usage</B>
  45  *
  46  * The only way to use the DESTRUCTEUR_GENERIQUE_ class is inheritance :
  47  *      class DESTRUCTEUR_SPECIFIQUE_ : public DESTRUCTEUR_GENERIQUE_
  48  *
  49  * <B>Design description</B>
  50  *
  51  *      A generic destructor supply two functionalities :
  52  *      -# a static method to add a destruction (objetct) to be performed DESTRUCTEUR_GENERIQUE_::Ajout(
  53  *      DESTRUCTEUR_GENERIQUE_ &objet) ;
  54  *         The Destruction object is stored in a list of pointer to DESTRUCTEUR_GENERIQUE_ objects.
  55  *      -# an object method to execute the destruction : operator()().
  56  */
  57
  58 #if defined UTILS_EXPORTS
  59 #if defined WIN32
  60 #define UTILS_EXPORT __declspec( dllexport )
  61 #else
  62 #define UTILS_EXPORT
  63 #endif
  64 #else
  65 #if defined WNT
  66 #define UTILS_EXPORT __declspec( dllimport )
  67 #else
  68 #define UTILS_EXPORT
  69 #endif
  70 #endif
  71
  72 class DESTRUCTEUR_GENERIQUE_
  73 {
  74 public :
  75   UTILS_EXPORT static std::list<DESTRUCTEUR_GENERIQUE_*> *Destructeurs;
  76
  77   virtual ~DESTRUCTEUR_GENERIQUE_() {}//!< virtual destructor
  78   UTILS_EXPORT static const int Ajout( DESTRUCTEUR_GENERIQUE_ &objet );//!< adds a destruction object to the list of destructions
  79   UTILS_EXPORT virtual void operator()( void )=0 ;//!< performs the destruction
  80 } ;
  81
  82
  83 /*!\class DESTRUCTEUR_DE_
  84  *
  85  * <B>Purpose</B>
  86  *
  87  * The DESTRUCTEUR_DE_ class allows the user to program - at any moment - the destruction of an object
  88  * at the end of the process.
  89  *
  90  * <B>Usage</B>
  91  *
  92  *      In this example the POINT_ ptrPoint will be destroyed at the end of the process (atexit).
  93  *
  94  *      POINT_ *ptrPoint = new POINT_ ;<BR>
  95  *      DESTRUCTEUR_DE_<POINT_> *ptrDestruction = new DESTRUCTEUR_DE_<POINT_>( *ptrPoint ) ;
  96  *
  97  *      Note that neither ptrPoint, nor ptrDestruction should be destroyed by the user.
  98  *
  99  * <B>Design description</B>
 100  *
 101  *      The destruction object must be created dynamicaly because it suscribes himself in the list of
 102  *      destruction to be performed at the end of the process.
 103  *
 104  */
 105 template <class TYPE> class DESTRUCTEUR_DE_ : public DESTRUCTEUR_GENERIQUE_
 106 {
 107 public :
 108   /* Programs the destruction at the end of the process, of the object objet.
 109      This method records in _PtrObjet the address of an object to be destroyed
 110      at the end of the process
 111   */
 112   DESTRUCTEUR_DE_(TYPE &objet):
 113     _PtrObjet( &objet )
 114   {
 115     assert(DESTRUCTEUR_GENERIQUE_::Ajout( *this ) >= 0) ;
 116   }
 117
 118   /* Performs the destruction of the object.
 119      This method really destroys the object pointed by _PtrObjet.
 120      It should be called at the end of the process (i.e. at exit).
 121   */
 122   virtual void operator()(void){
 123     typedef PortableServer::ServantBase TServant;
 124     if(_PtrObjet){
 125       if(TServant* aServant = dynamic_cast<TServant*>(_PtrObjet)){
 126         //cerr << "DESTRUCTEUR_GENERIQUE_::operator() deleting ServantBase's _PtrObjet" << endl;
 127         PortableServer::POA_var aPOA = aServant->_default_POA();
 128         PortableServer::ObjectId_var anObjectId = aPOA->servant_to_id(aServant);
 129         aPOA->deactivate_object(anObjectId.in());
 130         aServant->_remove_ref();
 131       }else{
 132         //cerr << "DESTRUCTEUR_GENERIQUE_::operator() deleting _PtrObjet" << endl;
 133         TYPE* aPtr = static_cast<TYPE*>(_PtrObjet);
 134         delete aPtr;
 135       }
 136       _PtrObjet = NULL ;
 137     }
 138   }
 139
 140   virtual ~DESTRUCTEUR_DE_(){
 141     assert(!_PtrObjet) ;
 142   }
 143
 144 private :
 145   TYPE *_PtrObjet ;
 146 };
 147
 148
 149 # endif         /* # if !defined( __SINGLETON__H__ ) */