/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/TrigSteeringEvent/TrigSteeringEvent/Enums.h

#pragma once
#ifndef TRIGINTERFACES_ENUMS_H
#define TRIGINTERFACES_ENUMS_H

#include <vector>
#include <string>
#include <stdint.h>

namespace HLT {
  struct Action {
    typedef enum  {
      CONTINUE    = 0,  
      ABORT_CHAIN = 1,  
      ABORT_EVENT = 2,  
      ABORT_JOB   = 3,   
      UNSPECIFIED_ = -1 

    } Code;
  };

  struct Reason {
    typedef enum {
      UNKNOWN=0,
      MISSING_FEATURE,   
      GAUDI_EXCEPTION,   
      EFORMAT_EXCEPTION, 
      STD_EXCEPTION,     
      UNKNOWN_EXCEPTION, 
      NAV_ERROR,         
      MISSING_ROD,       
      CORRUPTED_ROD,     
      TIMEOUT,           
      BAD_JOB_SETUP,     

      USERDEF_1,         
      USERDEF_2,
      USERDEF_3,
      USERDEF_4,
      LAST_            =0xf,        
      UNSPECIFIED_ = -1 
    } Code;
  };




  struct SteeringInternalReason {
    typedef enum {
      UNKNOWN=0, 
      NO_LVL1_ITEMS,    
      NO_LVL2_CHAINS,   
      NO_LVL1_RESULT,   
      WRONG_HLT_RESULT, 
      NO_HLT_RESULT,    
      ALGO_ERROR,       
      TIMEOUT,          
      BUSY,             
      BAD_JOB_SETUP,    
      LAST_,            
      UNSPECIFIED_ = -1 
    } Code;
  };

  class ErrorCode {
  public:
    ErrorCode();                                           
    ErrorCode(Action::Code a);                             
    ErrorCode(Action::Code a, Reason::Code r);             


    ErrorCode(uint32_t c);
    ErrorCode(const ErrorCode c, Reason::Code r);

    ErrorCode(Action::Code a, SteeringInternalReason::Code s);
    ErrorCode(const ErrorCode c, SteeringInternalReason::Code s);

    ErrorCode(Action::Code a, Reason::Code r, SteeringInternalReason::Code s);

    // comapricon operators
    bool operator==(const ErrorCode& ec) const;
    bool operator!=(const ErrorCode& ec) const;

    bool operator<(const ErrorCode& ec) const;
    bool operator>(const ErrorCode& ec) const;

    // conversions
    operator uint32_t() const {return code;}

    //    bool operator<(const ErrorCode& e1, const ErrorCode& e2 ) {return e1.code & 0x3;}// < e.code &0x3; }
    Action::Code action() const;
    Reason::Code reason() const;
    SteeringInternalReason::Code steeringInternalReason() const;

    std::string str();

    uint32_t code; 
  };

  std::string strErrorCode(const ErrorCode code);
  //  const std::string& str(const Reason::Code code) { return "U"; }


  //bunch of defines for backward compatibility
  static const ErrorCode OK(Action::CONTINUE);
  static const ErrorCode MISSING_FEATURE    (Action::CONTINUE,   Reason::MISSING_FEATURE);
  static const ErrorCode STOP_THIS_CHAIN_   (Action::CONTINUE,   Reason::MISSING_FEATURE);

  static const ErrorCode ERROR              (Action::ABORT_CHAIN, Reason::UNKNOWN);
  static const ErrorCode INVALID_TE         (Action::ABORT_CHAIN, Reason::UNKNOWN);
  static const ErrorCode TOOL_FAILURE       (Action::ABORT_CHAIN, Reason::UNKNOWN);
  static const ErrorCode NUM_ERROR          (Action::ABORT_CHAIN, Reason::UNKNOWN);
  static const ErrorCode SG_ERROR           (Action::ABORT_CHAIN, Reason::NAV_ERROR);
  static const ErrorCode NAV_ERROR          (Action::ABORT_CHAIN, Reason::NAV_ERROR);
  static const ErrorCode GAUDI_EXCEPTION    (Action::ABORT_CHAIN, Reason::GAUDI_EXCEPTION);
  static const ErrorCode EFORMAT_EXCEPTION  (Action::ABORT_CHAIN, Reason::EFORMAT_EXCEPTION);
  static const ErrorCode STD_EXCEPTION      (Action::ABORT_CHAIN, Reason::STD_EXCEPTION);
  static const ErrorCode UNKNOWN_EXCEPTION  (Action::ABORT_CHAIN, Reason::UNKNOWN_EXCEPTION);
  static const ErrorCode TIMEOUT            (Action::ABORT_EVENT, Reason::TIMEOUT, SteeringInternalReason::TIMEOUT);
  static const ErrorCode STOP_EVENT_        (Action::ABORT_EVENT);

