StatusCode.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_STATUSCODE_H
#define GAUDIKERNEL_STATUSCODE_H

#include <ostream>
#include <utility>

#include "GaudiKernel/Kernel.h"

class IMessageSvc;
class IStatusCodeSvc;

class IgnoreError
{
};

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

  StatusCode() = default;

  StatusCode( unsigned long code, bool checked = false ) : d_code( code ), m_checked( checked ) {}

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

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

  ~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(); }

  bool checked() const { return m_checked; }

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

  StatusCode& operator=( unsigned long value )
  {
    setCode( value );
    return *this;
  }
  StatusCode& operator=( const StatusCode& rhs )
  {
    d_code    = rhs.d_code;
    m_checked = std::exchange( rhs.m_checked, true );
    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   = SUCCESS; 
  mutable bool m_checked = false;   

  static bool s_checking; 

private:
  void check();
};

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

#endif // GAUDIKERNEL_STATUSCODES_H