statusCodes.h

Go to the documentation of this file.

#ifndef STATUSCODES_H
#define STATUSCODES_H
#include <cadef.h>
#include <map>
#include <vector>
#include <iostream>
#include <sstream>

#include <cafeDataType.h>


const unsigned short ICAFE_STATUS_BASE  =  600;
const unsigned short ICAFE_STATUS_CS    = ICAFE_STATUS_BASE;
const unsigned short ICAFE_STATUS_CFT   =  700; // ca_field_type
const unsigned short ICAFE_STATUS_CA_OP =  800;
const unsigned short ICAFE_STATUS_ERROR = 1000;
const unsigned short ICAFE_FILE_ERROR   = 1100;
const unsigned short ICAFE_SERVICE_ERROR    =1200;
const unsigned short ICAFE_BITSHUFFLE_ERROR =1300;
const unsigned short ICAFE_BSREAD_BASE  = 1500;
const unsigned short ICAFE_ERRNO_BASE   = 5000;

const unsigned short ICAFE_SUCCESS      = ECA_NORMAL;
const unsigned short ICAFE_NORMAL       = ECA_NORMAL;



enum CAFE_CS_STATE {    ICAFE_CS_NEVER_CONN=ICAFE_STATUS_CS,
                        ICAFE_CS_PREV_CONN,
                        ICAFE_CS_CONN,
                        ICAFE_CS_CLOSED,
                                                                                                ICAFE_CS_DISCONN,
                        ICAFE_CS_UNKNOWN
                   };
                                                                         
enum CAFE_CFT_STATE{    ICAFE_TYPENOTCONN=ICAFE_STATUS_CFT,
                        ICAFE_RULE_FALSE,
                        ICAFE_BADCOUNT,
                        ICAFE_CALLBACK_NOT_YET_INVOKED,
                        ICAFE_WAITING_FOR_PREV_CALLBACK,
                        ICAFE_CACHE_EMPTY,
                        ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT,
                                                                                                ICAFE_MONITOR_DELAYED_AS_CONN_DOWN,
                                                                                                ICAFE_HAS_MONITOR_GET_DONE_FROM_CACHE,
                                                                                                ICAFE_SET_AND_GET_MISMATCH
                   };

enum CAFE_CC_STATE {    ICAFE_CA_OP_GET=ICAFE_STATUS_CA_OP,
                        ICAFE_CA_OP_PUT,
                        ICAFE_CA_OP_CREATE_CHANNEL,
                        ICAFE_CA_OP_ADD_EVENT,
                        ICAFE_CA_OP_CLEAR_EVENT,
                        ICAFE_CA_OP_OTHER,
                        ICAFE_CA_OP_CONN_UP,
                        ICAFE_CA_OP_CONN_DOWN
                   };

enum CAFE_ERROR_STATE { ECAFE_NODATA=ICAFE_STATUS_ERROR,
                        ECAFE_INVALID_TYPE,
                        ECAFE_BADCOUNT,
                        ECAFE_BADSTR,
                        ECAFE_BADTYPE,
                        ECAFE_NO_CONVERT,
                        ECAFE_NULLCONTEXT,
                        ECAFE_NULLCHID,
                        ECAFE_NULLEVID,
                        ECAFE_UNKNOWN_COLLECTION,
                        ECAFE_EMPTY_COLLECTION,
                        ECAFE_COLLECTION_PREV_DEF,
                        ECAFE_COLLECTION_INVALID_MEMBER,
                        ECAFE_RULE_FALSE,
                        ECAFE_UNKNOWN_GROUP,
                        ECAFE_EMPTY_GROUP,
                        ECAFE_GROUP_PREV_DEF,
                        ECAFE_INVALID_HANDLE,
                        ECAFE_INVALID_GROUP_HANDLE,
                        ECAFE_NORDACCESS,
                        ECAFE_NOWTACCESS,
                        ECAFE_TIMEOUT,
                        ECAFE_CANNOT_OPEN_FILE,
                        ECAFE_INVALID_SWITCH_CASE,
                        ECAFE_PVALIAS_PREV_DEF,
                        ECAFE_PVALIAS_INVALID,
                        ECAFE_PVNAME_PREV_DEF_AS_PVALIAS,
                        ECAFE_DEVICE_ATTRIB_NOT_FOUND,
                        ECAFE_HASH_UNIQUEID_EXISTS,
                        ECAFE_WRONG_CA_CONTEXT,
                        ECAFE_INVALID_CAFENUM_POLICY_TYPE,
                        ECAFE_MAX_MONITORS_PER_CHAN_EXCEEDED,
                        ECAFE_INVALID_ENUM_INDEX,
                        ECAFE_PVGROUP_GROUPHANDLE_MISMATCH,
                        ECAFE_TIMEOUT_SET_AND_MATCH,
                                                                                                ECAFE_HANDLE_MISMATCH_SET_AND_MATCH,
                                                                                                ECAFE_INCONSISTENT_CONTAINER_CORRECTED
                    };

//1100
enum CAFE_FILE_ERROR  { ECAFE_LOAD_COLLECTION=ICAFE_FILE_ERROR,
                        ECAFE_LOAD_GROUP
                      };

//1200
enum CAFE_SERVICE_ERROR { ECAFE_BPM_DATA_IS_INVALID=ICAFE_SERVICE_ERROR
                      };
//1300
enum CAFE_BITSHUFFLE_ERROR { ECAFE_BITSHUFF_DECOMPRESS=ICAFE_BITSHUFFLE_ERROR,
                             ECAFE_BITSHUFF_ALLOCMEM,    
                             ECAFE_BITSHUFF_REALLOCMEM, 
                             ECAFE_BITSHUFF_BADCOUNT
                      };

enum CAFE_BSREAD_ERROR {ECAFE_BSREAD_MULTIPART_MESS_NODATA=ICAFE_BSREAD_BASE,
                        ECAFE_BSREAD_PARSEFAIL_MAINHEADER,
                        ECAFE_BSREAD_PARSEFAIL_DATAHEADER,
                                                                                                ECAFE_BSREAD_ZMQSTREAM_NULL   
                      };

//5000
//Used by zeromq
enum CAFE_ERRNO_ERROR { ERRNO_EINTR =ICAFE_ERRNO_BASE+4,
                        ERRNO_EAGAIN=ICAFE_ERRNO_BASE+11,
                        ERRNO_EFAULT=ICAFE_ERRNO_BASE+14,
                                                                                                ERRNO_EINVAL=ICAFE_ERRNO_BASE+22,
                        ERRNO_ENOTSOCK=ICAFE_ERRNO_BASE+88,
                        ERRNO_EPROTONOSUPPORT=ICAFE_ERRNO_BASE+93
};


