defines.hpp

Go to the documentation of this file.

#ifndef IFW_CTD_DEFINES_HPP_
#define IFW_CTD_DEFINES_HPP_

#include <stdarg.h>
#include <string>
#include <map>
#include <list>
#include <fstream>

#include "rad/Logger.hpp"
#include "rad/Exceptions.hpp"

namespace ifw {

std::string Print(const char* format, ...);

}

namespace ctd {
namespace defines {

using IsoTime = std::string;


typedef enum {
    DATA_TYPE_BOOLEAN   =     1,
    DATA_TYPE_INT8      =     2,
    DATA_TYPE_UINT8     =     4,
    DATA_TYPE_INT16     =     8,
    DATA_TYPE_UINT16    =    16,
    DATA_TYPE_INT32     =    32,
    DATA_TYPE_UINT32    =    64,
    DATA_TYPE_INT64     =   128,
    DATA_TYPE_UINT64    =   256,
    DATA_TYPE_FLOAT     =   512,
    DATA_TYPE_DOUBLE    =  1024,
    DATA_TYPE_STRING    =  2048,
    DATA_TYPE_NON_BASIC =  4096,
    DATA_TYPE_TIME_DATE =  8192,
    DATA_TYPE_TIMESTAMP = 16384,
    DATA_TYPE_BLOB      = 32768,
    DATA_TYPE_ALL       = (DATA_TYPE_BOOLEAN | DATA_TYPE_INT8      | DATA_TYPE_UINT8
    | DATA_TYPE_INT16  | DATA_TYPE_UINT16    | DATA_TYPE_INT32     | DATA_TYPE_UINT32
    | DATA_TYPE_INT64  | DATA_TYPE_UINT64    | DATA_TYPE_FLOAT     | DATA_TYPE_DOUBLE
    | DATA_TYPE_STRING | DATA_TYPE_NON_BASIC | DATA_TYPE_TIME_DATE | DATA_TYPE_TIMESTAMP
    | DATA_TYPE_BLOB),
    DATA_TYPE_UNKNOWN   = 2147483648
} DataType;

const std::string DATA_TYPE_BOOLEAN_STR    = "Boolean";
const std::string DATA_TYPE_INT8_STR       = "Int8";
const std::string DATA_TYPE_UINT8_STR      = "UInt8";
const std::string DATA_TYPE_INT16_STR      = "Int16";
const std::string DATA_TYPE_UINT16_STR     = "UInt16";
const std::string DATA_TYPE_INT32_STR      = "Int32";
const std::string DATA_TYPE_UINT32_STR     = "UInt32";
const std::string DATA_TYPE_INT64_STR      = "Int64";
const std::string DATA_TYPE_UINT64_STR     = "UInt64";
const std::string DATA_TYPE_FLOAT_STR      = "Float";
const std::string DATA_TYPE_DOUBLE_STR     = "Double";
const std::string DATA_TYPE_STRING_STR     = "String";
const std::string DATA_TYPE_NON_BASIC_STR  = "NonBasic";
const std::string DATA_TYPE_TIME_DATE_STR  = "TimeDate";
const std::string DATA_TYPE_TIMESTAMP_STR  = "TimeStamp";
const std::string DATA_TYPE_BLOB_STR       = "Blob";
const std::string DATA_TYPE_UNKNOWN_STR    = "Unknown";
static const std::map<DataType, std::string> s_data_types_nb_map =
{
    {DATA_TYPE_BOOLEAN,   DATA_TYPE_BOOLEAN_STR},
    {DATA_TYPE_INT8,      DATA_TYPE_INT8_STR},
    {DATA_TYPE_UINT8,     DATA_TYPE_UINT8_STR},
    {DATA_TYPE_INT16,     DATA_TYPE_INT16_STR},
    {DATA_TYPE_UINT16,    DATA_TYPE_UINT16_STR},
    {DATA_TYPE_INT32,     DATA_TYPE_INT32_STR},
    {DATA_TYPE_UINT32,    DATA_TYPE_UINT32_STR},
    {DATA_TYPE_INT64,     DATA_TYPE_INT64_STR},
    {DATA_TYPE_UINT64,    DATA_TYPE_UINT64_STR},
    {DATA_TYPE_FLOAT,     DATA_TYPE_FLOAT_STR},
    {DATA_TYPE_DOUBLE,    DATA_TYPE_DOUBLE_STR},
    {DATA_TYPE_STRING,    DATA_TYPE_STRING_STR},
    {DATA_TYPE_NON_BASIC, DATA_TYPE_NON_BASIC_STR},
    {DATA_TYPE_TIME_DATE, DATA_TYPE_TIME_DATE_STR},
    {DATA_TYPE_TIMESTAMP, DATA_TYPE_TIMESTAMP_STR},
    {DATA_TYPE_BLOB,      DATA_TYPE_BLOB_STR},
    {DATA_TYPE_UNKNOWN,   DATA_TYPE_UNKNOWN_STR}
};

static const std::map<std::string, DataType> s_data_types_name_map =
{
    {DATA_TYPE_BOOLEAN_STR,   DATA_TYPE_BOOLEAN},
    {DATA_TYPE_INT8_STR,      DATA_TYPE_INT8},
    {DATA_TYPE_UINT8_STR,     DATA_TYPE_UINT8},
    {DATA_TYPE_INT16_STR,     DATA_TYPE_INT16},
    {DATA_TYPE_UINT16_STR,    DATA_TYPE_UINT16},
    {DATA_TYPE_INT32_STR,     DATA_TYPE_INT32},
    {DATA_TYPE_UINT32_STR,    DATA_TYPE_UINT32},
    {DATA_TYPE_INT64_STR,     DATA_TYPE_INT64},
    {DATA_TYPE_UINT64_STR,    DATA_TYPE_UINT64},
    {DATA_TYPE_FLOAT_STR,     DATA_TYPE_FLOAT},
    {DATA_TYPE_DOUBLE_STR,    DATA_TYPE_DOUBLE},
    {DATA_TYPE_STRING_STR,    DATA_TYPE_STRING},
    {DATA_TYPE_NON_BASIC_STR, DATA_TYPE_NON_BASIC},
    {DATA_TYPE_TIME_DATE_STR, DATA_TYPE_TIME_DATE},
    {DATA_TYPE_TIMESTAMP_STR, DATA_TYPE_TIMESTAMP},
    {DATA_TYPE_BLOB_STR,      DATA_TYPE_BLOB},
    {DATA_TYPE_UNKNOWN_STR,   DATA_TYPE_UNKNOWN}
};

const std::map<DataType, std::string>& DataTypesNbMap();

const std::map<std::string, DataType>& DataTypesNameMap();

DataType IfwDataTypeToNumeric(const std::string& data_type);

std::string IfwDataTypeToString(const DataType data_type);

static const std::map<DataType, std::string> s_data_type_2_type_id_map =
{
    {DATA_TYPE_BOOLEAN,   typeid(bool).name()},
    {DATA_TYPE_INT8,      typeid(int8_t).name()},
    {DATA_TYPE_UINT8,     typeid(uint8_t).name()},
    {DATA_TYPE_INT16,     typeid(int16_t).name()},
    {DATA_TYPE_UINT16,    typeid(uint16_t).name()},
    {DATA_TYPE_INT32,     typeid(int32_t).name()},
    {DATA_TYPE_UINT32,    typeid(uint32_t).name()},
    {DATA_TYPE_INT64,     typeid(int64_t).name()},
    {DATA_TYPE_UINT64,    typeid(uint64_t).name()},
    {DATA_TYPE_FLOAT,     typeid(float).name()},
    {DATA_TYPE_DOUBLE,    typeid(double).name()},
    {DATA_TYPE_STRING,    typeid(std::string).name()}
};
// @todo: Support:
// DATA_TYPE_NON_BASIC
// DATA_TYPE_TIME_DATE
// {DATA_TYPE_TIMESTAMP
// DATA_TYPE_BLOB

static const std::map<std::string, DataType> s_type_id_2_data_type_map =
{
    {typeid(bool).name(),        DATA_TYPE_BOOLEAN},
    {typeid(int8_t).name(),      DATA_TYPE_INT8},
    {typeid(uint8_t).name(),     DATA_TYPE_UINT8},
    {typeid(int16_t).name(),     DATA_TYPE_INT16},
    {typeid(uint16_t).name(),    DATA_TYPE_UINT16},
    {typeid(int32_t).name(),     DATA_TYPE_INT32},
    {typeid(uint32_t).name(),    DATA_TYPE_UINT32},
    {typeid(int64_t).name(),     DATA_TYPE_INT64},
    {typeid(uint64_t).name(),    DATA_TYPE_UINT64},
    {typeid(float).name(),       DATA_TYPE_FLOAT},
    {typeid(double).name(),      DATA_TYPE_DOUBLE},
    {typeid(std::string).name(), DATA_TYPE_STRING}
};

const std::map<DataType, std::string>& DataType2TypeIdMap();

const std::map<std::string, DataType>& TypeId2DataTypeMap();

template <class TYPE> bool SupportedType(const TYPE& variable) {
    RAD_LOG_TRACE();

    return (TypeId2DataTypeMap().find(typeid(variable).name()) != TypeId2DataTypeMap().end());
}

const std::string EXT_FITS    = "fits";
const std::string EXT_YAML    = "yaml";
const std::string EXT_XML     = "xml";
const std::string EXT_CONFIG  = "config";
const std::string TRUE_STR             = "True";
const std::string FALSE_STR            = "False";

const int64_t     NO_TIMEOUT           = -1;
const std::string NO_TIMEOUT_STR       = "NoTimeout";

const int64_t     ERROR                = -1;
const std::string ERROR_STR            = "Error";

const int64_t     ILLEGAL              = -3;
const std::string ILLEGAL_STR          = "Illegal";

const int64_t     INVALID              = -4;
const std::string INVALID_STR          = "__INVALID__";

const int64_t     NOT_IMPLEMENTED      = -5;
const std::string NOT_IMPLEMENTED_STR  = "NotImplemented";

const int64_t     UNDEFINED            = -6;
const std::string UNDEFINED_STR        = "__UNDEFINED__";

const int64_t     UNKNOWN              = -7;
const std::string UNKNOWN_STR          = "Unknown";

const int64_t     FAILURE              = -8;
const std::string FAILURE_STR          = "Failure";

const int64_t      SUCCESS             = 0;
const std::string  SUCCESS_STR         = "Success";

const std::string  INDEFINITE_STR      = "Indefinite";
const std::string  ALL_STR             = "All";
const std::string  NONE_STR            = "None";
const std::string  COMPLETED_STR       = "Completed";
const std::string  PROCESSING_STR      = "Processing";
const std::string  BUSY_STR            = "Busy";
const std::string  ACTIVE_STR          = "Active";
const std::string  MOVING_STR          = "Moving";
const std::string  WARMING_UP_STR      = "WarmingUp";
const std::string  COOLING_DOWN_STR    = "CoolingDown";
const std::string  INITIALIZING_STR    = "Initializing";
const std::string  OFFSETTING_STR      = "Offsetting";
const std::string  CALIBRATING_STR     = "Calibrating";
const std::string  ADJUSTING_STR       = "Adjusting";
const std::string  RECEIVING_STR       = "Receiving";
const std::string  TRANSFERRING_STR    = "Transferring";
const std::string  STORING_STR         = "Storing";
const std::string  READING_STR         = "Reading";
const std::string  LOADING_STR         = "Loading";
const std::string  PARSING_STR         = "Parsing";
const std::string  ACQUIRING_STR       = "Acquiring";
const std::string  INSTALLING_STR      = "Installing";
const std::string  ON_STR              = "On";
const std::string  OFF_STR             = "Off";
const std::string  OK_STR              = "OK";
const std::string  NOT_OK_STR          = "NOK";
template <class TYPE> class List: public std::list<TYPE> {
public:
    TYPE& operator[] (const int32_t index) {
        typename List<TYPE>::iterator list_it = this->begin();
        std::advance(list_it, index);
        return *list_it;
    }
};

template <class TYPE> void CleanList(
        const List<TYPE>& list,
        const TYPE& pattern,
        List<TYPE>& clean_list) {

    typename List<TYPE>::iterator list_it;
    for (list_it = list.begin(); list_it != list.end(); list_it++) {
        if (*list_it != pattern) {
            clean_list.push_back(*list_it);
        }
    }
}

template <class TYPE> void CheckRange(const std::string& par,
                                      TYPE value,
                                      TYPE lower_limit,
                                      TYPE upper_limit);

template <class TYPE> void CheckRange(const std::string& par,
                                      const TYPE& value,
                                      List<TYPE>& valid_values);

template <class TYPE> int32_t ElInList(
        const List<TYPE>& list,
        const TYPE& value) {

    int32_t i = 0;
    for (auto list_it = list.begin(); list_it != list.end(); list_it++, i++) {
        if (*list_it == value) {
            return i;
        }
    }
    return -1;
}

template <class TYPE> std::string DumpList(
        const List<TYPE>& list,
        const std::string& separator = "\n") {

    std::stringstream tmp_buf;
    int32_t i = 0;
    for (auto list_it = list.begin(); list_it != list.end(); list_it++, i++) {
        tmp_buf << *list_it << separator;
    }
    return tmp_buf.str();
}

template <class MAP_TYPE> bool ElInMap(const std::string& key,
                                       const MAP_TYPE& map) {
    return (map.find(key) != map.end());
}

} // namespace ctd
} // namespace defines

void IFW_DEBUG(const char* format, ...);


#endif // IFW_CTD_DEFINES_HPP_