src/Utils/Utils_DESTRUCTEUR_GENERIQUE.cxx

   1 using namespace std;
   2 //=============================================================================
   3 // File      : Utils_DESTRUCTEUR_GENERIQUE.cxx
   4 // Created   : lun nov  5 16:04:47 CET 2001
   5 // Author    : Antoine YESSAYAN, EDF
   6 // Project   : SALOME
   7 // Copyright : EDF 2001
   8 // $Header$
   9 //=============================================================================
  10
  11 using namespace std;
  12
  13 void Nettoyage( void ) ;
  14
  15 # include <iostream>
  16 # include "utilities.h"
  17 # include "Utils_DESTRUCTEUR_GENERIQUE.hxx"
  18 # include <list>
  19 extern "C"
  20 {
  21 # include <stdlib.h>
  22 }
  23
  24 static list<DESTRUCTEUR_GENERIQUE_*> *Destructeurs=0 ;
  25
  26
  27
  28
  29 /*! \class ATEXIT_
  30  *
  31  * Mécanisme pour faire exécuter une seule fois DESTRUCTEUR_GENERIQUE_::Nettoyage
  32  * à la fin du traitement : creation d'un singleton statique de l'objet
  33  * tres specialise ATEXIT_.
  34  *
  35  * La création d'un objet de type ATEXIT_ entraîne l'inscription de la fonction
  36  * Nettoyage() par atexit(). Il suffit donc de créer un singleton statique du type ATEXIT_
  37  * pour effectuer cet enregistrement une seule fois indépendament de l'utilisateur.
  38  */
  39
  40 class ATEXIT_
  41 {
  42 public :
  43         /*!
  44          * Allocation dynamique de Destructeurs, une liste chaînée de DESTRUCTEUR_GENERIQUE_* et enregistrement
  45          * de la fonction Nettoyage() par atexit().
  46          *
  47          * La liste chaînée Destructeurs est détruite dans la fonction Nettoyage.
  48          */
  49         ATEXIT_( void )
  50         {
  51                 ASSERT (Destructeurs==0);
  52                 Destructeurs = new list<DESTRUCTEUR_GENERIQUE_*> ; // Destructeurs alloué dynamiquement (cf. ci-dessous) ,
  53                                                                    // il est utilisé puis détruit par la fonction Nettoyage
  54                 int cr = atexit( Nettoyage );                      // exécute Nettoyage lors de exit, après la destruction des données statiques !
  55                 ASSERT(cr==0) ;
  56         }
  57
  58         ~ATEXIT_( )
  59         {
  60                 MESSAGE("Destruction ATEXIT") ;
  61         }
  62 };
  63
  64
  65
  66
  67 static ATEXIT_ nettoyage ;      /* singleton statique */
  68
  69
  70 /*!
  71  * traitement effectué :
  72  * -# exécution de tous les objets de type DESTRUCTEUR_DE_ stockés dans la liste Destructeurs (ce qui détruit les
  73  *    singletons correspondant) ;
  74  * -# puis destruction de tous les objets de type DESTRUCTEUR_DE_ stockés dans la liste Destructeurs;
  75  * -# destruction de la liste Destructeurs.
  76  */
  77
  78 void Nettoyage( void )
  79 {
  80         BEGIN_OF("Nettoyage( void )") ;
  81         ASSERT(Destructeurs) ;
  82         SCRUTE( Destructeurs->size() ) ;
  83         if( Destructeurs->size() )
  84         {
  85                 list<DESTRUCTEUR_GENERIQUE_*>::iterator it = Destructeurs->end() ;
  86
  87                 do
  88                 {
  89                         MESSAGE( "DESTRUCTION d'un SINGLETON") ;
  90                         it-- ;
  91                         DESTRUCTEUR_GENERIQUE_* ptr = *it ;
  92                         //Destructeurs->remove( *it ) ;
  93                         (*ptr)() ;
  94                         delete ptr ;
  95                 }while( it!=  Destructeurs->begin() ) ;
  96
  97                 Destructeurs->clear() ;
  98                 SCRUTE( Destructeurs->size() ) ;
  99                 ASSERT( Destructeurs->size()==0 ) ;
 100                 ASSERT( Destructeurs->empty() ) ;
 101         }
 102
 103         delete Destructeurs;
 104         Destructeurs=0;
 105         END_OF("Nettoyage( void )") ;
 106         return ;
 107 }
 108
 109
 110 /*!
 111  * Adds a destruction object to the list of actions to be performed at the end
 112  * of the process
 113  */
 114 const int DESTRUCTEUR_GENERIQUE_::Ajout( DESTRUCTEUR_GENERIQUE_ &objet )
 115 {
 116         // N.B. : l'ordre de creation des SINGLETON etant important
 117         //        on n'utilise pas deux fois la meme position pour
 118         //        les stocker dans la pile des objets.
 119         ASSERT(Destructeurs) ;
 120         Destructeurs->push_back( &objet ) ;
 121         return Destructeurs->size() ;
 122 }