//epicsAlarmConditionStrings = {"NO_ALARM","READ","WRITE","HIHI","HIGH",
//"LOLO","LOW","STATE","COS", "COMM","TIMEOUT","HWLIMIT","CALC","SCAN","LINK",
//"SOFT","BAD_SUB","UDF","DISABLE","SIMM","READ_ACCESS", "WRITE_ACCESS"};


enum EPICS_GLOBAL_ALARM_CONDITION {STAT_NO_ALARM=0, STAT_READ, STAT_WRITE, STAT_HIHI, STAT_HIGH,
   STAT_LOLO, STAT_LOW, STAT_STATE, STAT_COS, STAT_COMM, STAT_TIMEOUT, STAT_HWLIMIT,
   STAT_CALC, STAT_SCAN, STAT_LINK,
   STAT_SOFT, STAT_BAD_SUB, STAT_UDF, STAT_DISABLE, STAT_SIMM, STAT_READ_ACCESS, STAT_WRITE_ACCESS
};

enum EPICS_GLOBAL_ALARM_SEVERITY {SEV_NO_ALARM=0, SEV_MINOR, SEV_MAJOR, SEV_INVALID};


class CAFEGlobalAlarmCondition {
        typedef std::map<int, std::string> mapIntString;

private:
        mapIntString mapAlarmCondition;
        mapIntString::iterator pos;

public:
  CAFEGlobalAlarmCondition() {
          mapAlarmCondition.insert(std::make_pair((int) STAT_NO_ALARM, "NO_ALARM"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_READ,     "READ"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_WRITE,    "WRITE"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_HIHI,     "HIHI"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_HIGH,     "HIGH"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_LOLO,     "LOLO"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_LOW,      "LOW"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_STATE,    "STATE"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_COS,      "COS"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_COMM,     "COMM"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_TIMEOUT,  "TIMEOUT"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_HWLIMIT,  "HWLIMIT"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_CALC,     "CALC"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_SCAN,     "SCAN"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_LINK,     "LINK"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_SOFT,     "SOFT"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_BAD_SUB,  "BAD_SUB"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_UDF,      "UDF"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_DISABLE,  "DISABLE"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_SIMM,     "SIMM"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_READ_ACCESS,   "READ_ACCESS"));
          mapAlarmCondition.insert(std::make_pair((int) STAT_WRITE_ACCESS,  "WRITE_ACCESS"));

  };

        ~CAFEGlobalAlarmCondition() {};

        std::string asString (int i) {

          pos = mapAlarmCondition.find(i);
          if (pos != mapAlarmCondition.end()) {
                  return    pos->second;
          }

          std::ostringstream oss;
          if (i == -1) {
                  oss << "NO_DATA" ;
                  return oss.str();
          }
          std::cout << "------------------------------------" << std::endl;
          oss << "INVALID ENUM VALUE: " << i ; //<< --std::endl;
          std::cout << oss.str();
          std::cout << " VALID VALUES ARE: " << std::endl;
          printAll();
          std::cout << "--------------------------------------" << std::endl;
          return oss.str();
          };


        int asInt (std::string message) {
          for (pos=mapAlarmCondition.begin(); pos != mapAlarmCondition.end(); ++pos) {

                if (pos->second==message) return pos->first;
                // String searches such as s.find(s1) return string::npos on failure
                else if ( (pos->second).find(message)  != std::string::npos) return pos->first;
          }
          std::cout << "------------------------------------" << std::endl;
          std::cout << "INVALID INPUT: " << message << " VALID VALUES ARE: " << std::endl;        
          printAll();
          std::cout << "------------------------------------" << std::endl;
          return  -1;
        };

        void getStates(std::vector<int> &vecI, std::vector<std::string> &vecS ) {

                vecS.clear(); vecS.reserve(mapAlarmCondition.size());
                vecI.clear(); vecI.reserve(mapAlarmCondition.size());

                for (pos=mapAlarmCondition.begin(); pos != mapAlarmCondition.end(); ++pos) {
                        vecI.push_back(pos->first);
                        vecS.push_back(pos->second);
                }
                return;
        }


        void printAll() {
          std::cout << "-------------------" << std::endl;
          std::cout << "EPICS GLOBAL ALARM CONDITION LIST" << std::endl;
          std::cout << "-------------------" << std::endl;
          for (pos=mapAlarmCondition.begin(); pos != mapAlarmCondition.end(); ++pos) {
                if (pos->first < 10) {
                        std::cout << " " << pos->first << " " << pos->second << std::endl;
                }
                else {
                        std::cout << pos->first << " " << pos->second << std::endl;
                }
          }
          std::cout << "------------------" << std::endl;
        };

  };



class CAFEGlobalAlarmSeverity {
        typedef std::map<int, std::string> mapIntString;

private:
        mapIntString mapAlarmSeverity;
        mapIntString::iterator pos;

public:
  CAFEGlobalAlarmSeverity() {
          mapAlarmSeverity.insert(std::make_pair((int) SEV_NO_ALARM, "NO_ALARM"));
          mapAlarmSeverity.insert(std::make_pair((int) SEV_MINOR, "MINOR"));
          mapAlarmSeverity.insert(std::make_pair((int) SEV_MAJOR, "MAJOR"));
          mapAlarmSeverity.insert(std::make_pair((int) SEV_INVALID, "INVALID"));
  };

        ~CAFEGlobalAlarmSeverity() {};

        std::string asString (int i) {

          pos = mapAlarmSeverity.find(i);
          if (pos != mapAlarmSeverity.end()) {
                  return    pos->second;
          }


          std::ostringstream oss;
          if (i == -1) {
                  oss << "NO_DATA" ;
                  return oss.str();
          }
          std::cout << "--------------------------------------" << std::endl;
          oss << "INVALID ENUM VALUE: " << i ; //<< std::endl;
          std::cout << oss.str();
          std::cout << " VALID VALUES ARE: " << std::endl;
          printAll();
          std::cout << "--------------------------------------" << std::endl;
          return oss.str();
          };


        int asInt (std::string message) {
          for (pos=mapAlarmSeverity.begin(); pos != mapAlarmSeverity.end(); ++pos) {

                if (pos->second==message) return pos->first;
                // String searches such as s.find(s1) return string::npos on failure
                else if ( (pos->second).find(message)  != std::string::npos) return pos->first;
          }
          std::cout << "--------------------------------------" << std::endl;
          std::cout << "INVALID INPUT: " << message << " VALID VALUES ARE: " << std::endl;
          printAll();
          std::cout << "--------------------------------------" << std::endl;
          return  -1;
        };

        void getStates(std::vector<int> &vecI, std::vector<std::string> &vecS ) {

                vecS.clear(); vecS.reserve(mapAlarmSeverity.size());
                vecI.clear(); vecI.reserve(mapAlarmSeverity.size());

                for (pos=mapAlarmSeverity.begin(); pos != mapAlarmSeverity.end(); ++pos) {

                        vecI.push_back(pos->first);
                        vecS.push_back(pos->second);
                }
                return;
        }

