FieldArray.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef _FIELD_ARRAY_H_
#define _FIELD_ARRAY_H_

#include <fesa-core/Utilities/ParserElements.h>
#include <fesa-core/DataStore/AbstractField.h>
#include <fesa-core/DataStore/FieldValue.h>
#include <string>

namespace fesa
{

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

    ~FieldArray();

    uint32_t getMaxSize();

  protected:

    uint32_t getFieldValueSize();

    void initialize(FieldElement& fieldElement);

    void setFieldValueAddress(char* pFV, bool initFieldsFlag);

    void checkMaxDimension(uint32_t size);

    FieldValue<T[]>* getFieldValue(int32_t slot);

    uint32_t maxSize_;

    FieldValue<T[]>* fieldValue_;

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

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

};

template<typename T>
FieldArray<T>::FieldArray(const std::string& fieldName,
                          const FieldCategory fieldCategory, bool multiplexed,
                          bool multiMultiplexed, bool persistent, DataIntegrity bufferType,
                          DataStore* pDataStore, int32_t size) :
    AbstractField(fieldName, fieldCategory, multiplexed, multiMultiplexed,
                  persistent, bufferType, pDataStore), maxSize_(size), fieldValue_(
                      NULL) {

}

template<typename T>
FieldArray<T>::~FieldArray() {
}

template<typename T>
inline FieldValue<T[]>* FieldArray<T>::getFieldValue(int32_t slot) {
    char* address = (char*) this->fieldValue_;
    address += valueSize_ * slot;
    return (FieldValue<T[]>*) address;
}

template<typename T>
void FieldArray<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_,
                                                               maxSize_);
            if (!temp) {
                throw FesaException(__FILE__, __LINE__,
                                    FesaErrorSettingFieldValueAddress.c_str(),
                                    name_.c_str());
            }
            pFV += this->valueSize_;
        }
    }

}

template<typename T>
uint32_t FieldArray<T>::getFieldValueSize() {
    if (valueSize_ == 0) {
        valueSize_ = sizeof(FieldValue<T[]> ) + sizeof(T) * maxSize_ * buffer_;
    }
    return valueSize_;

}

template<typename T>
void FieldArray<T>::initialize(FieldElement& fieldElement) {
    if (fieldElement.dimension1_ > 0) {

        this->maxSize_ = fieldElement.dimension1_;
    }

}

template<typename T>
void FieldArray<T>::checkMaxDimension(uint32_t size) {
    if (size > this->maxSize_) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldMaxDimensionOutOfBound.c_str(),
                            StringUtilities::toString(size).c_str(), this->name_.c_str(),
                            StringUtilities::toString(maxSize_).c_str());
    }
}

template<typename T>
void FieldArray<T>::copyValue(uint32_t slot, std::string& str) {
    std::vector<std::string> tokens;

    // Copy the string into a temp string because the original one cannot be modified because
    // it is used to populate the other slots if the filed is multiplexed.
    std::string tmpStr(str);
    StringUtilities::removeBrackets(tmpStr);
    StringUtilities::getElements(tmpStr, tokens);

    this->checkMaxDimension(tokens.size());

    // get the min size between the number of tokens and the array
    uint32_t minSize = tokens.size() < this->maxSize_ ? tokens.size()
        : this->maxSize_;

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

    pFV->setActiveCurrentSize(minSize);
    pFV->setPendingCurrentSize(minSize);

    T* lastValue = new T();
    for (uint32_t j = 0; j < minSize; j++) {
        Converter<T>::stringToValue(tokens[j],
                                    &(pFV->activeBuffer((char*) pFV)[j]));
        pFV->pendingBuffer((char*) pFV)[j] = pFV->activeBuffer((char*) pFV)[j];
    }
    // fill the rest of the array with the last value
    *lastValue = pFV->activeBuffer((char*) pFV)[minSize-1];
    for (uint32_t j = minSize; j < this->maxSize_; j++) {
        pFV->activeBuffer((char*) pFV)[j] = *lastValue;
        pFV->pendingBuffer((char*) pFV)[j] = *lastValue;
    }

    delete lastValue;

}

template<typename T>
void FieldArray<T>::getValueToStore(int32_t slot, std::string& value) {
    value = "{";
    std::string str;

    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    T* pBufVal;
    uint32_t size;
    if(pFV->isToBeSync()) {
        pBufVal = pFV->pendingBuffer((char*) pFV);
        size = pFV->getPendingCurrentSize();
    }
    else {
        pBufVal = pFV->activeBuffer((char*) pFV);
        size = pFV->getActiveCurrentSize();
    }
    for (uint32_t j = 0; j < size; j++) {
        Converter<T>::valueToString(pBufVal[j], str);
        if (j != size - 1) {
            value = value + str + ",";
        } else {
            value = value + str;
        }
    }
    value += "}";
}

template<typename T>
uint32_t FieldArray<T>::getMaxSize() {
    return this->maxSize_;
}

} // fesa

#endif // _FIELD_ARRAY_H_