QError.cc

Go to the documentation of this file.

#include "QError.hh"
#include <sstream>
 
using std::stringstream;
 
 
 
 
 
std::map<QError_, std::string> QError::fMap;
 
 
//_____________________________________________________________________________
void QError::Init()
{
  static bool initDone = false;
  if(initDone) return;
  
  // Generic error code (Diana & Apollo)
  fMap[QERR_SUCCESS]          = "Success";
  fMap[QERR_OUT_OF_RANGE]     = "Out Of Range";
  fMap[QERR_OVERFLOW]         = "Overflow";
  fMap[QERR_UNDERFLOW]        = "Underflow";
  fMap[QERR_SIZE_NOT_MATCH]   = "Size not match";
  fMap[QERR_FILE_NOT_FOUND]   = "File not found";
  fMap[QERR_CANNOT_OPEN_FILE] = "Cannot open file";
  fMap[QERR_IO_FAILED]        = "Input Output Failed";
  fMap[QERR_UNDEFINED_NUMBER] = "Number not valid";
  fMap[QERR_TYPE_CONVERSION]  = "Type Conversion";
  fMap[QERR_GSL_ERROR]        = "GSL error";
  fMap[QERR_TIMEOUT]          = "Timemout elapsed";
  fMap[QERR_EOF]              = "Reached EOF";
 
  // Diana:
  fMap[QERR_EVENT_GENERIC] = "Generic Event Error";
  fMap[QERR_GLOBAL_GENERIC] = "Generic Global Objects Error";
  fMap[QERR_EVENT_HANDLE] = "Event Handle Error";
  fMap[QERR_GLOBAL_HANDLE] = "Global Handle Error";
  
 
  // Apollo: general error codes
  fMap[QERR_UNDEFINED_CHANNEL]   = "Undefined Channel";
  fMap[QERR_UNDEFINED_ID]        = "Undefined Identification";
  fMap[QERR_UNDEFINED_TYPE]      = "Undefined Type";
  fMap[QERR_UNDEFINED_STATUS]    = "Undefined Status";
  fMap[QERR_UNDEFINED_PARAMETER] = "Undefined Parameter";
  fMap[QERR_UNDEFINED_COMMAND]   = "Undefined Command";
  fMap[QERR_UNDEFINED_DEVICE]    = "Undefined Device";
  fMap[QERR_UNDEFINED_INTERFACE] = "Undefined Interface";
  fMap[QERR_UNDEFINED_TARGET]    = "Undefined Target";
  fMap[QERR_EXIT]                = "Process status changed to Exit";
 
  // National Instruments error codes
  fMap[QERR_NI] = "National Instruments error";
 
  // Slow Control: specific error codes
  fMap[QERR_UNDEFINED_MODE]      = "Undefined Mode";
  fMap[QERR_UNDEFINED_BASKET]    = "Setting Basket Not defined";
  fMap[QERR_UNDEFINED_CRATE]     = "Undefined Crate Address";
  fMap[QERR_UNDEFINED_BOARD]     = "Undefined Board Address";
  
 
  // Slow Control: electronics error
  fMap[QERR_ELE_UNDEFINED_REGISTER]  = "Undefined Register";
  fMap[QERR_ELE_GENERIC_ERR]         = "Generic Error";            
  fMap[QERR_ELE_NO_ACKNOLDGEMENT]    = "No Data Acknologement";    
  fMap[QERR_ELE_UNDEFINED_REGISTER]  = "Register Not Defined";     
  fMap[QERR_ELE_FE_WRITE]            = "Front End Write Error";    
  fMap[QERR_ELE_BACKPLANE_WRITE]     = "Backplane Write Error";    
  fMap[QERR_ELE_BESSEL_WRITE]        = "Bessel Write Error";       
  fMap[QERR_ELE_PULSER_ATT_WRITE]    = "Pulser Attenuation Write Error"; 
  fMap[QERR_ELE_PULSER_STATUS_WRITE] = "Pulser Status Write Error"; 
  fMap[QERR_ELE_FE_READ]                 = "Front End Read Error";         
  fMap[QERR_ELE_BACKPLANE_READ]      = "Backplane Read Error";     
  fMap[QERR_ELE_BESSEL_READ]         = "Bessel Read Error";        
  fMap[QERR_ELE_PULSER_ATT_READ]     = "Pulser Attenuation Read Errror";
  fMap[QERR_ELE_PULSER_STATUS_READ]  = "Pulser Status Read Error";
 
 
  // Network communication errors
  fMap[QERR_NET_UNKNOWN_HOST]        = "Unknown Host";
  fMap[QERR_NET_CONNECTION_FAILED]   = "Connection Failed";
  fMap[QERR_NET_PROTOCOL]            = "Error in communication protocol";
 
  // shared memory related errors
  fMap[QERR_SHMEM_INVALID_INDEX]     = "Invalid index in shared memory buffer";
  fMap[QERR_SHMEM_INVALID_ID]        = "Invalid shared memory Id";
  
  // GPIB Error
  fMap[QERR_GPIB_GENERAL]  = "Error in GPIB Comunication";
 
  // vme related errors
  fMap[QERR_VME_OPEN]  = "Error opening VME environment";
  fMap[QERR_VME_READ]  = "Error reading from VME";
  fMap[QERR_VME_WRITE] = "Error writing to VME";
 
  // DataBase errors
  fMap[QERR_DB_INCONSISTENCY]        = "Inconsistency found in db";
  fMap[QERR_DB_CONN_FAILED]          = "Connection to db failed";
  fMap[QERR_DB_QUERY_FAILED]         = "Error while executing query";
  fMap[QERR_DB_NULL_RESULT]          = "Null result while single expected";
  fMap[QERR_DB_MAXLINES_EXCEEDED]    = "Number of entries exceeded requested "
          "limit";
 
 
  // Unknown errors
  fMap[QERR_UNKNOWN_ERR]     = "Unknown error";
  fMap[QERR_NOT_IMPLEMENTED] = "Not implemented";
 
  initDone = true;
}
 
 
//_____________________________________________________________________________
QError::QError():
   std::exception()
{
        fErr = QERR_SUCCESS;
        fDescr = "";
        Init();
}
 
 
//_____________________________________________________________________________
QError::QError(QError_ err)
{
        fErr = err;
        fDescr = "";
        Init();
}
 
 
//_____________________________________________________________________________
QError::QError(QError_ err, const std::string& descr)
{
        fErr = err;
        fDescr = descr;
        Init();
}
 
