StatusCode.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_STATUSCODE_H
#define GAUDIKERNEL_STATUSCODE_H

#include <ostream>

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

#include <memory>

class IMessageSvc;
class IStatusCodeSvc;

class IgnoreError
{
};

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

  StatusCode() = default;

  StatusCode( unsigned long code, IssueSeverity&& sev ) : d_code( code )
  {
    try { // ensure that we do not throw even if we cannot move the severity
      m_severity = std::make_shared<const IssueSeverity>( std::move( sev ) );
    } catch ( ... ) {
    }
  }

  StatusCode( IssueSeverity&& is )
      : StatusCode( is.getLevel() == IssueSeverity::RECOVERABLE
                        ? StatusCode::RECOVERABLE
                        : ( is.getLevel() < IssueSeverity::ERROR ? StatusCode::SUCCESS : StatusCode::FAILURE ),
                    std::move( is ) )
  {
  }

  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 ), m_severity( rhs.m_severity )
  {
    rhs.m_checked = true;
  }

  StatusCode( StatusCode&& rhs ) noexcept
      : d_code( rhs.d_code ), m_checked( rhs.m_checked ), m_severity( std::move( rhs.m_severity ) )
  {
    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(); }

  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   = SUCCESS;                
  mutable bool m_checked = false;                  
  std::shared_ptr<const IssueSeverity> 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";
  }
  if ( sc.isRecoverable() ) {
    return s << "RECOVERABLE";
  }
  s << "FAILURE";
  return ( StatusCode::FAILURE != sc.getCode() ) ? s << "(" << sc.getCode() << ")" : s;
}

#endif // GAUDIKERNEL_STATUSCODES_H