        void printAll() {
          std::cout << "-------------------" << std::endl;
          std::cout << "EPICS GLOBAL ALARM SEVERITY LIST" << std::endl;
          std::cout << "-------------------" << std::endl;
          for (pos=mapAlarmSeverity.begin(); pos != mapAlarmSeverity.end(); ++pos) {
                std::cout << pos->first << " " << pos->second << std::endl;
          }
          std::cout << "------------------" << std::endl;
        };

  };



/* class StatusInfo provides information for user defined error/status codes
* and ca defined error/status codes \n
*    1 ECA_NORMAL \n
*   48 ECA_ALLOCMEM \n
*   72 ECA_TOLARGE \n
*   80 ECA_TIMEOUT \n
*  114 ECA_BADTYPE \n
*  142 ECA_INTERNAL \n
*  152 ECA_GETFAIL \n
*  160 ECA_PUTFAIL \n
*  176 ECA_BADCOUNT \n
*  186 ECA_BADSTR \n
*  192 ECA_DISCONN \n
*  200 ECA_DBLCHNL \n
*  210 ECA_EVDISALLOW \n
*  242 ECA_BADMONID \n
*  330 ECA_BADMASK \n
*  339 ECA_IODONE \n
*  347 ECA_IOINPROGRESS \n
*  354 ECA_BADSYNCGRP \n
*  362 ECA_PUTCBINPROG \n
*  368 ECA_NORDACCESS \n
*  376 ECA_NOWTACCESS \n
*  386 ECA_ANACHRONISM \n
*  392 ECA_NOSEARCHADDR \n
*  400 ECA_NOCONVERT \n
*  410 ECA_BADCHID \n
*  418 ECA_BADFUNCPTR \n
*  424 ECA_ISATTACHED \n
*  432 ECA_UNAVAILINSERV \n
*  440 ECA_CHANDESTROY \n
*  450 ECA_BADPRIORITY \n
*  458 ECA_NOTTHREADED \n
*  464 ECA_16KARRAYCLIENT \n
*  472 ECA_CONNSEQTMO \n
*  480 ECA_UNRESPTMO \n
*  600 ICAFE_CS_NEVER_CONN \n
*  601 ICAFE_CS_PREV_CONN \n
*  602 ICAFE_CS_CONN \n
*  603 ICAFE_CS_CLOSED \n
*  604 ICAFE_CS_DISCONN, \n
*  605 ICAFE_CS_UNKNOWN \n
*  700 ICAFE_TYPENOTCONN \n
*  701 ICAFE_RULE_FALSE \n
*  702 ICAFE_BADCOUNT \n
*  703 ICAFE_CALLBACK_NOT_YET_INVOKED \n
*  704 ICAFE_WAITING_FOR_PREV_CALLBACK \n
*  705 ICAFE_CACHE_EMPTY \n
*  706 ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT \n
*  707 ICAFE_MONITOR_DELAYED_AS_CONN_DOWN \n
*  708 ICAFE_HAS_MONITOR_GET_DONE_FROM_CACHE \n
*  709 ICAFE_SET_AND_GET_MISMATCH \n
*  806 ICAFE_CA_OP_CONN_UP \n
*  807 ICAFE_CA_OP_CONN_DOWN \n
* 1000 ECAFE_NODATA \n
* 1001 ECAFE_INVALID_TYPE \n
* 1002 ECAFE_BADCOUNT \n
* 1003 ECAFE_BADSTR \n
* 1004 ECAFE_BADTYPE \n
* 1005 ECAFE_NO_CONVERT \n
* 1006 ECAFE_NULLCONTEXT \n
* 1007 ECAFE_NULLCHID \n
* 1008 ECAFE_NULLEVID \n
* 1009 ECAFE_UNKNOWN_COLLECTION \n
* 1010 ECAFE_EMPTY_COLLECTION \n
* 1011 ECAFE_COLLECTION_PREV_DEF \n
* 1012 ECAFE_COLLECTION_INVALID_MEMBER \n
* 1013 ECAFE_RULE_FALSE \n
* 1014 ECAFE_UNKNOWN_GROUP \n
* 1015 ECAFE_EMPTY_GROUP \n
* 1016 ECAFE_GROUP_PREV_DEF \n
* 1017 ECAFE_INVALID_HANDLE \n
* 1018 ECAFE_INVALID_GROUP_HANDLE \n
* 1019 ECAFE_NORDACCESS \n
* 1020 ECAFE_NOWTACCESS \n
* 1021 ECAFE_TIMEOUT \n
* 1022 ECAFE_CANNOT_OPEN_FILE \n
* 1023 ECAFE_INVALID_SWITCH_CASE \n
* 1024 ECAFE_PVALIAS_INVALID \n
* 1025 ECAFE_PVALIAS_PREV_DEF \n
* 1026 ECAFE_PVNAME_PREV_DEF_AS_PVALIAS \n
* 1027 ECAFE_DEVICE_ATTRIB_NOT_FOUND \n
* 1028 ECAFE_HASH_UNIQUEID_EXISTS \n
* 1029 ECAFE_WRONG_CA_CONTEXT \n
* 1030 ECAFE_INVALID_CAFENUM_POLICY_TYPE \n
* 1031 ECAFE_MAX_MONITORS_PER_CHAN_EXCEEDED \n
* 1032 ECAFE_INVALID_ENUM_INDEX \n
* 1033 ECAFE_PVGROUP_GROUPHANDLE_MISMATCH \n
* 1034 ECAFE_TIMEOUT_SET_AND_MATCH \n
* 1035 ECAFE_HANDLE_MISMATCH_SET_AND_MATCH \n
* 1036 ECAFE_INCONSISTENT_CONTAINER_CORRECTED \n
* 1100 ECAFE_LOAD_COLLECTION \n
* 1101 ECAFE_LOAD_GROUP \n
* 1200 ECAFE_BPM_DATA_IS_INVALID \n
* 1300 ECAFE_BITSHUFF_DECOMPRESS \n
* 1301 ECAFE_BITSHUFF_ALLOCMEM \n
* 1302 ECAFE_BITSHUFF_REALLOCMEM \n
* 1302 ECAFE_BITSHUFF_BADCOUNT \n
* 1500 ECAFE_BSREAD_MULTIPART_MESS_NODATA \n
* 1501 ECAFE_BSREAD_PARSEFAIL_MAINHEADER \n
* 1502 ECAFE_BSREAD_PARSEFAIL_DATAHEADER \n
* 1503 ECAFE_BSREAD_ZMQSTREAM_NULL \n
* 5004 ERRNO_EINTR \n
* 5011 ERRNO_EGAIN \n
* 5014 ERRNO_EFAULT \n
* 5022 ERRNO_EINVAL Invalid argument \n
* 5088 ERRNO_ENOTSOCK \n
* 5093 ERRNO_EPROTONOSUPPORT \n
*/
class CAFEStatusInfo {
    typedef std::map<int, std::string> mapLongString;
private:  
    mapLongString mapStatusInfo;
    mapLongString::iterator posStatusInfo;

public:
    CAFEStatusInfo() {
    //maximum message length is 80 characters

    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CA_OP_CONN_UP,     "Status of channel connection: channel UP " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CA_OP_CONN_DOWN,   "Status of channel connection: channel DOWN! " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CS_NEVER_CONN,     "Valid chid; server not found or unavailable " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CS_PREV_CONN,      "Valid chid; previously connected to server " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CS_CONN,           "Valid chid; connected to server " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CS_CLOSED,         "Channel deleted by user " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CS_DISCONN,        "Channel disconnected " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CS_UNKNOWN,        "Unknown state!!! " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_TYPENOTCONN,       "ca_field_type() channel is disconnected " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_RULE_FALSE,        "CAFE collection rule for channel set to false by user " ));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_BADCOUNT,          "nelemClient exceeds nelemNative (max. allowed)! Set nelemClient/nelemRequest to nelemNative "));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CALLBACK_NOT_YET_INVOKED,  "Callback for get/set operation has not yet been invoked "));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_WAITING_FOR_PREV_CALLBACK, "Callback for previous get/set operation not yet invoked "));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CACHE_EMPTY,        "Data buffer is empty; get message to IOC not yet invoked"));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT, "User supplied callback function not provided when expected "));

    mapStatusInfo.insert(std::make_pair((int)  ICAFE_MONITOR_DELAYED_AS_CONN_DOWN, "Channel disconnected. Monitor will be started on connection "));
    mapStatusInfo.insert(std::make_pair((int)  ICAFE_HAS_MONITOR_GET_DONE_FROM_CACHE, "Handle has monitor, hence data retrieved from cache "));

    mapStatusInfo.insert(std::make_pair((int)  ICAFE_SET_AND_GET_MISMATCH, "Set and Get values from SetAndGetMethod do not match"));   


    mapStatusInfo.insert(std::make_pair((int)  ECAFE_NODATA,            "Requested data transfer is of zero length! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_INVALID_TYPE,      "Invalid data type! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BADCOUNT,          "nelemClient exceeds nelemNative (max. allowed)! Set nelemClient/nelemRequest to nelemNative "));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BADSTR,            "Empty string for process variable name! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BADTYPE,           "Invalid datatype! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_NO_CONVERT,        "set()/get() cannot convert to/from native datatype! " ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_NULLCONTEXT,  "Error: current context is null; CA not initialized. " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_NULLCHID,     "Error: chid is null!!  " ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_NULLEVID,                 "Monitor() evid is null! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_UNKNOWN_COLLECTION,       "CAFE collection is unknown/unregistered or invalid! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_EMPTY_COLLECTION,         "CAFE collection is empty; has no members! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_COLLECTION_PREV_DEF,      "CAFE collection with this name already exists! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_COLLECTION_INVALID_MEMBER,"Device is not a member of the CAFE collection! " ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_RULE_FALSE,          "CAFE rule for channel set to false by user " ));
    
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_UNKNOWN_GROUP,  "CAFE group is unknown/unregistered or invalid! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_EMPTY_GROUP,    "CAFE group is empty; has no members! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_GROUP_PREV_DEF, "CAFE group with this name already exists! " ));
    
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_INVALID_HANDLE,  "Handle does not exist! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_INVALID_GROUP_HANDLE,  "Group handle does not exist! " ));
    
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_NORDACCESS,  "Channel does not have READ access!  " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_NOWTACCESS,  "Channel does not have WRITE access! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_TIMEOUT,     "Callback function not activated within specified timeout period " ));
    
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_CANNOT_OPEN_FILE,          "Cannot open file! " ));
    
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_INVALID_SWITCH_CASE, "Internal CAFE Error: Invalid option for switch case " ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_PVALIAS_INVALID,     "Requested PVAlias is another handle's PV name. Bizarre! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_PVALIAS_PREV_DEF,    "Requested PVAlias already exists! " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_PVNAME_PREV_DEF_AS_PVALIAS, "PVName clashes with previously defined PVAlias!" ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_DEVICE_ATTRIB_NOT_FOUND, "Deliminator - hence dev/attrib - not found in PV name" ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_HASH_UNIQUEID_EXISTS,"cafeConduit object already inserted (handle exists) "));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_WRONG_CA_CONTEXT,"Operation cannot be carried out for this ca_client_context "));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_INVALID_CAFENUM_POLICY_TYPE, "Not a valid CAFENUM type for this policy. See policies.h "));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_MAX_MONITORS_PER_CHAN_EXCEEDED, "See define.sh to change the allowed maximum "));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_INVALID_ENUM_INDEX, "DBR_ENUM value exceeds the number of enum string options " ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_PVGROUP_GROUPHANDLE_MISMATCH, "PVGroup previously assigned to another group handle " ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_TIMEOUT_SET_AND_MATCH, "Readback channel did not reach set value within specified timeout period "));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_HANDLE_MISMATCH_SET_AND_MATCH, "Number of set/readback handles do not match"));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_INCONSISTENT_CONTAINER_CORRECTED, "Boost container required update after consistency check"));
 
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_LOAD_COLLECTION,     "CAFE collection could not be loaded from xml configuration file " ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_LOAD_GROUP,          "CAFE group could not be loaded from group xml configuration file " ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BPM_DATA_IS_INVALID, "CAFE BPM Service: Data Validity channel reports BPM data is INVALID " ));
   
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BITSHUFF_DECOMPRESS,  "Bitshuffle decompress failed within CAFE BS read" )); 
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BITSHUFF_ALLOCMEM,    "Bitshuffle memory allocation failed within CAFE BS read" ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BITSHUFF_REALLOCMEM,  "Bitshuffle memory reallocation failed within CAFE BS read" ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BITSHUFF_BADCOUNT,    "Bitshuffle data size is too small (<BSREAD_PREBLOB_BYTES)" ));

    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BSREAD_MULTIPART_MESS_NODATA, "No data for this channel from BS read" ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BSREAD_PARSEFAIL_MAINHEADER, "Main header in BS read could not be parsed" ));
    mapStatusInfo.insert(std::make_pair((int)  ECAFE_BSREAD_PARSEFAIL_DATAHEADER, "Data header in BS read could not be parsed" ));
                mapStatusInfo.insert(std::make_pair((int)  ECAFE_BSREAD_ZMQSTREAM_NULL, "ZMQ stream not created. Check configuration parameters"));
    mapStatusInfo.insert(std::make_pair((int)  ERRNO_EINTR,    "C ERRNO CODE: Interrupted system call" ));
    mapStatusInfo.insert(std::make_pair((int)  ERRNO_EAGAIN,   "C ERRNO CODE: Try again" ));
    mapStatusInfo.insert(std::make_pair((int)  ERRNO_EFAULT,   "C ERRNO CODE: Bad address" ));
                mapStatusInfo.insert(std::make_pair((int)  ERRNO_EINVAL,   "C ERROR CODE: Invalid argument" ));
    mapStatusInfo.insert(std::make_pair((int)  ERRNO_ENOTSOCK, "C ERRNO CODE: Socket operation on non-socket" ));
    mapStatusInfo.insert(std::make_pair((int)  ERRNO_EPROTONOSUPPORT,   "C ERRNO CODE: Protocol not supported" ));
}

  ~CAFEStatusInfo() {};
  

  std::string message (int i) {

    if (i<ICAFE_STATUS_BASE) {
        std::string c= ca_message(i);
        return c;
    }
    else {
        posStatusInfo = mapStatusInfo.find(i);
        if (posStatusInfo != mapStatusInfo.end()) {
            return    posStatusInfo->second;
        }

    std::ostringstream oss;
    oss << "INVALID ERROR CODE: " << i ; //<< std::endl;
    //std::cout << oss.str();

    return oss.str();

    }
  };



  void printAll() {
    std::cout << "-----------------------" << std::endl;
    std::cout << "CAFE ERROR MESSAGE LIST" << std::endl;
    std::cout << "-----------------------" << std::endl;
    for (posStatusInfo=mapStatusInfo.begin(); posStatusInfo != mapStatusInfo.end(); ++posStatusInfo) {
        std::cout << posStatusInfo->first << " " << posStatusInfo->second << std::endl;
    }
    std::cout << "------------------" << std::endl;
  };
};





