Back to index

salome-kernel  6.5.0
Utils_DESTRUCTEUR_GENERIQUE.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 //  SALOME Utils : general SALOME's definitions and tools
00024 //  File   : Utils_DESTRUCTEUR_GENERIQUE.cxx
00025 //  Author : Antoine YESSAYAN, EDF
00026 //  Module : SALOME
00027 //  $Header: /home/server/cvs/KERNEL/KERNEL_SRC/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.cxx,v 1.12.2.1.10.3.12.1 2012-04-12 14:05:32 vsr Exp $
00028 //
00029 # include <iostream>
00030 # include <list>
00031 extern "C"
00032 {
00033 # include <stdlib.h>
00034 }
00035 
00036 # include "Utils_DESTRUCTEUR_GENERIQUE.hxx"
00037 //# include "utilities.h"
00038 # include "LocalTraceBufferPool.hxx"
00039 void Nettoyage();
00040 
00041 #ifdef _DEBUG_
00042 // static int MYDEBUG = 0;
00043 #else
00044 // static int MYDEBUG = 0;
00045 #endif
00046 
00047 std::list<DESTRUCTEUR_GENERIQUE_*> *DESTRUCTEUR_GENERIQUE_::Destructeurs=0 ;
00048 
00060 //CCRT
00061 static bool ATEXIT_Done = false ;
00062 //CCRT
00063 
00064 class ATEXIT_
00065 {
00066 public :
00073         //CCRT  ATEXIT_( void )
00074         ATEXIT_( bool Make_ATEXIT )
00075         {
00076           //CCRT
00077           if ( Make_ATEXIT && !ATEXIT_Done ) {
00078             //CCRT
00079                 assert (DESTRUCTEUR_GENERIQUE_::Destructeurs==0);
00080                 //cerr << "ATEXIT_::ATEXIT_ Construction ATEXIT" << endl;// message necessaire pour utiliser logger dans Nettoyage (cf.BUG KERNEL4561)
00081                 DESTRUCTEUR_GENERIQUE_::Destructeurs = 
00082                       new std::list<DESTRUCTEUR_GENERIQUE_*> ; // Destructeur alloue dynamiquement (cf. ci-dessous) ,
00083                                                                    // il est utilise puis detruit par la fonction Nettoyage
00084                 //To be sure the trace singleton will be the last one to be destroyed initialize it here before calling atexit
00085                 LocalTraceBufferPool::instance();
00086 #ifndef _DEBUG_
00087                 atexit( Nettoyage );                      // execute Nettoyage lors de exit, aprs la destruction des donnees statiques !
00088 #else
00089                 int cr = atexit( Nettoyage );                      // execute Nettoyage lors de exit, aprs la destruction des donnees statiques !
00090                 assert(cr==0) ;
00091 #endif
00092                 ATEXIT_Done = true ;
00093           }
00094         }
00095 
00096         ~ATEXIT_( )
00097         {
00098           //cerr << "ATEXIT_::~ATEXIT_ Destruction ATEXIT" << endl;
00099         }
00100 };
00101 
00102 
00103 
00104 
00105 static ATEXIT_ nettoyage = ATEXIT_( false );    /* singleton statique */
00106 
00107 
00116 void Nettoyage( void )
00117 {
00118   //cerr << "Nettoyage()" << endl;
00119   //if(MYDEBUG) BEGIN_OF("Nettoyage( void )") ;
00120         assert(DESTRUCTEUR_GENERIQUE_::Destructeurs) ;
00121         //if(MYDEBUG) SCRUTE( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() ) ;
00122         if( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() )
00123         {
00124                 std::list<DESTRUCTEUR_GENERIQUE_*>::iterator it = DESTRUCTEUR_GENERIQUE_::Destructeurs->end() ;
00125 
00126                 do
00127                 {
00128                   //if(MYDEBUG) MESSAGE( "DESTRUCTION d'un SINGLETON");
00129                         it-- ;
00130                         DESTRUCTEUR_GENERIQUE_* ptr = *it ;
00131                         //DESTRUCTEUR_GENERIQUE_::Destructeurs->remove( *it ) ;
00132                         (*ptr)() ;
00133                         delete ptr ;
00134                 }while( it!=  DESTRUCTEUR_GENERIQUE_::Destructeurs->begin() ) ;
00135 
00136                 DESTRUCTEUR_GENERIQUE_::Destructeurs->clear() ;
00137                 //if(MYDEBUG) SCRUTE( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() ) ;
00138                 assert( DESTRUCTEUR_GENERIQUE_::Destructeurs->size()==0 ) ;
00139                 assert( DESTRUCTEUR_GENERIQUE_::Destructeurs->empty() ) ;
00140         }
00141 
00142         delete DESTRUCTEUR_GENERIQUE_::Destructeurs;
00143         DESTRUCTEUR_GENERIQUE_::Destructeurs=0;
00144         //if(MYDEBUG) END_OF("Nettoyage( void )") ;
00145         return ;
00146 }
00147 
00148 
00153 const int DESTRUCTEUR_GENERIQUE_::Ajout( DESTRUCTEUR_GENERIQUE_ &objet )
00154 {
00155         // N.B. : l'ordre de creation des SINGLETON etant important
00156         //        on n'utilise pas deux fois la meme position pour
00157         //        les stocker dans la pile des objets.
00158 
00159         //CCRT
00160         if ( !ATEXIT_Done ) {
00161           nettoyage = ATEXIT_( true ) ;
00162         }
00163         //CCRT
00164         assert(Destructeurs) ;
00165         Destructeurs->push_back( &objet ) ;
00166         return Destructeurs->size() ;
00167 }