FieldArray2D.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef _FIELD_ARRAY_2D_H_
#define _FIELD_ARRAY_2D_H_

#include <fesa-core/DataStore/AbstractField.h>

#include <string>

namespace fesa
{

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

    ~FieldArray2D();

    void getMaxSize(uint32_t& size1, uint32_t& size2);

  protected:

    void initialize(FieldElement& fieldElement);

    uint32_t getFieldValueSize();

    void setFieldValueAddress(char* pFV, bool initFieldsFlag);

    void checkMaxDimensions(uint32_t size1, uint32_t size2);

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

    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& value);

    uint32_t maxSize1_;

    uint32_t maxSize2_;

    FieldValue<T[][1]>* fieldValue_;

};

template<typename T>
FieldArray2D<T>::FieldArray2D(const std::string& fieldName,
                              const FieldCategory fieldCategory, bool multiplexed,
                              bool multiMultiplexed, bool persistent, DataIntegrity bufferType,
                              DataStore* pDataStore, int32_t size1, int32_t size2) :
    AbstractField(fieldName, fieldCategory, multiplexed, multiMultiplexed,
                  persistent, bufferType, pDataStore), maxSize1_(size1), maxSize2_(
                      size2) {

}

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

template<typename T>
inline FieldValue<T[][1]>* FieldArray2D<T>::getFieldValue(int32_t slot) {

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

}

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

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

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

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

}

template<typename T>
void FieldArray2D<T>::initialize(FieldElement& fieldElement) {

    if (fieldElement.dimension1_ > 0) {
        this->maxSize1_ = fieldElement.dimension1_;
    }
    if (fieldElement.dimension2_ > 0) {
        this->maxSize2_ = fieldElement.dimension2_;
    }

}

template<typename T>
uint32_t FieldArray2D<T>::getFieldValueSize() {

    if (valueSize_ == 0) {
        valueSize_ = sizeof(FieldValue<T[][1]> ) + sizeof(T) * maxSize1_
            * maxSize2_ * buffer_;
    }
    return valueSize_;
}

template<typename T>
void FieldArray2D<T>::checkMaxDimensions(uint32_t size1,
                                         uint32_t size2) {

    if (size1 > maxSize1_ || size2 > maxSize2_) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldMaxDimensionsOutOfBound.c_str(),
                            StringUtilities::toString(size1).c_str(),
                            StringUtilities::toString(size2).c_str(),
                            this->name_.c_str(),
                            StringUtilities::toString(maxSize1_).c_str(),
                            StringUtilities::toString(maxSize2_).c_str());
    }
}

template<typename T>
void FieldArray2D<T>::copyValue(uint32_t slot, std::string& str) {

    std::vector<std::string> rows;

    // 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, rows);

    checkMaxDimensions(rows.size(), 0);

    // get the min size between the number of rows and the first dimension
    uint32_t minRowSize = rows.size() < this->maxSize1_ ? rows.size()
        : this->maxSize1_;

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

    T (*activeVal)[this->maxSize2_];

    activeVal = (T(*)[this->maxSize2_]) pFV->activeBuffer((char*) pFV);

    T (*pendingVal)[this->maxSize2_];

    pendingVal = (T(*)[this->maxSize2_]) pFV->pendingBuffer((char*) pFV);

    for (uint32_t j = 0; j < minRowSize; ++j) {
        std::vector<std::string> columns;
        // remove any blanks before open bracket and after close bracket
        std::string& rowEl = rows.at(j);

        StringUtilities::removeBrackets(rowEl);
        StringUtilities::getElements(rowEl, columns);

        checkMaxDimensions(rows.size(), columns.size());

        // get the min size between the number of rows and the first dimension
        uint32_t minColumnSize =
            (columns.size() < this->maxSize2_) ? columns.size()
            : this->maxSize2_;

        pFV->setPendingCurrentSize(minRowSize, minColumnSize);
        pFV->setActiveCurrentSize(minRowSize, minColumnSize);

        for (uint32_t jj = 0; jj < minColumnSize; ++jj) {

            Converter<T>::stringToValue(columns.at(jj), &activeVal[j][jj]);
            pendingVal[j][jj] = activeVal[j][jj];

        }
    }

}

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

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

template<typename T>
void FieldArray2D<T>::getMaxSize(uint32_t& size1, uint32_t& size2) {
    size1 = this->maxSize1_;
    size2 = this->maxSize2_;

}

} // fesa

#endif // _FIELD_ARRAY_2D_H_