class CAFEStatusCode {
    typedef std::map<int, std::string> mapLongString;
        
private:  
    mapLongString mapStatusCode;
    mapLongString::iterator pos;

public:
  CAFEStatusCode() {
    mapStatusCode.insert(std::make_pair(ECA_NORMAL,        "SUCCESS: ICAFE_NORMAL"));
    mapStatusCode.insert(std::make_pair(ECA_ALLOCMEM,      "WARNING: ECA_ALLOCMEM")); 
    mapStatusCode.insert(std::make_pair(ECA_TOLARGE,       "WARNING: ECA_TOLARGE"));
    mapStatusCode.insert(std::make_pair(ECA_TIMEOUT,       "WARNING: ECA_TIMEOUT"));
    mapStatusCode.insert(std::make_pair(ECA_BADTYPE,         "ERROR: ECA_BADTYPE"));
    mapStatusCode.insert(std::make_pair(ECA_INTERNAL,        "FATAL: ECA_INTERNAL")); 
    mapStatusCode.insert(std::make_pair(ECA_GETFAIL,       "WARNING: ECA_GETFAIL"));
    mapStatusCode.insert(std::make_pair(ECA_PUTFAIL,       "WARNING: ECA_PUTFAIL")); 
    mapStatusCode.insert(std::make_pair(ECA_BADCOUNT,      "WARNING: ECA_BADCOUNT"));
    mapStatusCode.insert(std::make_pair(ECA_BADSTR,          "ERROR: ECA_BADSTR"));
    mapStatusCode.insert(std::make_pair(ECA_DISCONN,       "WARNING: ECA_DISCONN"));
    mapStatusCode.insert(std::make_pair(ECA_DBLCHNL,       "WARNING: ECA_DBLCHNL"));
    mapStatusCode.insert(std::make_pair(ECA_EVDISALLOW,      "ERROR: ECA_EVDISALLOW"));
    mapStatusCode.insert(std::make_pair(ECA_BADMONID,        "ERROR: ECA_BADMONID"));
    mapStatusCode.insert(std::make_pair(ECA_BADMASK,         "ERROR: ECA_BADMASK"));
    mapStatusCode.insert(std::make_pair(ECA_IODONE ,          "INFO: ECA_IODONE "));
    mapStatusCode.insert(std::make_pair(ECA_IOINPROGRESS,     "INFO: ECA_IOINPROGRESS"));
    mapStatusCode.insert(std::make_pair(ECA_BADSYNCGRP,      "ERROR: ECA_BADSYNCGRP"));
    mapStatusCode.insert(std::make_pair(ECA_PUTCBINPROG,     "ERROR: ECA_PUTCBINPROG"));
    mapStatusCode.insert(std::make_pair(ECA_NORDACCESS,    "WARNING: ECA_NORDACCESS"));
    mapStatusCode.insert(std::make_pair(ECA_NOWTACCESS,    "WARNING: ECA_NOWTACCESS"));
    mapStatusCode.insert(std::make_pair(ECA_ANACHRONISM,     "ERROR: ECA_ANACHRONISM"));
    mapStatusCode.insert(std::make_pair(ECA_NOSEARCHADDR,  "WARNING: ECA_NOSEARCHADDR"));
    mapStatusCode.insert(std::make_pair(ECA_NOCONVERT,     "WARNING: ECA_NOCONVERT"));
    mapStatusCode.insert(std::make_pair(ECA_BADCHID,         "ERROR: ECA_BADCHID"));
    mapStatusCode.insert(std::make_pair(ECA_BADFUNCPTR,      "ERROR: ECA_BADFUNCPTR"));
    mapStatusCode.insert(std::make_pair(ECA_ISATTACHED,    "WARNING: ECA_ISATTACHED"));
    mapStatusCode.insert(std::make_pair(ECA_UNAVAILINSERV, "WARNING: ECA_UNAVAILINSERV"));
    mapStatusCode.insert(std::make_pair(ECA_CHANDESTROY,   "WARNING: ECA_CHANDESTROY"));
    mapStatusCode.insert(std::make_pair(ECA_BADPRIORITY,     "ERROR: ECA_BADPRIORITY"));
    mapStatusCode.insert(std::make_pair(ECA_NOTTHREADED,     "ERROR: ECA_NOTTHREADED"));
    mapStatusCode.insert(std::make_pair(ECA_16KARRAYCLIENT,"WARNING: ECA_16KARRAYCLIENT"));
    mapStatusCode.insert(std::make_pair(ECA_CONNSEQTMO,    "WARNING: ECA_CONNSEQTMO"));
    mapStatusCode.insert(std::make_pair(ECA_UNRESPTMO ,    "WARNING: ECA_UNRESPTMO"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CS_NEVER_CONN,   "CHANNEL STATE: ICAFE_CS_NEVER_CONN" ));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CS_PREV_CONN,    "CHANNEL STATE: ICAFE_CS_PREV_CONN " ));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CS_CONN,         "CHANNEL STATE: ICAFE_CS_CONN" ));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CS_CLOSED,       "CHANNEL STATE: ICAFE_CS_CLOSED" ));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CS_DISCONN,      "CHANNEL STATE: ICAFE_CS_DISCONN" ));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CS_UNKNOWN,      "CHANNEL STATE: ICAFE_CS_UNKNOWN" ));

    mapStatusCode.insert(std::make_pair((int)  ICAFE_TYPENOTCONN,     "CHANNEL FIELD TYPE: ICAFE_CFT_TYPENOTCONN"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_RULE_FALSE,      "CAFE INFO: ICAFE_RULE_FALSE"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_BADCOUNT,          "CAFE INFO: ICAFE_BADCOUNT"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CALLBACK_NOT_YET_INVOKED, "CAFE_INFO: ICAFE_CALLBACK_NOT_YET_INVOKED"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_WAITING_FOR_PREV_CALLBACK, "CAFE_INFO: ICAFE_WAITING_FOR_PREV_CALLBACK"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CACHE_EMPTY,     "CAFE_INFO:ICAFE_CACHE_EMPTY"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT, "CAFE_INFO: ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CA_OP_CONN_UP,   "CHANNEL CONNECTION: ICAFE_CC_OP_CONN_UP" ));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_CA_OP_CONN_DOWN, "CHANNEL CONNECTION: ICAFE_CC_OP_CONN_DOWN" ));

    mapStatusCode.insert(std::make_pair((int)  ICAFE_MONITOR_DELAYED_AS_CONN_DOWN, "CHANNEL CONNECTION: ICAFE_MONITOR_DELAYED_AS_CONN_DOWN"));
    mapStatusCode.insert(std::make_pair((int)  ICAFE_HAS_MONITOR_GET_DONE_FROM_CACHE, "CAFE_INFO: ICAFE_HAS_MONITOR_GET_DONE_FROM_CACHE"));

    mapStatusCode.insert(std::make_pair((int)  ICAFE_SET_AND_GET_MISMATCH, "CAFE_INFO: ICAFE_SET_AND_GET_MISMATCH"));

    mapStatusCode.insert(std::make_pair((int)  ECAFE_NODATA,          "CAFE ERROR: ECAFE_NODATA"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BADCOUNT,        "CAFE ERROR: ECAFE_BADCOUNT"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BADSTR,          "CAFE ERROR: ECAFE_BADSTR"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BADTYPE,         "CAFE ERROR: ECAFE_BADTYPE"));

    mapStatusCode.insert(std::make_pair((int)  ECAFE_NO_CONVERT,           "CAFE ERROR: ECAFE_NO_CONVERT"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_NULLCONTEXT,          "CAFE ERROR: ECAFE_NULLCONTEXT"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_NULLCHID,             "CAFE ERROR: ECAFE_NULLCHID"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_NULLEVID,             "CAFE ERROR: ECAFE_NULLEVID"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_UNKNOWN_COLLECTION,   "CAFE ERROR: ECAFE_UNKNOWN_COLLECTION"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_EMPTY_COLLECTION,     "CAFE ERROR: ECAFE_EMPTY_COLLECTION"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_COLLECTION_PREV_DEF,  "CAFE ERROR: ECAFE_COLLECTION_PREV_DEF"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_COLLECTION_INVALID_MEMBER,  "CAFE ERROR: ECAFE_COLLECTION_INVALID_MEMBER"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_RULE_FALSE,           "CAFE ERROR/INFO: ECAFE_RULE_FALSE"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_UNKNOWN_GROUP,        "CAFE ERROR: ECAFE_UNKNOWN_GROUP"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_EMPTY_GROUP,          "CAFE ERROR: ECAFE_EMPTY_GROUP"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_GROUP_PREV_DEF,       "CAFE ERROR: ECAFE_GROUP_PREV_DEF"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_INVALID_HANDLE,       "CAFE ERROR: ECAFE_INVALID_HANDLE"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_INVALID_GROUP_HANDLE, "CAFE ERROR: ECAFE_INVALID_GROUP_HANDLE"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_NORDACCESS,       "CAFE ERROR: ECAFE_NORDACCESS"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_NOWTACCESS,       "CAFE ERROR: ECAFE_NOWTACCESS"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_TIMEOUT,          "CAFE ERROR: ECAFE_TIMEOUT"));
    
    mapStatusCode.insert(std::make_pair((int)  ECAFE_CANNOT_OPEN_FILE,     "CAFE ERROR: ECAFE_CANNOT_OPEN_FILE"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_INVALID_SWITCH_CASE,  "CAFE ERROR: ECAFE_INVALID_SWITCH_CASE"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_PVALIAS_INVALID,      "CAFE ERROR: ECAFE_PVALIAS_INVALID"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_PVALIAS_PREV_DEF,     "CAFE ERROR: ECAFE_PVALIAS_PREV_DEF"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_PVNAME_PREV_DEF_AS_PVALIAS,"CAFE ERROR: ECAFE_PVNAME_PREV_DEF_AS_PVALIAS"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_DEVICE_ATTRIB_NOT_FOUND,"CAFE ERROR: ECAFE_DEVICE_ATTRIB_NOT_FOUND"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_HASH_UNIQUEID_EXISTS, "CAFE ERROR: ECAFE_HASH_UNIQUEID_EXISTS"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_WRONG_CA_CONTEXT,     "CAFE ERROR: ECAFE_WRONG_CA_CONTEXT"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_INVALID_CAFENUM_POLICY_TYPE, "CAFE ERROR: ECAFE_INVALID_CAFENUM_POLICY_TYPE"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_MAX_MONITORS_PER_CHAN_EXCEEDED, "CAFE_ERROR: ECAFE_MAX_MONITORS_PER_CHAN_EXCEEDED"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_INVALID_ENUM_INDEX,   "CAFE_ERROR: ECAFE_INVALID_ENUM_INDEX"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_PVGROUP_GROUPHANDLE_MISMATCH, "CAFE ERROR:ECAFE_PVGROUP_GROUPHANDLE_MISMATCH"));

    mapStatusCode.insert(std::make_pair((int)  ECAFE_TIMEOUT_SET_AND_MATCH, "CAFE ERROR: CAFE_TIMEOUT_SET_AND_MATCH"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_HANDLE_MISMATCH_SET_AND_MATCH, "CAFE ERROR: CAFE_HANDLE_MISMATCH_SET_AND_MATCH"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_INCONSISTENT_CONTAINER_CORRECTED,"CAFE ERROR: ECAFE_INCONSISTENT_CONTAINER_CORRECTED"));

    mapStatusCode.insert(std::make_pair((int)  ECAFE_LOAD_COLLECTION,      "CAFE ERROR: ECAFE_LOAD_COLLECTION"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_LOAD_GROUP,           "CAFE ERROR: ECAFE_LOAD_GROUP"));

    mapStatusCode.insert(std::make_pair((int)  ECAFE_BPM_DATA_IS_INVALID, "CAFE_ERROR: ECAFE_BPM_DATA_IS_INVALID" ));

    mapStatusCode.insert(std::make_pair((int)  ECAFE_BITSHUFF_DECOMPRESS,  "CAFE_ERROR: ECAFE_BITSHUF_DECOMPRESS" )); 
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BITSHUFF_REALLOCMEM,  "CAFE_WARN: ECAFE_BITSHUFF_REALLOCMEM" )); 
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BITSHUFF_ALLOCMEM,    "CAFE_ERROR: ECAFE_BITSHUFF_ALLOCMEM" )); 
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BITSHUFF_BADCOUNT,    "CAFE_ERROR: ECAFE_BITSHUFF_BADCOUNT" )); 

    mapStatusCode.insert(std::make_pair((int)  ECAFE_BSREAD_MULTIPART_MESS_NODATA, "CAFE_WARN: ECAFE_BSREAD_MULTIPART_MESS_NODATA"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BSREAD_PARSEFAIL_MAINHEADER,  "CAFE_ERROR: ECAFE_BSREAD_PARSEFAIL_MAINHEADER"));
    mapStatusCode.insert(std::make_pair((int)  ECAFE_BSREAD_PARSEFAIL_DATAHEADER,  "CAFE_ERROR: ECAFE_BSREAD_PARSEFAIL_DATAHEADER"));
                mapStatusCode.insert(std::make_pair((int)  ECAFE_BSREAD_ZMQSTREAM_NULL, "CAFE_WARN: ECAFE_BSREAD_ZMQSTREAM_NULL"));

    mapStatusCode.insert(std::make_pair((int)  ERRNO_EINTR,    "CAFE_ERROR: ERRNO_EINTR" ));
    mapStatusCode.insert(std::make_pair((int)  ERRNO_EAGAIN,   "CAFE_WARN: ERRNO_EAGAIN" ));
    mapStatusCode.insert(std::make_pair((int)  ERRNO_EFAULT,   "CAFE_ERROR: ERRNO_EFAULT" ));
                mapStatusCode.insert(std::make_pair((int)  ERRNO_EINVAL,   "CAFE_ERROR: ERRNO_EINVAL" ));
    mapStatusCode.insert(std::make_pair((int)  ERRNO_ENOTSOCK, "CAFE_ERROR: ERRNO_ENOTSOCK" ));
    mapStatusCode.insert(std::make_pair((int)  ERRNO_EPROTONOSUPPORT,   "CAFE_ERROR: ERRNO_EPROTONOSUPPORT" ));

};

  ~CAFEStatusCode() {};
  
  std::string message (int i) {
 
    pos = mapStatusCode.find(i);  
    if (pos != mapStatusCode.end()) {
        return    pos->second;
    }

    std::ostringstream oss;
    oss << "INVALID ERROR CODE: " << i ; //<< std::endl;
    //std::cout << oss.str();

    return oss.str();
    };


  void getStates(std::vector<int> &vecI, std::vector<std::string> &vecS ) {

          vecS.clear(); vecS.reserve(mapStatusCode.size());
          vecI.clear(); vecI.reserve(mapStatusCode.size());

          for (pos=mapStatusCode.begin(); pos != mapStatusCode.end(); ++pos) {
                  std::size_t found = (pos->second).find(": ");
                          if (found!=std::string::npos) {

                                  vecS.push_back((pos->second).substr(found+2,(pos->second).length()));
                          }
                          else {
                                  vecS.push_back(pos->second);
                          }
                  vecI.push_back(pos->first);
          }
          return;
  };

  std::string msgIDAsString (int i) {
                  
    pos = mapStatusCode.find(i);    
    if (pos != mapStatusCode.end()) {
                    std::size_t found = (pos->second).find(": ");
                                if (found!=std::string::npos) {
                                
                                        return (pos->second).substr(found+2,(pos->second).length());
                                }
                                else {
                return    pos->second;
                                }
    }

    std::ostringstream oss;
    oss << "INVALID ERROR CODE: " << i ; //<< std::endl;
    //std::cout << oss.str();

    return oss.str();
    };


  int enumIs (std::string message) {
    for (pos=mapStatusCode.begin(); pos != mapStatusCode.end(); ++pos) {

      if (pos->second==message) return pos->first; 
      // String searches such as s.find(s1) return string::npos on failure
      else if ( (pos->second).find(message)  != std::string::npos) return pos->first;
    }
    return  -1;
  };
        
        bool isTimeout(int statusCodeToCheck) {
                 if (statusCodeToCheck==ECA_TIMEOUT || statusCodeToCheck==ECAFE_TIMEOUT) {
                 return true; 
                 }
                 else {return false;}
        }

  void printAll() {
    std::cout << "-------------------" << std::endl;
    std::cout << "CAFE ERROR CODE LIST" << std::endl;
    std::cout << "-------------------" << std::endl;
    for (pos=mapStatusCode.begin(); pos != mapStatusCode.end(); ++pos) {
      std::cout << pos->first << " " << pos->second << std::endl;
    }
    std::cout << "------------------" << std::endl;
  };

};



