RawDecodingError.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef ALICEO2_EMCAL_RAWDECODINGERROR_H
#define ALICEO2_EMCAL_RAWDECODINGERROR_H
 
#include <array>
#include <cassert>
#include <exception>
 
namespace o2
{
 
namespace emcal
{
 
class RawDecodingError : public std::exception
{
 public:
  enum class ErrorType_t {
    PAGE_NOTFOUND,      
    HEADER_DECODING,    
    PAYLOAD_DECODING,   
    HEADER_INVALID,     
    PAGE_START_INVALID, 
    PAYLOAD_INVALID,    
    TRAILER_DECODING,   
    TRAILER_INCOMPLETE  
  };
 
  RawDecodingError(ErrorType_t errtype, int fecID) : mErrorType(errtype), mFecID(fecID)
  {
  }
 
  ~RawDecodingError() noexcept override = default;
 
  const char* what() const noexcept override
  {
    return getErrorCodeDescription(mErrorType);
  }
 
  ErrorType_t getErrorType() const { return mErrorType; }
 
  int getFECID() const { return mFecID; }
 
  static int ErrorTypeToInt(RawDecodingError::ErrorType_t errortype)
  {
    switch (errortype) {
      case ErrorType_t::PAGE_NOTFOUND:
        return 0;
      case ErrorType_t::HEADER_DECODING:
        return 1;
      case ErrorType_t::PAYLOAD_DECODING:
        return 2;
      case ErrorType_t::HEADER_INVALID:
        return 3;
      case ErrorType_t::PAGE_START_INVALID:
        return 4;
      case ErrorType_t::PAYLOAD_INVALID:
        return 5;
      case ErrorType_t::TRAILER_DECODING:
        return 6;
      case ErrorType_t::TRAILER_INCOMPLETE:
        return 7;
    };
    // can never reach this, due to enum class
    // just to make Werror happy
    return -1;
  }
 
  static constexpr int getNumberOfErrorTypes() { return 8; }
 
  static ErrorType_t intToErrorType(unsigned int errortype)
  {
    assert(errortype < getNumberOfErrorTypes());
    static constexpr std::array<ErrorType_t, getNumberOfErrorTypes()> errortypes = {{ErrorType_t::PAGE_NOTFOUND, ErrorType_t::HEADER_DECODING,
                                                                                     ErrorType_t::PAYLOAD_DECODING, ErrorType_t::HEADER_INVALID,
                                                                                     ErrorType_t::PAGE_START_INVALID, ErrorType_t::PAYLOAD_INVALID,
                                                                                     ErrorType_t::TRAILER_DECODING, ErrorType_t::TRAILER_INCOMPLETE}};
    return errortypes[errortype];
  }
 
  static const char* getErrorCodeNames(ErrorType_t errortype)
  {
    switch (errortype) {
      case ErrorType_t::PAGE_NOTFOUND:
        return "PageNotFound";
      case ErrorType_t::HEADER_DECODING:
        return "HeaderDecoding";
      case ErrorType_t::PAYLOAD_DECODING:
        return "PayloadDecoding";
      case ErrorType_t::HEADER_INVALID:
        return "HeaderCorruption";
      case ErrorType_t::PAGE_START_INVALID:
        return "PageStartInvalid";
      case ErrorType_t::PAYLOAD_INVALID:
        return "PayloadCorruption";
      case ErrorType_t::TRAILER_DECODING:
        return "TrailerDecoding";
      case ErrorType_t::TRAILER_INCOMPLETE:
        return "TrailerIncomplete";
    };
    return "Undefined error";
  }
 
  static const char* getErrorCodeNames(unsigned int errortype)
  {
    return getErrorCodeNames(intToErrorType(errortype));
  }
 
  static const char* getErrorCodeTitles(ErrorType_t errortype)
  {
    switch (errortype) {
      case ErrorType_t::PAGE_NOTFOUND:
        return "Page not found";
      case ErrorType_t::HEADER_DECODING:
        return "Header decoding";
      case ErrorType_t::PAYLOAD_DECODING:
        return "Payload decoding";
      case ErrorType_t::HEADER_INVALID:
        return "Header corruption";
      case ErrorType_t::PAGE_START_INVALID:
        return "Page start invalid";
      case ErrorType_t::PAYLOAD_INVALID:
        return "Payload corruption";
      case ErrorType_t::TRAILER_DECODING:
        return "Trailer decoding";
      case ErrorType_t::TRAILER_INCOMPLETE:
        return "Trailer incomplete";
    };
    return "Undefined error";
  }
 
  static const char* getErrorCodeTitles(unsigned int errortype)
  {
    return getErrorCodeTitles(intToErrorType(errortype));
  }
 
  static const char* getErrorCodeDescription(ErrorType_t errortype)
  {
    switch (errortype) {
      case ErrorType_t::PAGE_NOTFOUND:
        return "Page with requested index not found";
      case ErrorType_t::HEADER_DECODING:
        return "RDH of page cannot be decoded";
      case ErrorType_t::PAYLOAD_DECODING:
        return "Payload of page cannot be decoded";
      case ErrorType_t::HEADER_INVALID:
        return "Access to header not belonging to requested superpage";
      case ErrorType_t::PAGE_START_INVALID:
        return "Page decoding starting outside payload size";
      case ErrorType_t::PAYLOAD_INVALID:
        return "Access to payload not belonging to requested superpage";
      case ErrorType_t::TRAILER_DECODING:
        return "Inconsistent trailer in memory";
      case ErrorType_t::TRAILER_INCOMPLETE:
        return "Incomplete trailer";
    };
    return "Undefined error";
  }
 
  static const char* getErrorCodeDescription(unsigned int errortype)
  {
    return getErrorCodeDescription(intToErrorType(errortype));
  }
 
 private:
  ErrorType_t mErrorType; 
  int mFecID;             
};
 
std::ostream& operator<<(std::ostream& stream, const RawDecodingError& error);
 
std::ostream& operator<<(std::ostream& stream, const RawDecodingError::ErrorType_t& error);
 
} // namespace emcal
 
} // namespace o2
 
#endif