acserrLegacy.h

Go to the documentation of this file.

#ifndef _acserr_Legacy_H_
#define _acserr_Legacy_H_
/*******************************************************************************
* ALMA - Atacama Large Millimiter Array
* (c) European Southern Observatory, 2004 
*
*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
*
* "@(#) $Id: acserrLegacy.h,v 1.11 2007/05/14 14:12:32 bjeram Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* bjeram  2004-02-13  created
*/

/************************************************************************
 *
 *----------------------------------------------------------------------
 */

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include <logging.h>
#include <Thread_Manager.h> 
#include <sstream>
#include <acserrS.h>
#include <acscommonC.h>
#include <exception>

// for backward compatibilty reason
namespace ACSErr {
    const ErrorCode ACSErrOK = ACSErrOK;
};


#define DEFAULT_SEVERITY ACSErr::Error

#define ACS_ERROR_BEGIN(et, ec, ro) ACSError(__FILE__, __LINE__, et, ec, ro)

#define ACS_ERROR(arg...) ACSError(__FILE__, __LINE__ ,## arg)
//#define ACS_ERROR(pe, et, ec, ro) ACSError(__FILE__, __LINE__, pe, et, ec, ro, )
//#define ACS_ERROR_BEGIN(et, ec, ro) ACSError(__FILE__, __LINE__, et, ec, ro)
//#define ACS_NO_ERROR(ro) ACSError(__FILE__, __LINE__, ro)


#define ACS_NO_ERROR(ro) ACSError(__FILE__, __LINE__, ro)

#define ACS_EXCEPTION(arg...) ACSErr::ACSException( ACSError::createErrorTrace(__FILE__, __LINE__, arg) )
//#define ACS_EXCEPTION(eo) ACSErr::ACSException( eo.getErrorTrace() )

#define THROW_ACS_EXCEPTION(arg...) ACE_THROW ( ACS_EXCEPTION(arg) )
                                                
#define THROW_ACS_EXCEPTION_EX(lab, arg...) ACE_THROW_EX ( ACS_EXCEPTION(arg), lab )

#define RETHROW_ACS_EXCEPTION(arg...) ACE_TRY_THROW ( ACS_EXCEPTION(arg) )

#define RETHROW_ACS_EXCEPTION_EX(lab, arg...) ACE_TRY_THROW_EX ( ACS_EXCEPTION(arg), lab )

class ACSError {
public:

  ACSError (); 

    ACSError (const char* file, int line); // = ACSError()

  ACSError (const char* file, int line, const char* routine);

  ACSError (const ACSErr::ErrorTrace& errortrace);

  ACSError (ACSErr::ErrorTrace& errortrace);

  ACSError (const char* file, int line, ACSErr::ErrorTrace* errortrace, bool release=1);

  ACSError (ACSErr::ErrorTrace* errortrace, bool release=1);

  ACSError (const char* file, int line, ACSErr::ACSErrType et, ACSErr::ErrorCode ec, 
            const char* routine, ACSErr::Severity severity=DEFAULT_SEVERITY);

    ACSError (const char* file, int line, ACSError &err, ACSErr::ACSErrType et, ACSErr::ErrorCode ec, 
              const char *routine, ACSErr::Severity severity=DEFAULT_SEVERITY);

  ACSError (const char* file, int line, ACSError *err, ACSErr::ACSErrType et, ACSErr::ErrorCode ec, 
            const char *routine, ACSErr::Severity severity=DEFAULT_SEVERITY, bool release=1);
  ACSError (ACSErr::ACSException& exception);

  ACSError (const char* file, int line, ACSErr::ACSException &pex, ACSErr::ACSErrType et,
            ACSErr::ErrorCode ec, const char *routine,
            ACSErr::Severity severity=DEFAULT_SEVERITY);

  ACSError (const char* file, int line, ACSErr::ErrorTrace &pc, ACSErr::ACSErrType et,
            ACSErr::ErrorCode ec, const char *routine,
            ACSErr::Severity severity=DEFAULT_SEVERITY);

  ~ACSError();
  
   ACSErr::ErrorTrace& getErrorTrace(){ return *current; } // should check if stack is empty
 