  static const ErrorCode NO_LVL1_ITEMS      (Action::ABORT_EVENT, SteeringInternalReason::NO_LVL1_ITEMS);
  static const ErrorCode NO_LVL2_CHAINS     (Action::ABORT_EVENT, SteeringInternalReason::NO_LVL2_CHAINS);
  static const ErrorCode NO_LVL1_RESULT     (Action::ABORT_EVENT, SteeringInternalReason::NO_LVL1_RESULT);
  static const ErrorCode WRONG_HLT_RESULT   (Action::ABORT_EVENT, SteeringInternalReason::WRONG_HLT_RESULT);
  static const ErrorCode NO_HLT_RESULT      (Action::ABORT_EVENT, SteeringInternalReason::NO_HLT_RESULT);

  static const ErrorCode STOP_JOB_          (Action::ABORT_JOB);
  static const ErrorCode BAD_JOB_SETUP      (Action::ABORT_JOB, Reason::BAD_JOB_SETUP);
  static const ErrorCode BAD_ALGO_CONFIG    (Action::ABORT_JOB, Reason::BAD_JOB_SETUP);
  static const ErrorCode FATAL              (Action::ABORT_JOB, Reason::UNKNOWN);
  static const ErrorCode LAST_ERROR         (Action::ABORT_JOB, Reason::LAST_, SteeringInternalReason::LAST_);


  // keep order so that worst is most right!
  /*  enum ErrorCode {
    OK=0, MISSING_FEATURE,
    STOP_THIS_CHAIN_,
    ERROR,
    INVALID_TE, TOOL_FAILURE,
    NUM_ERROR, SG_ERROR, NAV_ERROR,
    GAUDI_EXCEPTION, EFORMAT_EXCEPTION, STD_EXCEPTION, UNKNOWN_EXCEPTION, // bunch of exceptions we handle
    STOP_EVENT_,
    NO_LVL1_ITEMS, NO_LVL2_CHAINS,
    NO_LVL1_RESULT, WRONG_HLT_RESULT, NO_HLT_RESULT,
    TIMEOUT,
    STOP_JOB_,
    BAD_JOB_SETUP, BAD_ALGO_CONFIG, FATAL, LAST_ERROR };


  const std::string& strErrorCode( ErrorCode ec );
  */
  // search for the ErrorCode and return the position. return -1 if it can not be found.
  int getErrorCodePosFromStr(const std::string& ec);

  void reportErrorCode(ErrorCode& e1, ErrorCode e2);

  enum HLTLevel { L2 = 0, EF, HLT, UNKNOWN };

}



// definitions
inline HLT::ErrorCode::ErrorCode() { code = 0; }
inline HLT::ErrorCode::ErrorCode(HLT::Action::Code a) { code = a << 4; }
inline HLT::ErrorCode::ErrorCode(HLT::Action::Code a, HLT::Reason::Code r) { code = a << 4; code |= r; }


inline HLT::ErrorCode::ErrorCode(uint32_t c) { code = c; }
inline HLT::ErrorCode::ErrorCode(const HLT::ErrorCode c, HLT::Reason::Code r) { code = c.code; code &= 0x30; code |= r; }

inline HLT::ErrorCode::ErrorCode(HLT::Action::Code a, HLT::SteeringInternalReason::Code s) { code = a << 4; code |= s<<8; }
inline HLT::ErrorCode::ErrorCode(const HLT::ErrorCode c, HLT::SteeringInternalReason::Code s) { code = c.code; code |= s<<8; }

inline HLT::ErrorCode::ErrorCode(HLT::Action::Code a, HLT::Reason::Code r, HLT::SteeringInternalReason::Code s) { code = a << 4; code |= r; code |= s<<8; }

// comapricon operators
inline bool HLT::ErrorCode::operator==(const HLT::ErrorCode& ec) const { return uint32_t(*this) == uint32_t(ec); }
inline bool HLT::ErrorCode::operator!=(const HLT::ErrorCode& ec) const { return !(*this == ec); }

inline bool HLT::ErrorCode::operator<(const HLT::ErrorCode& ec) const { return uint32_t(*this) < uint32_t(ec); }
inline bool HLT::ErrorCode::operator>(const HLT::ErrorCode& ec) const { return !(*this<ec) && !(*this == ec); }

// conversions
//HLT::ErrorCode::operator uint32_t() const { return code; }

//    bool operator<(const ErrorCode& e1, const ErrorCode& e2 ) {return e1.code & 0x3;}// < e.code &0x3; }
inline HLT::Action::Code HLT::ErrorCode::action() const { return HLT::Action::Code((code>>4)&0x3); }
inline HLT::Reason::Code HLT::ErrorCode::reason() const { return HLT::Reason::Code(code&0xf); }
inline HLT::SteeringInternalReason::Code HLT::ErrorCode::steeringInternalReason() const { return HLT::SteeringInternalReason::Code(code>>8); }



#endif

---