StatusCode.h

Go to the documentation of this file.

// $Id: StatusCode.h,v 1.12 2008/10/28 17:21:58 marcocle Exp $
#ifndef GAUDIKERNEL_STATUSCODE_H
#define GAUDIKERNEL_STATUSCODE_H

#include <ostream>

#include "GaudiKernel/IssueSeverity.h"

class IMessageSvc;
class IStatusCodeSvc;

class IgnoreError {};

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

  StatusCode();
  StatusCode( unsigned long code, const IssueSeverity& );
  StatusCode( unsigned long code, bool checked = false );

  StatusCode( const StatusCode& sc );

  ~StatusCode();

  bool isSuccess() const;

  bool isFailure() const;
  bool isRecoverable() const;

  unsigned long getCode() const;

  void setCode( unsigned long );

  void setChecked() const;
  void ignore() const;

  operator unsigned long() const;

  const IssueSeverity& severity() const;

  StatusCode& operator=(unsigned long value);
  StatusCode& operator=(const StatusCode& rhs);

  friend bool operator< ( const StatusCode& a, const StatusCode& b );

  friend bool operator> ( const StatusCode& a, const StatusCode& b );

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

  static void enableChecking();
  static void disableChecking();

protected:
  unsigned long   d_code;      
  mutable bool    m_checked;   
  IssueSeverity*  m_severity;  

  static bool     s_checking;  

  static IssueSeverity* cloneSeverity(const IssueSeverity*);
};

inline StatusCode::StatusCode():
  d_code(SUCCESS), m_checked(false), m_severity(0) {}

inline StatusCode::StatusCode( unsigned long code, bool checked ) :
  d_code(code),m_checked(checked), m_severity(0) {}

inline StatusCode::StatusCode( unsigned long code, const IssueSeverity& sev ) :
  d_code(code),m_checked(false), m_severity(cloneSeverity(&sev)) {
}

inline StatusCode::StatusCode( const StatusCode &rhs ) {
  d_code = rhs.d_code;
  m_checked = rhs.m_checked;
  rhs.m_checked = true;
  m_severity = rhs.m_severity ? cloneSeverity(rhs.m_severity) : 0;
}

inline StatusCode& 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;
  if (m_severity) delete m_severity;
  m_severity = rhs.m_severity ? cloneSeverity(rhs.m_severity): 0;
  return *this;
}

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

inline bool StatusCode::isFailure() const {
  m_checked = true;
  return (d_code != SUCCESS );
}

inline bool StatusCode::isRecoverable() const {
  m_checked = true;
  return (d_code == RECOVERABLE);
}

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

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

inline void StatusCode::setChecked() const {
  m_checked = true;
}

inline void StatusCode::ignore() const {
  m_checked = true;
}

inline StatusCode::operator unsigned long() const  {
  m_checked = true;
  return d_code;
}

inline StatusCode& StatusCode::operator=(unsigned long value)   {
  d_code = value;
  m_checked = false;
  return *this;
}

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

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

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