///
/// \file statusCodes.h
///
/// class StatusInfo - contains user defined messages (>ICAFE_STATUS_BASE)
///                    and ca_message() output string
///
/// class StatusMap  - contains ECA and ECAFE error strings plus ICAFE info strings
///
/// class Status     - contains both above classes by composition
///
/// \author  Jan Chrin, PSI
/// \date    Release: Feb. 2015
///          Revised: May  2017
///          Added CAFEGlobalAlarmStatus and CAFEGlobalAlarmSeverity
/// \version CAFE 1.1.0
///
/// JC, Dec. 2015, additional methods to CAFEStatus
///


#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_DAQ    =  900; // for use in HLAs
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_DAQ_STATE {   ICAFE_DAQ_RUN= ICAFE_STATUS_DAQ,
                        ICAFE_DAQ_PAUSED,
                        ICAFE_DAQ_STOPPED
                    };

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 "NO_DATA"; //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 "NO_DATA"; //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
*  900 ICAFE_DAQ_RUN \n
*  901 ICAFE_DAQ_PAUSED \n
*  902 ICAFE_DAQ_STOPPED \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_EAGAIN \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 closed 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)  ICAFE_DAQ_RUN,           "HLA DAQ in progress " ));
        mapStatusInfo.insert(std::make_pair((int)  ICAFE_DAQ_PAUSED,        "HLA DAQ has been paused " ));
        mapStatusInfo.insert(std::make_pair((int)  ICAFE_DAQ_STOPPED,       "HLA DAQ has been stopped " ));

        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_CA_OP_CONN_UP" ));
        mapStatusCode.insert(std::make_pair((int)  ICAFE_CA_OP_CONN_DOWN, "CHANNEL CONNECTION: ICAFE_CA_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)  ICAFE_DAQ_RUN,           "CAFE INFO: ICAFE_DAQ_RUN" ));
        mapStatusCode.insert(std::make_pair((int)  ICAFE_DAQ_PAUSED,        "CAFE INFO: ICAFE_DAQ_PAUSED" ));
        mapStatusCode.insert(std::make_pair((int)  ICAFE_DAQ_STOPPED,       "CAFE INFO: ICAFE_DAQ_STOPPED" ));

        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)  ICAFE_DAQ_RUN,      "INFO" ));
        mapStatusSeverity.insert(std::make_pair((int)  ICAFE_DAQ_PAUSED,   "INFO" ));
        mapStatusSeverity.insert(std::make_pair((int)  ICAFE_DAQ_STOPPED,  "INFO" ));

        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