QError::QError(QError_ err, const std::string& file, const int line, const std::string& descr)
{
        fErr = err;
    SetDescription(file,line,descr);
        Init();
}
 
QError::QError(const QError& err)
{
        *this = err;
}
 
 
 
 
//_____________________________________________________________________________
void QError::Set(QError_ err, const std::string& descr)
{
        fErr = err;
        fDescr = descr;
}
 
void QError::Set(QError_ err, const std::string& file, const int line, const std::string& descr)
{
        fErr = err;
    SetDescription(file,line,descr);
}
 
 
 
//_____________________________________________________________________________
 
//_____________________________________________________________________________
const QError& QError::operator = (const QError_ &e)
{
        fErr = e;
        return *this;
}
 
 
//_____________________________________________________________________________
const QError& QError::operator = (const QError &e)
{
        fErr = e.fErr;
        fDescr = e.fDescr;
        return *this;
}
 
 
const std::string& QError::GetDescription() const
{
    return fDescr;
}
 
void QError::SetDescription(const std::string& file, const int line, const std::string& descr)
{
 
    stringstream str;
    str<<file<<":"<<line<<": "<<descr;
    fDescr = str.str();
}
//_____________________________________________________________________________
const std::string& QError::ToString() const
{
        return fMap[fErr];
}
 
 
//_____________________________________________________________________________
std::ostream& operator<<(std::ostream &s ,const QError &err) 
{
   s<<"Error: "<<err.fMap[err.fErr];
   if(err.GetDescription().empty())
      s << ". No description available";
   else
      s << ". Description: " << err.GetDescription();
   return s;
}
 
 
//_____________________________________________________________________________
const char* QError::what() const throw()
{
   std::stringstream s;
   s << *this;
   std::string ret1 = s.str();
   const char* ret = ret1.c_str();
   return ret;
}