ColCOWS_Debug.hh

//===========================================================================//
//    
//    Description: Debug output Management
//    Filename: colcows/ColCOWS_Debug.hh
//    Authors: Michael Dussere and Aurélien Esnard
//    
//===========================================================================//
//    
//    Copyright (C) 2003 INRIA and CNRS
//    
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//    
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//    
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//    
//===========================================================================//


#ifndef __COLCOWS_DEBUG_HH__
#define __COLCOWS_DEBUG_HH__

//---------------------------------------------------------------------------//
#include "ColCOWS_Include.hh"
//---------------------------------------------------------------------------//

namespace ColCOWS {
  struct CorbaException;
}

__COLCOWS_BEGIN__

extern bool _DebugInitialized;
extern int  _DebugTraceLevel;


//------------------------------------------------------------------------
// Debug Mode
// 
// Le principe du level de debug est de renvoyer des sorties de manière 
// conditionnée suivant le niveau choisi par l'utilisateur.
//
//------------------------------------------------------------------------

//! debug level
enum DebugLevel {   
  dbl0           = 0,
  dblForce       = 0,
  dblError       = 0,
  dbl1           = 1,
  dblException   = 1,
  dblCritical    = 1,
  dbl2           = 2,
  dblWarning     = 2,
  dblMajor       = 2,
  dbl3           = 3,
  dblCall        = 3,
  dblSecondary   = 3,
  dblHead        = 3,
  dblIn          = 3,
  dblOut         = 3,
  dbl4           = 4,
  dblAccessory   = 4,
  dblHeadDetail  = 4,
  dblTail        = 4,
  dblCallDone    = 4,
  dbl5           = 5,
  dblCallDetail  = 5,
  dbl6           = 6,
  dbl7           = 7,
  dbl8           = 8,
  dblTrace       = 8,
  dbl9           = 9,
  dblInternal    = 9,
  dbl10          = 10,
  dblTest        = 10
};

#define  COLCOWS_DEBUG_LEVEL_VARIABLE   "COLCOWS_DEBUG_LEVEL"
#define  COLCOWS_DEBUG_LEVEL_DEFAULT    3

#define COLCOWS_DEBUG_LOCATION "(" <<__FILE__ << ":" << __LINE__ << ") "
#define COLCOWS_DEBUG_SPACE "\t\t"

#ifdef COLCOWS_NO_DEBUG
#define COLCOWS_DEBUG(l,x)   ( false )
#define COLCOWS_IN_DEBUG()   ( false )
#define COLCOWS_OUT_DEBUG()  ( false )
#else
#define COLCOWS_DEBUG(l,x)   ((_DebugTraceLevel >= l     ) && \
                          (std::cerr << x                  << COLCOWS_DEBUG_SPACE << COLCOWS_DEBUG_LOCATION << std::endl))
#define COLCOWS_IN_DEBUG()   ((_DebugTraceLevel >= dblIn ) && \
                          (std::cerr << "==> " << __func__ << COLCOWS_DEBUG_SPACE << COLCOWS_DEBUG_LOCATION << std::endl))
#define COLCOWS_OUT_DEBUG()  ((_DebugTraceLevel >= dblOut) && \
                          (std::cerr << "<== " << __func__ << COLCOWS_DEBUG_SPACE << COLCOWS_DEBUG_LOCATION << std::endl))
#endif

#define COLCOWS_TRACE_LOCATION ""
#define COLCOWS_TRACE_SPACE ""
#define COLCOWS_TRACE(x)   (std::cout << x << COLCOWS_TRACE_SPACE << COLCOWS_TRACE_LOCATION << std::endl)

//------------------------------------------------------------------------
// ColCOWS Exception 
//------------------------------------------------------------------------

//! names associated with ColCOWSExceptionKind
extern char * ColCOWSExceptionKindName[];

//! kind of exceptions thrown by EPSN
enum ColCOWSExceptionKind { cstGenericalException, 
                            cstCorbaException,
                            cstNotReadyException,
                            cstBadAssertException
};

//    Generical,
//    ActivationFailure,
//    DeactivationFailure,
//    ConnectiontionFailure,
//    AlreadyActivated,
//    NotActivated,
//    ActivationTimeout,
//    AlreadyConnected, 
//    NotConnected,
//    NotReady,
//    BadAssert


//! exceptions thrown by COLCOWS
class ColCOWSException {
  friend std::ostream& operator <<(std::ostream& stream, const ColCOWSException& e);

public:

  //! full constructor
  ColCOWSException(ColCOWSExceptionKind kind, const char* info, const char* file, long int line) :
    _kind(kind), _info(info), _file(file), _line(line) { }

  //! full constructor
  ColCOWSException(ColCOWSExceptionKind kind, const std::string & info, const std::string & file, long int line) :
    _kind(kind), _info(info), _file(file), _line(line) { }

