StatusCode.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_STATUSCODE_H
#define GAUDIKERNEL_STATUSCODE_H

#include <ostream>

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/IssueSeverity.h"

#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
#include <memory>
#else
#include "boost/shared_ptr.hpp"
#endif

class IMessageSvc;
class IStatusCodeSvc;

class IgnoreError {};

class StatusCode {
public:
  enum {
    FAILURE = 0,
    SUCCESS = 1,
    RECOVERABLE = 2
  };

  StatusCode():
    d_code(SUCCESS), m_checked(false), m_severity() {}
  StatusCode( unsigned long code, const IssueSeverity& sev ):
    d_code(code),m_checked(false), m_severity() {
    try { // ensure that we do not throw even if we cannot copy the severity
#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) && ! defined(__GCCXML__)
      m_severity = std::make_shared<IssueSeverity>(sev);
#else
      m_severity = SeverityPtr(new IssueSeverity(sev));
#endif
    }
    catch (...) {}
  }
  StatusCode( unsigned long code, bool checked = false ):
    d_code(code),m_checked(checked), m_severity() {}

  StatusCode( const StatusCode& rhs ):
    d_code(rhs.d_code), m_checked(rhs.m_checked),
    m_severity(rhs.m_severity)
    { rhs.m_checked = true; }

#ifndef __GCCXML__
  StatusCode( StatusCode&& rhs ):
    d_code(rhs.d_code), m_checked(rhs.m_checked),
    m_severity( std::move(rhs.m_severity) )
  { rhs.m_checked = true; }
#endif

  ~StatusCode()
  { if (UNLIKELY(s_checking)) check(); }

  bool isSuccess() const {
    m_checked = true;
    return (d_code == SUCCESS);
  }

  bool isFailure() const { return !isSuccess(); }
  bool isRecoverable() const {
    m_checked = true;
    return (d_code == RECOVERABLE);
  }

  unsigned long getCode() const{
    m_checked = true;
    return d_code;
  }

  void setCode(unsigned long value)  {
    m_checked = false;
    d_code = value;
  }

  void setChecked() const{
    m_checked = true;
  }
  void ignore() const { setChecked(); }

  operator unsigned long() const { return getCode(); }

  GAUDI_API const IssueSeverity& severity() const;

  StatusCode& operator=(unsigned long value) {
    setCode(value);
    return *this;
  }
  StatusCode& operator=(const StatusCode& rhs){
    if (this == &rhs) return *this; // Protection against self-assignment
    d_code = rhs.d_code;
    m_checked = rhs.m_checked;
    rhs.m_checked = true;
    m_severity = rhs.m_severity;
    return *this;
  }

  friend bool operator< ( const StatusCode& a, const StatusCode& b ) {
    return a.d_code < b.d_code;
  }

  friend bool operator> ( const StatusCode& a, const StatusCode& b ) {
    return a.d_code > b.d_code;
  }

#ifndef _WIN32
  operator IgnoreError() const {
    m_checked = true;
    return IgnoreError();
  }
#endif

  static GAUDI_API void enableChecking();
  static GAUDI_API void disableChecking();
  static GAUDI_API bool checkingEnabled();

  class ScopedDisableChecking {
    bool m_enabled;
  public:
    ScopedDisableChecking(): m_enabled(StatusCode::checkingEnabled()) {
      if (m_enabled) StatusCode::disableChecking();
    }
    ~ScopedDisableChecking() {
      if (m_enabled) StatusCode::enableChecking();
    }
  };

protected:
  unsigned long   d_code;      
  mutable bool    m_checked;   
#if defined(__GCCXML__)
  // This is because GCCXML needs to see something that is not too in conflict with
  // boost or std
  typedef IssueSeverity* SeverityPtr;
#elif defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
  typedef std::shared_ptr<IssueSeverity> SeverityPtr;
#else
  typedef boost::shared_ptr<IssueSeverity> SeverityPtr;
#endif
  SeverityPtr     m_severity;  

  static bool     s_checking;  

private:
   void check();
};

inline std::ostream& operator<< ( std::ostream& s , const StatusCode& sc )
{
  if ( sc.isSuccess() ) { return s << "SUCCESS" ; }
  else if ( sc.isRecoverable() ) { return s << "RECOVERABLE" ; }
  s << "FAILURE" ;
  if ( StatusCode::FAILURE != sc.getCode() )
    { s << "(" << sc.getCode() << ")" ;}
  return s ;
}

#endif  // GAUDIKERNEL_STATUSCODES_H