Field.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef FIELD_H_
#define FIELD_H_

#include <fesa-core/DataStore/AbstractField.h>
#include <fesa-core/DataStore/FieldValue.h>
#include <fesa-core/DataStore/Converter.h>
#include <fesa-core/Synchronization/AbstractMultiplexingManager.h>
#include <fesa-core/Exception/FesaException.h>

#include <string>
#include <cstring>

namespace fesa
{

template<typename T>
class Field : public AbstractField {
  public:
    Field(const std::string& fieldName, const FieldCategory fieldCategory,
          bool multiplexed, bool multiMultiplexed, bool persistent,
          DataIntegrity bufferType, DataStore* pDataStore);

    ~Field();

  protected:

    uint32_t getFieldValueSize();

    FieldValue<T>* getFieldValue(int32_t slot);

    void setFieldValueAddress(char* pFV, bool initFieldsFlag);

    FieldValue<T>* fieldValue_;

    void copyValue(uint32_t slot, std::string& val);

    /*
     * \return the value of the pending buffer as a string
     */
    void getValueToStore(int32_t slot, std::string& str);

};

template<typename T>
Field<T>::Field(const std::string& fieldName,
                const FieldCategory fieldCategory, bool multiplexed,
                bool multiMultiplexed, bool persistent, DataIntegrity bufferType,
                DataStore* pDataStore) :
    AbstractField(fieldName, fieldCategory, multiplexed, multiMultiplexed,
                  persistent, bufferType, pDataStore) {

}

template<typename T>
Field<T>::~Field() {

}

template<typename T>
inline FieldValue<T>* Field<T>::getFieldValue(int32_t slot) {

    char* address = (char*) this->fieldValue_;
    address += valueSize_ * slot;
    return (FieldValue<T>*) address;
}

template<typename T>
uint32_t Field<T>::getFieldValueSize() {
    if (valueSize_ == 0) {
        valueSize_ = static_cast<uint32_t>(sizeof(FieldValue<T> )) + static_cast<uint32_t>(sizeof(T)) * buffer_;
    }
    return valueSize_;
}

template<typename T>
void Field<T>::setFieldValueAddress(char* pFV, bool initFieldsFlag) {
    int32_t depth = 1;

    if (this->multiplexingManager_ != NULL) {
        depth = this->multiplexingManager_->getDepth();
    }

    this->fieldValue_ = (FieldValue<T>*) pFV;

    if (initFieldsFlag) {
        for (int32_t i = 0; i < depth; i++) {
            FieldValue<T>* temp = new (pFV) FieldValue<T> (buffer_);
            if (!temp) {
                throw FesaException(__FILE__, __LINE__,
                                    FesaErrorSettingFieldValueAddress.c_str(),
                                    name_.c_str());
            }
            pFV += this->valueSize_;
        }
    }

}

template<typename T>
void Field<T>::copyValue(uint32_t slot, std::string& str) {
    T* pVal = new T;
    Converter<T>::stringToValue(str, pVal);

    FieldValue<T>* pFV = this->getFieldValue(slot);

    std::memcpy(&(pFV->activeBuffer((char*) pFV)), pVal, sizeof(T));
    std::memcpy(&(pFV->pendingBuffer((char*) pFV)), pVal, sizeof(T));

    delete pVal;
}

template<typename T>
void Field<T>::getValueToStore(int32_t slot, std::string& str)

{
    FieldValue<T>* pFV = this->getFieldValue(slot);

    if (pFV->hasPendingChanged() || pFV->isToBeSync()) {
        Converter<T>::valueToString(pFV->pendingBuffer((char*) pFV), str);
    } else {
        Converter<T>::valueToString(pFV->activeBuffer((char*) pFV), str);
    }
}

} // fesa

#endif // FIELD_H_