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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  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 "utilities.h"
  33
  34 /*!\class DESTRUCTEUR_GENERIQUE_
  35  *
  36  * <B>Definition</B>
  37  *
  38  * The DESTRUCTEUR_GENERIQUE_ abstract class describes the comportement of any destruction object.
  39  * Tis type is used to create a list of miscellaneous destruction object.
  40  *
  41  * <B>Usage</B>
  42  *
  43  * The only way to use the DESTRUCTEUR_GENERIQUE_ class is inheritance :
  44  *      class DESTRUCTEUR_SPECIFIQUE_ : public DESTRUCTEUR_GENERIQUE_
  45  *
  46  * <B>Design description</B>
  47  *
  48  *      A generic destructor supply two functionalities :
  49  *      -# a static method to add a destruction (objetct) to be performed DESTRUCTEUR_GENERIQUE_::Ajout(
  50  *      DESTRUCTEUR_GENERIQUE_ &objet) ;
  51  *         The Destruction object is stored in a list of pointer to DESTRUCTEUR_GENERIQUE_ objects.
  52  *      -# an object method to execute the destruction : operator()().
  53  */
  54
  55 class DESTRUCTEUR_GENERIQUE_
  56 {
  57 public :
  58         virtual ~DESTRUCTEUR_GENERIQUE_() {}//!< virtual destructor
  59         static const int Ajout( DESTRUCTEUR_GENERIQUE_ &objet );//!< adds a destruction object to the list of destructions
  60         virtual void operator()( void )=0 ;//!< performs the destruction
  61 } ;
  62
  63
  64
  65
  66
  67
  68 /*!\class DESTRUCTEUR_DE_
  69  *
  70  * <B>Purpose</B>
  71  *
  72  * The DESTRUCTEUR_DE_ class allows the user to program - at any moment - the destruction of an object
  73  * at the end of the process.
  74  *
  75  * <B>Usage</B>
  76  *
  77  *      In this example the POINT_ ptrPoint will be destroyed at the end of the process (atexit).
  78  *
  79  *      POINT_ *ptrPoint = new POINT_ ;<BR>
  80  *      DESTRUCTEUR_DE_<POINT_> *ptrDestruction = new DESTRUCTEUR_DE_<POINT_>( *ptrPoint ) ;
  81  *
  82  *      Note that neither ptrPoint, nor ptrDestruction should be destroyed by the user.
  83  *
  84  * <B>Design description</B>
  85  *
  86  *      The destruction object must be created dynamicaly because it suscribes himself in the list of
  87  *      destruction to be performed at the end of the process.
  88  *
  89  */
  90
  91 template <class TYPE> class DESTRUCTEUR_DE_ : public DESTRUCTEUR_GENERIQUE_
  92 {
  93 public :
  94
  95         inline DESTRUCTEUR_DE_( TYPE &objet ); //! programs the destruction at the end of the process, of the object objet
  96         virtual void operator()( void ) ; //!< performs the destruction of the object
  97         virtual ~DESTRUCTEUR_DE_() ;
  98 private :
  99         const TYPE *_PtrObjet ;
 100 } ;
 101
 102
 103
 104
 105
 106
 107 /*!
 108 This method records in _PtrObjet the address of an object to be destroyed at the end of the process
 109 */
 110 template <class TYPE> DESTRUCTEUR_DE_<TYPE>::DESTRUCTEUR_DE_( TYPE &objet ): _PtrObjet( &objet )
 111 {
 112         int k = DESTRUCTEUR_GENERIQUE_::Ajout( *this ) ;
 113         ASSERT(k>=0) ;
 114 }
 115
 116 template <class TYPE> DESTRUCTEUR_DE_<TYPE>::~DESTRUCTEUR_DE_()
 117 {
 118         ASSERT(_PtrObjet==NULL) ;
 119 }
 120
 121 /*!
 122 This method really destroys the object pointed by _PtrObjet. It should be called at the end of the process
 123 (i.e. at exit).
 124 */
 125 template <class TYPE> void DESTRUCTEUR_DE_<TYPE>::operator()( void )
 126 {
 127         if ( _PtrObjet )
 128         {
 129                   MESSAGE("deleting _PtrObjet") ;
 130                 delete (TYPE*)_PtrObjet ;
 131                 _PtrObjet = NULL ;
 132         }
 133 }
 134
 135 # endif         /* # if !defined( __SINGLETON__H__ ) */