AlarmField.h

Go to the documentation of this file.

//Copyright GSI 2012
#ifndef ALARM_FIELD_H_
#define ALARM_FIELD_H_

#include <fesa-core/DataStore/FaultField.h>
#include <fesa-core-gsi/DataStore/TypeDefinition.h>
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core-gsi/Exception/GSIException.h>
#include <fesa-core-gsi/DataStore/ConverterAlarmField.h>

namespace fesaGSI
{

    template<typename AlarmDataType, unsigned int userKeyNb>
    class AlarmField: public fesa::FaultField<AlarmDataType>
    {
        public:

                            AlarmField(const std::string& name, bool multiplexed, fesa::DataStore* pDataStore,
                                            const std::string& description, fesa::FaultSeverity severity,
                                            const char** userKeyNames = 0);

            ~AlarmField();

            const char** getUserKeyNames(unsigned int& size, fesa::MultiplexingContext* pCtx);

            const char** getUserKeyValues(unsigned int& size, fesa::MultiplexingContext* pCtx);

            const char* getUserKeyValue(const char* userKeyName, fesa::MultiplexingContext* pCtx);

            void setUserKeyValue(const char* userKeyName, const char* userKeyValue, fesa::MultiplexingContext* pCtx);

            void lower(long long time, fesa::MultiplexingContext* pCtx);

            void lower(fesa::MultiplexingContext* pCtx);

        protected:
            char userKeyNameCol_[userKeyNb][KEY_VALUE_MAXSIZE];
            char** pUserKeyNameCol_;
            char* pUserKeyName_[userKeyNb];

            void cleanAlarmMessages(fesa::MultiplexingContext* pCtx);

    };

    template<typename AlarmDataType, unsigned int userKeyNb>
    AlarmField<AlarmDataType, userKeyNb>::AlarmField(const std::string& name, bool multiplexed,
                    fesa::DataStore* pDataStore, const std::string& description, fesa::FaultSeverity severity,
                    const char** userKeyNames) :
        fesa::FaultField<AlarmDataType>(name, multiplexed, pDataStore, description, severity)
    {
        memset(userKeyNameCol_, '\0', (userKeyNb*KEY_VALUE_MAXSIZE));
        pUserKeyNameCol_ = &pUserKeyName_[0];
        for (unsigned int i = 0; i < userKeyNb; i++)
        {
            pUserKeyName_[i] = userKeyNameCol_[i];
            strcpy(userKeyNameCol_[i],userKeyNames[i]);
        }
    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    AlarmField<AlarmDataType, userKeyNb>::~AlarmField()
    {

    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    const char** AlarmField<AlarmDataType, userKeyNb>::getUserKeyNames(unsigned int& size,
                    fesa::MultiplexingContext* pCtx)
    {
        size = userKeyNb;
        return (const char**) pUserKeyNameCol_;
    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    const char** AlarmField<AlarmDataType, userKeyNb>::getUserKeyValues(unsigned int& size,
                    fesa::MultiplexingContext* pCtx)
    {
        if (userKeyNb == 0)
        {
            throw GSIException(__FILE__, __LINE__,FesaGSIErrorAlarmFieldEmptyKeyValues.c_str());
        }
        size = userKeyNb;
        unsigned int slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);
        return ((const char**) this->getFieldValue(slot)->activeBuffer().pUserKeyValueCol_);
    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    const char* AlarmField<AlarmDataType, userKeyNb>::getUserKeyValue(const char* userKeyName,
                    fesa::MultiplexingContext* pCtx)
    {
        if (userKeyNb == 0)
        {
            throw GSIException(__FILE__, __LINE__,FesaGSIErrorAlarmFieldEmptyKeyValues.c_str());
        }
        unsigned int i;
        for (i = 0; i < userKeyNb; i++)
        {
            if(!strcmp(userKeyNameCol_[i], userKeyName))
            {
                break;
            }
        }
        if (i == userKeyNb)
        {
            throw GSIException(__FILE__, __LINE__,FesaGSIErrorAlarmFieldKeyNameNotFound.c_str());
        }
        unsigned int slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);
        return ((const char*) this->getFieldValue(slot)->activeBuffer().userKeyValueCol_[i]);
    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    void AlarmField<AlarmDataType, userKeyNb>::setUserKeyValue(const char* userKeyName, const char* userKeyValue,
                    fesa::MultiplexingContext* pCtx)
    {
        if (strlen(userKeyName) > KEY_VALUE_MAXSIZE)
        {
            throw GSIException(__FILE__, __LINE__,FesaGSIErrorAlarmFieldKeyNameExceedsMaxSize.c_str());
        }
        unsigned int i;
        for (i = 0; i < userKeyNb; i++)
        {
            if(!strcmp(userKeyNameCol_[i], userKeyName))
            {
                break;
            }
        }
        if (i == userKeyNb)
        {
            throw GSIException(__FILE__, __LINE__,FesaGSIErrorAlarmFieldKeyNameNotFound.c_str());
        }
        unsigned int slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);
        AlarmField_DataType<userKeyNb>* pActiveBuffer = &(this->getFieldValue(slot)->activeBuffer());
        strcpy(pActiveBuffer->userKeyValueCol_[i], userKeyValue);
    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    void AlarmField<AlarmDataType, userKeyNb>::lower(long long time, fesa::MultiplexingContext* pCtx)
    {
        cleanAlarmMessages(pCtx);
        fesa::FaultField<AlarmDataType>::lower(time, pCtx);
    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    void AlarmField<AlarmDataType, userKeyNb>::lower(fesa::MultiplexingContext* pCtx)
    {
        cleanAlarmMessages(pCtx);
        fesa::FaultField<AlarmDataType>::lower(pCtx);
    }

    template<typename AlarmDataType, unsigned int userKeyNb>
    void AlarmField<AlarmDataType, userKeyNb>::cleanAlarmMessages(fesa::MultiplexingContext* pCtx)
    {
     unsigned int slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);
     
        char* addr = (char*)this->getFieldValue(slot);

                       AlarmField_DataType<userKeyNb>* pActiveBuffer = &(this->getFieldValue(slot)->activeBuffer(addr));
                       for (unsigned int i = 0; i < userKeyNb; i++)
                       {
                           pActiveBuffer->userKeyValueCol_[i][0] = '\0';
                       }
    }

}
// namespace end

#endif /* ALARM_FIELD_H_ */