  //! destructor
  virtual ~ColCOWSException(){}

  //! CorbaException converter constructor
  ColCOWSException( CorbaException & e );

  //! forward as CorbaException
  void forwardCorbaException();

private:

  //! exception kind
  ColCOWSExceptionKind _kind;

  //! exception description and additionals
  std::string       _info;

  //! file it is thrown from
  std::string       _file;

  //! ligne it is thrown from
  long int          _line;

};


//------------------------------------------------------------------------
// Error & Assert
//------------------------------------------------------------------------

#define THROW_CORBA_EXCEPTION( kind, info) do {                                                                           \
                                                COLCOWS_DEBUG(dblError, "Throw Corba exception : " << info );             \
                                                std::stringstream s_info;                                                 \
                                                s_info << info ;                                                          \
                                                CorbaException ex( (int)kind, s_info.str().c_str(), __FILE__, __LINE__ ); \
                                                throw ex;                                                                 \
                                              } while(0)

#define COLCOWS_ERROR(info) do {                                                                                       \
                              COLCOWS_DEBUG(dblError, info );                                                          \
                              std::stringstream s_info;                                                                \
                              s_info << info ;                                                                         \
                              ColCOWSException ex(cstGenericalException, s_info.str(), __FILE__, __LINE__ );           \
                              throw ex;                                                                                \
                            } while(0)


#define COLCOWS_ASSERT(test, info) do {                                                                                \
                                     if (!(test)) {                                                                    \
                                        COLCOWS_DEBUG(dblError, info );                                                \
                                        std::stringstream s_info;                                                      \
                                        s_info << info ;                                                               \
                                        ColCOWSException ex(cstBadAssertException, s_info.str(), __FILE__, __LINE__ ); \
                                        throw ex;}                                                                     \
                                   } while(0)


#define __BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__  try {

#define __END_REDIRECT_ALL_EXCEPTIONS_TO_COLCOWS__        }                                                                       \
                                                    catch(ColCOWS::ColCOWSException & ex) {                                       \
                                                      COLCOWS_DEBUG(dblError,"ColCOWSException forwarded as CorbaException");     \
                                                      throw;                                                                      \
                                                    }                                                                             \
                                                    catch(ColCOWS::CorbaException & corba_ex) {                                   \
                                                      COLCOWS_DEBUG(dblError,"CorbaException forwarded");                         \
                                                      ColCOWSException ex(corba_ex);                                              \
                                                      throw ex;                                                                   \
                                                    }                                                                             \
                                                    catch(...) {                                                                  \
                                                      COLCOWS_DEBUG(dblError,"Unknown exception forwarded as CorbaException");    \
                                                      CorbaException corba_ex( (int)cstGenericalException,                        \
                                                                               "Unknown exception forwarded as CorbaException",   \
                                                                               __FILE__, __LINE__ );                              \
                                                      throw corba_ex;                                                             \
                                                    }


#define __BEGIN_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__  try {

#define __END_REDIRECT_ALL_EXCEPTIONS_TO_CORBA__        }                                                                         \
                                                    catch(ColCOWS::ColCOWSException & ex) {                                       \
                                                      COLCOWS_DEBUG(dblError,"ColCOWSException forwarded as CorbaException");     \
                                                      ex.forwardCorbaException();                                                \
                                                    }                                                                             \
                                                    catch(ColCOWS::CorbaException & corba_ex) {                                   \
                                                      COLCOWS_DEBUG(dblError,"CorbaException forwarded");                         \
                                                      throw;                                                                      \
                                                    }                                                                             \
                                                    catch(...) {                                                                  \
                                                      COLCOWS_DEBUG(dblError,"Unknown exception forwarded as CorbaException");    \
                                                      CorbaException corba_ex( (int)cstGenericalException,                        \
                                                                               "Unknown exception forwarded as CorbaException",   \
                                                                               __FILE__, __LINE__ );                              \
                                                      throw corba_ex;                                                             \
                                                    }


#define __BEGIN_REDIRECT_CORBA_EXCEPTIONS_TO_COLCOWS__  try {

#define __END_REDIRECT_CORBA_EXCEPTIONS_TO_COLCOWS__         }                                                                      \
                                                        catch(ColCOWS::CorbaException & corba_ex) {                                 \
                                                          COLCOWS_DEBUG(dblError,"CorbaException forwarded as ColCOWSException");   \
                                                          ColCOWSException ex(corba_ex);                                            \
                                                          throw ex;                                                                 \
                                                        }


//------------------------------------------------------------------------

bool InitDebug();

//------------------------------------------------------------------------

__COLCOWS_END__

#endif // __COLCOWS_DEBUG_HH__

---