class CAFEStatusSeverity {
    typedef std::map<int, std::string> mapLongString;
        
private:  
    mapLongString mapStatusSeverity;
    mapLongString::iterator pos;

public:
  CAFEStatusSeverity() {
    mapStatusSeverity.insert(std::make_pair(ECA_NORMAL,        "INFO"));
    mapStatusSeverity.insert(std::make_pair(ECA_ALLOCMEM,      "WARN")); 
    mapStatusSeverity.insert(std::make_pair(ECA_TOLARGE,       "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_TIMEOUT,       "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADTYPE,       "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_INTERNAL,      "FATAL")); 
    mapStatusSeverity.insert(std::make_pair(ECA_GETFAIL,       "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_PUTFAIL,       "WARN")); 
    mapStatusSeverity.insert(std::make_pair(ECA_BADCOUNT,      "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADSTR,        "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_DISCONN,       "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_DBLCHNL,       "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_EVDISALLOW,    "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADMONID,      "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADMASK,       "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_IODONE ,       "INFO"));
    mapStatusSeverity.insert(std::make_pair(ECA_IOINPROGRESS,  "INFO"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADSYNCGRP,    "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_PUTCBINPROG,   "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_NORDACCESS,    "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_NOWTACCESS,    "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_ANACHRONISM,   "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_NOSEARCHADDR,  "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_NOCONVERT,     "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADCHID,       "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADFUNCPTR,    "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_ISATTACHED,    "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_UNAVAILINSERV, "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_CHANDESTROY,   "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_BADPRIORITY,   "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_NOTTHREADED,   "ERROR"));
    mapStatusSeverity.insert(std::make_pair(ECA_16KARRAYCLIENT,"WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_CONNSEQTMO,    "WARN"));
    mapStatusSeverity.insert(std::make_pair(ECA_UNRESPTMO ,    "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CS_NEVER_CONN,   "WARN" ));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CS_PREV_CONN,    "INFO" ));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CS_CONN,         "INFO" ));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CS_CLOSED,       "INFO" ));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CS_DISCONN,      "WARN" ));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CS_UNKNOWN,      "ERROR" ));

    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_TYPENOTCONN,      "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_RULE_FALSE,      "INFO"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_BADCOUNT,        "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CALLBACK_NOT_YET_INVOKED,  "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_WAITING_FOR_PREV_CALLBACK, "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CACHE_EMPTY,     "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT, "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CA_OP_CONN_UP,   "INFO" ));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_CA_OP_CONN_DOWN, "WARN" ));

    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_MONITOR_DELAYED_AS_CONN_DOWN, "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_HAS_MONITOR_GET_DONE_FROM_CACHE, "INFO"));

    mapStatusSeverity.insert(std::make_pair((int)  ICAFE_SET_AND_GET_MISMATCH, "WARN"));

    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_NODATA,          "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BADCOUNT,        "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BADSTR,          "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BADTYPE,         "ERROR"));

    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_NO_CONVERT,           "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_NULLCONTEXT,          "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_NULLCHID,             "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_NULLEVID,             "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_UNKNOWN_COLLECTION,   "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_EMPTY_COLLECTION,     "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_COLLECTION_PREV_DEF,  "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_COLLECTION_INVALID_MEMBER,  "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_RULE_FALSE,           "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_UNKNOWN_GROUP,        "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_EMPTY_GROUP,          "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_GROUP_PREV_DEF,       "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_INVALID_HANDLE,       "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_INVALID_GROUP_HANDLE, "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_NORDACCESS,           "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_NOWTACCESS,           "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_TIMEOUT,              "WARN"));
    

    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_CANNOT_OPEN_FILE,     "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_INVALID_SWITCH_CASE,  "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_PVALIAS_INVALID,      "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_PVALIAS_PREV_DEF,     "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_PVNAME_PREV_DEF_AS_PVALIAS,"ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_DEVICE_ATTRIB_NOT_FOUND,"ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_HASH_UNIQUEID_EXISTS, "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_WRONG_CA_CONTEXT,     "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_INVALID_CAFENUM_POLICY_TYPE, "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_MAX_MONITORS_PER_CHAN_EXCEEDED, "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_INVALID_ENUM_INDEX,   "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_PVGROUP_GROUPHANDLE_MISMATCH, "ERROR"));

    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_TIMEOUT_SET_AND_MATCH, "WARN"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_HANDLE_MISMATCH_SET_AND_MATCH, "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_INCONSISTENT_CONTAINER_CORRECTED, "WARN"));

    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_LOAD_COLLECTION,      "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_LOAD_GROUP,           "ERROR"));

    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BPM_DATA_IS_INVALID,  "WARN" ));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BITSHUFF_DECOMPRESS,  "ERROR")); 
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BITSHUFF_ALLOCMEM,    "ERROR" )); 
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BITSHUFF_REALLOCMEM,  "WARN" ));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BITSHUFF_BADCOUNT,    "ERROR" )); 
  
          mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BSREAD_MULTIPART_MESS_NODATA, "WARN" ));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BSREAD_PARSEFAIL_MAINHEADER,  "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BSREAD_PARSEFAIL_DATAHEADER,  "ERROR"));
                mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BSREAD_ZMQSTREAM_NULL,        "WARN"));

    mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EINTR,     "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EAGAIN,    "WARN" ));
    mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EFAULT,    "ERROR"));
                mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EINVAL,    "ERROR" ));
    mapStatusSeverity.insert(std::make_pair((int)  ERRNO_ENOTSOCK,  "ERROR"));
    mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EPROTONOSUPPORT, "ERROR"  ));

};

  ~CAFEStatusSeverity() {};
  
  std::string message (int i) {   
    pos = mapStatusSeverity.find(i);    
    if (pos != mapStatusSeverity.end()) {
        return    pos->second;
    }

    std::ostringstream oss;
    oss << "INVALID ERROR CODE: " << i ; //<< std::endl;
    //std::cout << oss.str();

    return oss.str();
    };

  int enumIs (std::string message) {
    for (pos=mapStatusSeverity.begin(); pos != mapStatusSeverity.end(); ++pos) {

      if (pos->second==message) return pos->first; 
      // String searches such as s.find(s1) return string::npos on failure
      else if ( (pos->second).find(message)  != std::string::npos) return pos->first;
    }
    return  -1;
  };

  void printAll() {
    std::cout << "-------------------" << std::endl;
    std::cout << "CAFE STATUS SEVERITY LIST" << std::endl;
    std::cout << "-------------------" << std::endl;
    for (pos=mapStatusSeverity.begin(); pos != mapStatusSeverity.end(); ++pos) {
      std::cout << pos->first << " " << pos->second << std::endl;
    }
    std::cout << "------------------" << std::endl;
  };

};

