PR: remove explicit calls to Trace mecanism to avoid problems when trace classes...

diff --git a/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.cxx b/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.cxx
index d9448bc8219f2df0331893ddd9a3b588703ce9b7..9d910a323ab5f630b5f35e6d6b3ddddbf00b8fd1 100644 (file)
--- a/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.cxx
+++ b/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.cxx
@@ -35,7 +35,7 @@ extern "C"
 }
 
 # include "Utils_DESTRUCTEUR_GENERIQUE.hxx"
-# include "utilities.h"
+//# include "utilities.h"
 void Nettoyage();
 
 #ifdef _DEBUG_
@@ -78,20 +78,20 @@ public :
          //CCRT
          if ( Make_ATEXIT && !ATEXIT_Done ) {
            //CCRT
-               ASSERT (DESTRUCTEUR_GENERIQUE_::Destructeurs==0);
-               if(MYDEBUG) MESSAGE("Construction ATEXIT"); // message necessaire pour utiliser logger dans Nettoyage (cf.BUG KERNEL4561)
+               assert (DESTRUCTEUR_GENERIQUE_::Destructeurs==0);
+               cerr << "ATEXIT_::ATEXIT_ Construction ATEXIT" << endl;// message necessaire pour utiliser logger dans Nettoyage (cf.BUG KERNEL4561)
                DESTRUCTEUR_GENERIQUE_::Destructeurs = 
                       new std::list<DESTRUCTEUR_GENERIQUE_*> ; // Destructeur alloue dynamiquement (cf. ci-dessous) ,
                                                                   // il est utilise puis detruit par la fonction Nettoyage
                int cr = atexit( Nettoyage );                      // execute Nettoyage lors de exit, aprs la destruction des donnees statiques !
-               ASSERT(cr==0) ;
+               assert(cr==0) ;
                ATEXIT_Done = true ;
          }
        }
 
        ~ATEXIT_( )
        {
-               if(MYDEBUG) MESSAGE("Destruction ATEXIT") ;
+         cerr << "ATEXIT_::~ATEXIT_ Destruction ATEXIT" << endl;
        }
 };
 
@@ -111,16 +111,17 @@ static ATEXIT_ nettoyage = ATEXIT_( false );      /* singleton statique */
 
 void Nettoyage( void )
 {
-       if(MYDEBUG) BEGIN_OF("Nettoyage( void )") ;
-       ASSERT(DESTRUCTEUR_GENERIQUE_::Destructeurs) ;
-       if(MYDEBUG) SCRUTE( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() ) ;
+  cerr << "Nettoyage()" << endl;
+  //if(MYDEBUG) BEGIN_OF("Nettoyage( void )") ;
+       assert(DESTRUCTEUR_GENERIQUE_::Destructeurs) ;
+       //if(MYDEBUG) SCRUTE( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() ) ;
        if( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() )
        {
                std::list<DESTRUCTEUR_GENERIQUE_*>::iterator it = DESTRUCTEUR_GENERIQUE_::Destructeurs->end() ;
 
                do
                {
-                       if(MYDEBUG) MESSAGE( "DESTRUCTION d'un SINGLETON");
+                 //if(MYDEBUG) MESSAGE( "DESTRUCTION d'un SINGLETON");
                        it-- ;
                        DESTRUCTEUR_GENERIQUE_* ptr = *it ;
                        //DESTRUCTEUR_GENERIQUE_::Destructeurs->remove( *it ) ;
@@ -129,14 +130,14 @@ void Nettoyage( void )
                }while( it!=  DESTRUCTEUR_GENERIQUE_::Destructeurs->begin() ) ;
 
                DESTRUCTEUR_GENERIQUE_::Destructeurs->clear() ;
-               if(MYDEBUG) SCRUTE( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() ) ;
-               ASSERT( DESTRUCTEUR_GENERIQUE_::Destructeurs->size()==0 ) ;
-               ASSERT( DESTRUCTEUR_GENERIQUE_::Destructeurs->empty() ) ;
+               //if(MYDEBUG) SCRUTE( DESTRUCTEUR_GENERIQUE_::Destructeurs->size() ) ;
+               assert( DESTRUCTEUR_GENERIQUE_::Destructeurs->size()==0 ) ;
+               assert( DESTRUCTEUR_GENERIQUE_::Destructeurs->empty() ) ;
        }
 
        delete DESTRUCTEUR_GENERIQUE_::Destructeurs;
        DESTRUCTEUR_GENERIQUE_::Destructeurs=0;
-       if(MYDEBUG) END_OF("Nettoyage( void )") ;
+       //if(MYDEBUG) END_OF("Nettoyage( void )") ;
        return ;
 }
 
@@ -156,7 +157,7 @@ const int DESTRUCTEUR_GENERIQUE_::Ajout( DESTRUCTEUR_GENERIQUE_ &objet )
           nettoyage = ATEXIT_( true ) ;
        }
        //CCRT
-       ASSERT(Destructeurs) ;
+       assert(Destructeurs) ;
        Destructeurs->push_back( &objet ) ;
        return Destructeurs->size() ;
 }

