QError.hh

Go to the documentation of this file.

 
#ifndef _Q_ERR_HH_
#define _Q_ERR_HH_
 
#include <iostream>
#include <string>
#include <exception>
#include <map>
 
#include "QDiana.hh"
 
 
enum QError_ {
  
  // generic errors
  QERR_SUCCESS,
  QERR_OUT_OF_RANGE,
  QERR_OVERFLOW ,
  QERR_UNDERFLOW ,
  QERR_SIZE_NOT_MATCH,
  QERR_FILE_NOT_FOUND,
  QERR_CANNOT_OPEN_FILE,
  QERR_IO_FAILED,
  QERR_UNDEFINED_NUMBER,
  QERR_TYPE_CONVERSION,
  QERR_GSL_ERROR,
  QERR_TIMEOUT,
  QERR_EOF,
 
  // Diana:
  QERR_EVENT_GENERIC,
  QERR_EVENT_HANDLE,
  QERR_GLOBAL_GENERIC,
  QERR_GLOBAL_HANDLE,
 
  // Apollo: general errors
  QERR_UNDEFINED_CHANNEL,
  QERR_UNDEFINED_ID,
  QERR_UNDEFINED_TYPE,
  QERR_UNDEFINED_STATUS,
  QERR_UNDEFINED_PARAMETER,
  QERR_UNDEFINED_COMMAND,
  QERR_UNDEFINED_DEVICE,
  QERR_UNDEFINED_INTERFACE,
  QERR_UNDEFINED_TARGET,
  QERR_EXIT,
 
  // National Instruments error codes
  QERR_NI,
 
  // Slow Control: specific error codes
  QERR_UNDEFINED_MODE,
  QERR_UNDEFINED_BASKET,
  QERR_UNDEFINED_CRATE, 
  QERR_UNDEFINED_BOARD, 
 
  // Slow Control Error (Front-End, Bessel, Pulser, Backplane)
  QERR_ELE_UNDEFINED_REGISTER,
  QERR_ELE_GENERIC_ERR,
  QERR_ELE_NO_ACKNOLDGEMENT,
  QERR_ELE_FE_WRITE,
  QERR_ELE_BACKPLANE_WRITE,
  QERR_ELE_BESSEL_WRITE,
  QERR_ELE_PULSER_ATT_WRITE,
  QERR_ELE_PULSER_STATUS_WRITE,
  QERR_ELE_FE_READ,
  QERR_ELE_BACKPLANE_READ,
  QERR_ELE_BESSEL_READ,
  QERR_ELE_PULSER_ATT_READ,
  QERR_ELE_PULSER_STATUS_READ,
 
  // vme related errors
  QERR_VME_OPEN,
  QERR_VME_WRITE,
  QERR_VME_READ,
 
  // GPIB Errors
  QERR_GPIB_GENERAL,
 
  // Network communication errors
  QERR_NET_UNKNOWN_HOST,
  QERR_NET_CONNECTION_FAILED,
  QERR_NET_PROTOCOL,
 
  // shared memory related errors
  QERR_SHMEM_INVALID_INDEX,
  QERR_SHMEM_INVALID_ID,
 
  // DataBase errors
  QERR_DB_INCONSISTENCY,
  QERR_DB_CONN_FAILED,
  QERR_DB_QUERY_FAILED,
  QERR_DB_NULL_RESULT,
  QERR_DB_MAXLINES_EXCEEDED,
 
  // Unknown Errors
  QERR_UNKNOWN_ERR,
  QERR_NOT_IMPLEMENTED
};
 
class QError: public std::exception {
 
        public:
   
                virtual const char* what() const throw();
 
                QError();
 
                QError(QError_ err);
 
                QError(QError_ err, const std::string& descr);
        
                QError(QError_ err, const std::string& file, const int line, const std::string& descr);
 
                QError(const QError& err);
 
                virtual ~QError() throw() {};
 
                const QError& operator = (const QError_ &e); 
 
        const QError& operator=(const QError& err);
 
                void SetDescription(const std::string& descr) {fDescr = descr;}
        
                void SetDescription(const std::string& file, const int line, const std::string& descr);
 
                const std::string& GetDescription() const;
 
                QError_ GetCode() const {return fErr;}
 
                const std::string& ToString() const;
 
 
                bool operator == (const QError_& e) const {return fErr == e;}
 
                bool operator == (const QError& e)  const {return fErr == e.fErr;}
 
                bool operator != (const QError_& e) const {return fErr != e;}
 
                bool operator != (const QError &e)  const {return fErr != e.fErr;}
 
                void Set(QError_ e=QERR_SUCCESS, const std::string &descr="");
 
                void Set(QError_ e, const std::string& file, const int line, const std::string &descr = "");
 
 
        private:
        
 
                QError_ fErr;
 
                std::string fDescr;
        
 
                static void Init();
 
                static std::map<QError_, std::string> fMap;
 
                friend  std::ostream& operator<<(std::ostream &s , const QError &err); 
 
        // QRootCintTrigger
};
 
 
std::ostream& operator<<(std::ostream &s , const QError &err); 
 
 
#endif