//Example
//For statusCode=0, we have
//severity: INFO
//asString: ECA_NORMAL or ICAFE_NORMAL as from Feb. 2018) 
//msgID:    ECA_NORMAL 
//code:     SUCCESS: ECA_NORMAL
//info:     Normal successful completion
//message:  SUCCESS: ECA_NORMAL Normal successful completion
class CAFEStatus {

    public:  
                CAFEStatusSeverity css; 
    CAFEStatusInfo csi;
    CAFEStatusCode csc;
    CAFEStatus() {};
                                
                std::string severity(int i) {
                        return (std::string) css.message(i); 
                }
                
                std::string asString(int i) {
                        return (std::string) csc.msgIDAsString(i);
                }

                std::string msgID(int i) {
                        return (std::string) csc.msgIDAsString(i); 
                }
                
                std::string code(int i) {
                        return (std::string) csc.message(i); 
                }
    
                std::string info(int i) {
                        return (std::string) csi.message(i); 
                }    

                std::string message(int i) {
                        std::string strRet="";
                        strRet.append(csc.message(i));
                        strRet.append(" ");
                        strRet.append(csi.message(i));
                        return (std::string) strRet; 
                }
                
                bool isTimeout(int i) {
                        return csc.isTimeout(i);
                }

        void report (int i) {
        //std::cout << "------------------" << std::endl;
        //std::cout << "CAFE STATUS REPORT" << std::endl;
        std::cout << "------------------------------------" << std::endl;
        std::cout << csc.message(i)       << std::endl;
        std::cout << csi.message(i)       << std::endl;
        std::cout << "------------------------------------" << std::endl;
    };
};

#endif // STATUSCODES_H