diff --git a/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.hxx b/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.hxx
index 6e8798311fbec95638648a6f88473e54fac51066..4f97236a6016ef6381c657be77a9ab6ab33c9ca9 100644 (file)
--- a/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.hxx
+++ b/src/Utils/Utils_DESTRUCTEUR_GENERIQUE.hxx
@@ -30,8 +30,9 @@
 # define __DESTRUCTEUR_GENERIQUE__H__
 
 # include <list>
+#include <cassert>
 # include <CORBA.h>
-# include "utilities.h"
+//# include "utilities.h"
 
 /*!\class DESTRUCTEUR_GENERIQUE_
  *
@@ -111,7 +112,7 @@ public :
   DESTRUCTEUR_DE_(TYPE &objet):
     _PtrObjet( &objet )
   {
-    ASSERT(DESTRUCTEUR_GENERIQUE_::Ajout( *this ) >= 0) ;
+    assert(DESTRUCTEUR_GENERIQUE_::Ajout( *this ) >= 0) ;
   }
 
   /* Performs the destruction of the object.
@@ -122,13 +123,13 @@ public :
     typedef PortableServer::ServantBase TServant;
     if(_PtrObjet){
       if(TServant* aServant = dynamic_cast<TServant*>(_PtrObjet)){
-       //MESSAGE("deleting ServantBase's _PtrObjet");
+       cerr << "DESTRUCTEUR_GENERIQUE_::operator() deleting ServantBase's _PtrObjet" << endl;
        PortableServer::POA_var aPOA = aServant->_default_POA();
        PortableServer::ObjectId_var anObjectId = aPOA->servant_to_id(aServant);
        aPOA->deactivate_object(anObjectId.in());
        aServant->_remove_ref();
       }else{
-       //MESSAGE("deleting _PtrObjet");
+       cerr << "DESTRUCTEUR_GENERIQUE_::operator() deleting _PtrObjet" << endl;
        TYPE* aPtr = static_cast<TYPE*>(_PtrObjet);
        delete aPtr;
       }
@@ -137,7 +138,7 @@ public :
   } 
 
   virtual ~DESTRUCTEUR_DE_(){
-    ASSERT(!_PtrObjet) ;
+    assert(!_PtrObjet) ;
   }
 
 private :

diff --git a/src/Utils/Utils_ORB_INIT.cxx b/src/Utils/Utils_ORB_INIT.cxx
index bc5a7c37c571b43998a0ce5225a5db2ed825bed0..cb8874845312079f4818b4d3125ea16d769bf508 100644 (file)
--- a/src/Utils/Utils_ORB_INIT.cxx
+++ b/src/Utils/Utils_ORB_INIT.cxx
@@ -40,9 +40,9 @@ ORB_INIT::~ORB_INIT()
 {
   if ( ! CORBA::is_nil( _orb ) )
   {
-    //MESSAGE("appel _orb->destroy()") ;
+    std::cerr << "appel _orb->destroy()" << std::endl;
     _orb->destroy() ;
-    //MESSAGE("retour _orb->destroy()") ;
+    std::cerr << "retour _orb->destroy()" << std::endl;
   }
 }
 

diff --git a/src/Utils/Utils_SINGLETON.hxx b/src/Utils/Utils_SINGLETON.hxx
index 4447b3de7aed14954917fc5252de4da0688c09e1..8921e17b7449e28e971712a30d5511e2ae037aaf 100644 (file)
--- a/src/Utils/Utils_SINGLETON.hxx
+++ b/src/Utils/Utils_SINGLETON.hxx
@@ -140,10 +140,10 @@ template <class TYPE> SINGLETON_<TYPE>::SINGLETON_( void )
 template <class TYPE> int SINGLETON_<TYPE>::Destruction( void )
 {
        int k = - 1 ;
-       BEGIN_OF("SINGLETON_<TYPE>::Destruction( void )") ;
+       //BEGIN_OF("SINGLETON_<TYPE>::Destruction( void )") ;
        if ( PtrSingleton )
        {
-               MESSAGE("Destruction du SINGLETON_") ;
+         //MESSAGE("Destruction du SINGLETON_") ;
 
 
                std::list<DESTRUCTEUR_GENERIQUE_ *>::iterator k ;
@@ -158,14 +158,14 @@ template <class TYPE> int SINGLETON_<TYPE>::Destruction( void )
                delete PtrSingleton ;
                PtrSingleton = NULL ;
        }
-       END_OF("SINGLETON_<TYPE>::Destruction( void )") ;
+       //END_OF("SINGLETON_<TYPE>::Destruction( void )") ;
        return k ;
 }
 
 
 template <class TYPE> SINGLETON_<TYPE>::~SINGLETON_()
 {
-       MESSAGE("passage dans SINGLETON_<TYPE>::~SINGLETON_( void )") ;
+  //MESSAGE("passage dans SINGLETON_<TYPE>::~SINGLETON_( void )") ;
 }
 
 # endif                /* # if !defined( __SINGLETON__H__ ) */