  ACSErr::ErrorTrace* returnErrorTrace (bool deletion=true);
  
  ACSErr::ErrorTrace *getNext();
  
  ACSErr::ErrorTrace *top(){ current = &errorTrace; return current;}

  void log();

  bool isOK(){ return (current->errorCode==ACSErrOK && current->errorType==ACSErrTypeOK); }

  void addData (const char* name, const char* value);
    
  template<class T>
  void addData (const char* name, T value){
      const char *s;
      std::ostringstream ostr;
      ostr << value << std::ends;
      std::string ts=ostr.str(); // we have to make a temporary string otherwise there is problem with memory:  s = ostr.str().c_str(); does not work
      s = ts.c_str();
      addData (name, s);
  }

  char* getDescription();

  static char* getDescription (ACSErr::ACSErrType et, ACSErr::ErrorCode ec);

  char* getFileName(){ return CORBA::string_dup(current->file); }

  CORBA::ULong getLineNumber(){ return current->lineNum; }

  char* getRoutine(){ return CORBA::string_dup (current->routine); }

  char* getHostName(){ return CORBA::string_dup (current->host); }

  char* getProcess(){ return CORBA::string_dup (current->process); }

  char* getThread(){ return CORBA::string_dup (current->thread); }

  CORBA::ULongLong getTimeStamp (){ return current->timeStamp; }

    ACSErr::ErrorCode getErrorCode(){ return current->errorCode; }
//      CORBA::Long t; current->error >>= t; return t; }

    ACSErr::ACSErrType getErrorType(){ return current->errorType; }

  ACSErr::Severity getSeverity() { return current->severity; }

  unsigned int getDepth(){ return depth; }

 void setTimeStamp (CORBA::ULongLong time){ current->timeStamp = time; }

  void setFileName(const char* fn){ current->file = CORBA::string_dup (fn); }

  void setLineNumber (CORBA::ULong ln){ current->lineNum = ln; }//? should we delete previos one

  void setError (ACSErr::ACSErrType ty, ACSErr::ErrorCode ec) 
        { current->errorType=ty; current->errorCode=ec; }

  void setSeverity(ACSErr::Severity severity) {current->severity = severity; }

  static void hostName (const char* hn);
  
    static void processName (const char *pn); 


  static void setProcessName (const char *pn); 


  static ACSErr::ErrorTrace createErrorTrace (const char* file, int line,
                                                    ACSError &er)
{
    ACE_UNUSED_ARG(file); 
    ACE_UNUSED_ARG(line); 
    return er.getErrorTrace(); 
}

  static ACSErr::ErrorTrace createErrorTrace (const char* file, int line, 
                                                     ACSErr::ACSException &pex, ACSErr::ACSErrType et,
                                                     ACSErr::ErrorCode ec, const char *routine,
                                                     ACSErr::Severity severity=DEFAULT_SEVERITY);

  static ACSErr::ErrorTrace createErrorTrace (const char* file, int line, 
                                                     ACSErr::ACSErrType et, ACSErr::ErrorCode ec,\
                                                     const char *routine,
                                                     ACSErr::Severity severity=DEFAULT_SEVERITY); 

    static bool init (int argc, char *argv[]);
    static bool init (CORBA::ORB_ptr _orb);
    static bool init ();
    static bool isInit(){ return initialized; }
    static void done();

protected:
    static bool initialized;
    
    static bool initLog (CORBA::ORB_ptr _orb);
  void log (ACSErr::ErrorTrace *c, int level);

  void fill (ACSErr::ACSErrType et, ACSErr::ErrorCode ec, ACSErr::Severity severity, 
             const char* file, int line, const char* routine);

    ACS::Time getTime();

  
  ACSErr::ErrorTrace errorTrace, *current;
  unsigned int depth;

  static CORBA::ORB_var orb;

  static std::unexpected_handler  m_oldUnexpected;
  static std::terminate_handler  m_oldTerminate;

  static const ACSErr::ACSErrType ACSErrTypeOK;   // this constant is redefined here otherwise we depend on code generated from ACSErrTypeOK
 static const ACSErr::ErrorCode ACSErrOK; // this constant is redefined here otherwise we depend on code generated from ACSErrTypeOK

};//class ACSError

#endif