acserr.h

Go to the documentation of this file.

#ifndef _ACSERR__H_
#define _ACSERR__H_
/*******************************************************************************
*    ALMA - Atacama Large Millimiter Array
*    (c) European Southern Observatory, 2002
*    Copyright by ESO (in the framework of the ALMA collaboration)
*    and Cosylab 2002, All rights reserved
*
*    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: acserr.h,v 1.81 2010/05/31 09:36:51 bjeram Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* almamgr 2004-03-02 added last() to ErrorTraceHelper
* almamgr 2004-03-02 added isErrorFree, log and getErrorTraceHelper to CompletionImpl
* bjeram 2003-07-07 added std:: prefix (gcc 3.2.x)
* bjeram 2003-03-06 added strstream #include
1* bjeram 2003-03-06 added ACSErr prefix to types defined in the idl files
* bjeram 2002-06-05 added setTimeStamp
* bjeram 2002-06-05 added ACSError (const char* file, int line, ACSError &err, ACSErrType et, ACSErr::ErrorCode ec, const char *routine, ACSErr::Severity severity);
* bjeram 2002-06-04 moved getDescription(type, code) to public and made it static
* bjeram 2002-06-04 fixed ML in addData<T>
* bjeram 2002-02-13 added ACSError() and ACS_ERROR() for creating no-error object w/o runtime and source info
* bjeram 2001-10-18 overloaded ACS_EXCEPTION and (RE)THROW_ACS_EXCEPTIONS(_EX) macros
* bjeram 2001-10-18 added RETHROW_ACS_EXCEPTION_EX
* bjeram 2001-10-18 added  THROW_ACS_EXCEPTION_EX
* bjeram 2001-10-18 overloaded ACS_ERROR macro
* almamgr  20/06/01  created
*/

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


#include "acserrLegacy.h"
#include <sstream>

// forward declaration
class ACSLogImpl;

namespace ACSErr
{

class ErrorTraceHelper
{
  protected:
    friend class CompletionImpl;
    friend class ::ACSLogImpl;
    friend class ::ACSError;

    ErrorTraceHelper(ACSErr::ErrorTrace &et);

// for OK cases and wrapping error completion
     void setErrorTrace(ACSErr::ErrorTrace &et, int depth);

// default constructor (OK completion)
    ErrorTraceHelper()
        : m_errorTracePtr(0), m_current(0), m_depth(0)
        {}

// create new error trace
    ErrorTraceHelper (ACSErr::ACSErrType et, ACSErr::ErrorCode ec,
                      const char* file, int line, const char* routine, const char* sd,
                      ACSErr::Severity severity,
                      ACSErr::ErrorTrace &errortrace);

// adding previos error trace
    ErrorTraceHelper (const ACSErr::ErrorTrace &pet,
                      ACSErr::ACSErrType et, ACSErr::ErrorCode ec,
                      const char* file, int line, const char* routine, const char* sd, 
                      ACSErr::Severity severity,
                      ACSErr::ErrorTrace &errortrace);

    ErrorTraceHelper& operator=(ACSErr::ErrorTrace& eth);

  public:


    void log(ACE_Log_Priority priorty=LM_ERROR);

    std::string toString();

    void addData (const char* name, const char* value);
    
    void addData (const char* name, char* value)
        {
            addData (name, (const char*)value);
        }//addData

    template<typename 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);
        }//addData

    void setMemberValue (const char* name, const char* value);

    void setMemberValue (const char* name, ACE_CString &value);

    template<typename T>
    void setMemberValue (const char* name, T value)
        { 
            const char *s;
            if (name==NULL) return;

            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 = ts.c_str();
            setMemberValue (name, s);
        }//setMemberValue

    ACE_CString getData (const char* name);

    void getMemberValue(const char* name, char*& value)
        {
            value = CORBA::string_dup(getData(name).c_str());
        }
    
    template<typename T>
    void getMemberValue (const char* name, T &value)
        {
            std::istringstream istr(getData(name).c_str());
            istr >> value;
        }//getMemberValue

    template<typename T>
    T getMemberValue (const char* name);

    char* getDescription();

    char* getShortDescription();

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

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

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

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

  char* getProcessName(){ return CORBA::string_dup (m_current->process); }

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

  char* getSourceObject(){ return CORBA::string_dup (m_current->sourceObject); }
  CORBA::ULongLong getTimeStamp (){ return m_current->timeStamp; }

    ACSErr::ErrorCode getErrorCode(){ return m_current->errorCode; }

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

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

  unsigned int getDepth(){ return m_depth; }

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

  void setSourceObject(const char* so){ m_current->sourceObject = CORBA::string_dup (so); }

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

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

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

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

  static void setHostName (const char* hn);
  
  static void setProcessName (const char *pn); 

  ACSErr::ErrorTrace *getNext();

    bool last() { return (m_depth==0 || m_current->previousError.length()==0); }
  
  ACSErr::ErrorTrace *top(){ m_current = m_errorTracePtr; return m_current;}

    ACSErr::ErrorTrace& getErrorTrace(){ return *m_current; } // should check if stack is empty
    
    static ACS::Time getTime();
    
    ErrorTraceHelper*  getErrorTraceHelper() { return this; }

  protected:

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

    void log (ACSErr::ErrorTrace * c,
              int level, char *stackId,
              ACE_Log_Priority priorty=LM_ERROR);

    void toString (ACSErr::ErrorTrace * c, int level, std::ostringstream& oss);

    ACSErr::ErrorTrace *m_errorTracePtr;
