FaultField.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef FAULT_FIELD_H_
#define FAULT_FIELD_H_

#include <fesa-core/DataStore/GenericField.h>
#include <fesa-core/DataStore/AbstractFaultField.h>
#include <fesa-core/DataStore/TypeDefinition.h>

#include <string>
#include <sys/time.h>

namespace fesa
{

template<typename DataType>
class FaultField  : protected GenericFieldStruct<DataType>, virtual AbstractFaultField
{
  public:
    FaultField(const std::string& name, bool multiplexed, DataStore* pDataStore,
               const std::string& description, FaultSeverity severity);

    ~FaultField();

    void raise(int64_t time, MultiplexingContext* pCtx, int32_t errorCode = 0);

    void raise(MultiplexingContext* pCtx, int32_t errorCode = 0);

    virtual void lower(int64_t time, MultiplexingContext* pCtx);

    virtual void lower(MultiplexingContext* pCtx);

    bool isRaised(MultiplexingContext* pCtxt);

    FaultSeverity getSeverity();

    int64_t getTimestamp(MultiplexingContext* pCtxt);

    std::string getDescription();

  private:

    int64_t getActualTime();

    std::string description_;

    FaultSeverity severity_;

};

template<typename DataType>
FaultField<DataType>::FaultField(const std::string& name, bool multiplexed, DataStore* pDataStore,
                                 const std::string& description, FaultSeverity severity) :
    GenericFieldStruct<DataType> (name, multiplexed,pDataStore,false,SingleBuffered), description_(description),
    severity_(severity)
   // AbstractFaultField(name, multiplexed, pDataStore, description, severity)
{

}

template<typename DataType>
FaultField<DataType>::~FaultField()
{

}

template<typename DataType>
void FaultField<DataType>::raise(int64_t time, MultiplexingContext* pCtx, int32_t errorCode)
{
    if (!isRaised(pCtx))
    {
        uint32_t slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);

        char* address = (char*)this->getFieldValue(slot);

        FaultField_DataType* pActiveBuffer = &(this->getFieldValue(slot)->activeBuffer(address));
        pActiveBuffer->state_ = true;
        pActiveBuffer->timestamp_ = time;
        pActiveBuffer->errorCode_ = errorCode;

        this->commit(slot);
    }
}

template<typename DataType>
void FaultField<DataType>::raise(MultiplexingContext* pCtx, int32_t errorCode)
{
    if (!isRaised(pCtx))
    {
        int64_t time = getActualTime();
        raise(time, pCtx);
    }
}

template<typename DataType>
void FaultField<DataType>::lower(int64_t time, MultiplexingContext* pCtx)
{
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);
    char* address = (char*)this->getFieldValue(slot);
    FaultField_DataType* pActiveBuffer = &(this->getFieldValue(slot)->activeBuffer(address));
    pActiveBuffer->state_ = false;
    pActiveBuffer->timestamp_ = time;

    this->commit(slot);
}

template<typename DataType>
void FaultField<DataType>::lower(MultiplexingContext* pCtx)
{
    int64_t time = getActualTime();
    lower(time, pCtx);
}

template<typename DataType>
bool FaultField<DataType>::isRaised(MultiplexingContext* pCtx)
{
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);
    char* addr = (char*)this->getFieldValue(slot);
    return (this->getFieldValue(slot)->activeBuffer(addr).state_);
}

template<typename DataType>
FaultSeverity FaultField<DataType>::getSeverity()
{
    return severity_;
}

template<typename DataType>
int64_t FaultField<DataType>::getTimestamp(MultiplexingContext* pCtx)
{
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0 : this->multiplexingManager_->requireSlot(*pCtx);
    char* addr = (char*)this->getFieldValue(slot);
    return (this->getFieldValue(slot)->activeBuffer(addr).timestamp_);
}

template<typename DataType>
int64_t FaultField<DataType>::getActualTime()
{
    struct timeval now;
    gettimeofday(&now, 0);
    return (now.tv_sec * (int64_t) 1000000000 + now.tv_usec * (int64_t) 1000);
}

template<typename DataType>
std::string FaultField<DataType>::getDescription()
{
    return description_;
}

} // fesa

#endif // FAULT_FIELD_H_