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"

#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; }

#ifndef __GCCXML__
  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; }
#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 = 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