//& m_errorTraceRef;
    ACSErr::ErrorTrace *m_current;
    unsigned int m_depth;
    
    static char m_hostName[64];
    static char m_processName[64];
    static const unsigned int m_maxDepth;
};

/*******************************************************************************************/
class CompletionInit : public ACSErr::Completion
{
  public:
    CompletionInit(const ACSErr::Completion &c);

    CompletionInit(ACSErr::CompletionType t, ACSErr::CompletionCode c, bool initTrace=true);
    
    ACSErr::CompletionCode getCode(){ return code; }

    ACSErr::CompletionType getType(){ return type; }

  CORBA::ULongLong getTimeStamp (){ return timeStamp; }
};




/**************************************************************************************/
class CompletionImpl : public CompletionInit 
{
  public:
// default constructor
    CompletionImpl();

    CompletionImpl (ACSErr::ACSErrType t, ACSErr::ErrorCode c) :
        CompletionInit(t, c, false)/*,
        m_errorTraceHelper(previousError[0], previousError.length())
*/
        {
        }

    CompletionImpl (ACSErr::ACSErrType t, ACSErr::ErrorCode c,
                      const char* file, int line, const char* routine, const char* sd,
                      ACSErr::Severity severity) : 
        CompletionInit(t, c),
        m_errorTraceHelper(t, c, file, line, routine, sd, severity, previousError[0])
        {}

// adding previous (remote or local) with reference 
    CompletionImpl (const ACSErr::Completion &pc, ACSErr::ACSErrType t, ACSErr::ErrorCode c,
                      const char* file, int line, const char* routine, const char* sd,
                      ACSErr::Severity severity) :
        CompletionInit(t, c),
        m_errorTraceHelper(pc.previousError[0], t, c, file, line, routine, sd, severity, previousError[0])
        {}
// adding previous remote completion as pointer
    CompletionImpl (ACSErr::Completion *pc, ACSErr::ACSErrType t, ACSErr::ErrorCode c,
                      const char* file, int line, const char* routine, const char* sd,
                      ACSErr::Severity severity) :
        CompletionInit(t, c),
        m_errorTraceHelper(pc->previousError[0], t, c, file, line, routine, sd, severity, previousError[0])
        { delete pc; }

// adding previous completion as pointer
    CompletionImpl (CompletionImpl *pc, ACSErr::ACSErrType t, ACSErr::ErrorCode c,
                      const char* file, int line, const char* routine, const char* sd,
                      ACSErr::Severity severity) :
        CompletionInit(t, c),
        m_errorTraceHelper(pc->previousError[0], t, c, file, line, routine, sd, severity, previousError[0])
        { delete pc; }

// adding error trace
    CompletionImpl (const ACSErr::ErrorTrace &et, ACSErr::ACSErrType t, ACSErr::ErrorCode c,
                      const char* file, int line, const char* routine, const char* sd,
                      ACSErr::Severity severity) :
        CompletionInit(t, c),
        m_errorTraceHelper(et, t, c, file, line, routine, sd, severity, previousError[0])
        {}

//wrapping remote (CORBA) Completion
    CompletionImpl(ACSErr::Completion* c, bool del=true);

    CompletionImpl(ACSErr::Completion_var& c);

    CompletionImpl (const ACSErr::Completion &c);

    CompletionImpl (const CompletionImpl &c);

    virtual ~CompletionImpl(){}
    
    ACSErr::Completion* returnCompletion (bool deletion=true)
        {
            ACSErr::Completion *tmp = new ACSErr::Completion(*this);
            if (deletion) delete this;
            return tmp;
        }//returnCompletion

    ACSErr::Completion* outCompletion(bool del=false) { return this->returnCompletion(del); }

    bool isErrorFree(){ return (previousError.length() == 0); }

    ErrorTraceHelper*  getErrorTraceHelper(){ return (ErrorTraceHelper*)( (previousError.length() > 0) ? &m_errorTraceHelper : NULL); }
    
    void log(ACE_Log_Priority priorty=LM_ERROR);

    template<typename T>
    void addData (const char* name, T value)
        {
            if (!isErrorFree())
                {
                m_errorTraceHelper.addData(name, value);
                }
        }


    CompletionImpl& operator=(CompletionImpl&);

    CompletionImpl& operator=(Completion* c);

    CompletionImpl& operator=(Completion_var& c);



  protected:
    ErrorTraceHelper m_errorTraceHelper;
};//CompletionImpl

/*************************************************************************************/
//template implementation
//

// specialization for strings
template<>
char * ErrorTraceHelper::getMemberValue<char*> (const char* name);

template<>
ACE_CString ErrorTraceHelper::getMemberValue<ACE_CString> (const char* name);

template<typename T>
T ErrorTraceHelper::getMemberValue (const char* name)
{
    T value;
    std::istringstream istr(getData(name).c_str());
    istr >> value;
    return value;
}//getMemberValue

}

// these two lines are just for backward compatibility and should be removed
// ... with next release
typedef ACSErr::CompletionInit CompletionInit;
typedef ACSErr::CompletionImpl CompletionImpl;
typedef ACSErr::ErrorTraceHelper ErrorTraceHelper;

#endif