GenericField.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef GENERIC_FIELD_H_
#define GENERIC_FIELD_H_

#include <fesa-core/DataStore/Field.h>
#include <fesa-core/DataStore/FieldArray.h>
#include <fesa-core/DataStore/FieldArray2D.h>
#include <fesa-core/DataStore/FieldString.h>
#include <fesa-core/DataStore/FieldStringArray.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>

namespace fesa
{

template<typename T>
class GenericFieldScalar: public Field<T> {
  public:

    GenericFieldScalar(const std::string& fieldName, bool multiplexed,
                       DataStore* pDataStore, bool persistent = false,
                       DataIntegrity bufferType = SingleBuffered);
    ~GenericFieldScalar();

    T get(MultiplexingContext*);

    void set(T val, MultiplexingContext*);
};

template<typename T>
GenericFieldScalar<T>::GenericFieldScalar(const std::string& fieldName,
                                          bool multiplexed, DataStore* pDataStore, bool persistent,
                                          DataIntegrity bufferType) :
    Field<T> (fieldName, Generic, multiplexed, false, persistent,
              bufferType, pDataStore) {
}

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

}

template<typename T>
T GenericFieldScalar<T>::get(MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T>* pFV = this->getFieldValue(slot);
    // Return the value from the Active buffer
    return (pFV->activeBuffer((char*) pFV));
}

template<typename T>
void GenericFieldScalar<T>::set(T val, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T>* pFV = this->getFieldValue(slot);
    // Set the pending buffer
    pFV->pendingBuffer((char*) pFV) = val;
}

/****************** END CLASS  GenericFieldScalar *********************/

template<typename T>
class GenericFieldStruct: public Field<T> {
  public:

    GenericFieldStruct(const std::string& fieldName, bool multiplexed,
                       DataStore* pDataStore, bool persistent,
                       DataIntegrity bufferType = SingleBuffered);
    ~GenericFieldStruct();

    const T* get(MultiplexingContext*);

    void set(T* val, MultiplexingContext*);
};

template<typename T>
GenericFieldStruct<T>::GenericFieldStruct(const std::string& fieldName,
                                          bool multiplexed, DataStore* pDataStore, bool persistent,
                                          DataIntegrity bufferType) :
    Field<T> (fieldName, Generic, multiplexed, false, persistent,
              bufferType, pDataStore) {
}

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

}

template<typename T>
const T* GenericFieldStruct<T>::get(MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T>* pFV = this->getFieldValue(slot);
    // Return the value from the Active buffer
    return &(pFV->activeBuffer((char*) pFV));
}

template<typename T>
void GenericFieldStruct<T>::set(T* val, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T>* pFV = this->getFieldValue(slot);
    // Set the pending buffer
    std::memcpy(&(pFV->pendingBuffer((char*) pFV)), val, sizeof(T));
}

/****************** END CLASS GenericFieldStruct *********************/

template<typename T>
class GenericFieldArray: public FieldArray<T> {
  public:

    GenericFieldArray(const std::string& fieldName, bool multiplexed,
                      DataStore* pDataStore, bool persistent, int32_t size,
                      DataIntegrity bufferType);

    ~GenericFieldArray();

    const T* get(uint32_t& size, MultiplexingContext* context);

    void set(const T* val, uint32_t size, MultiplexingContext* context);

    uint32_t getSize(MultiplexingContext* context);
};

template<typename T>
GenericFieldArray<T>::GenericFieldArray(const std::string& fieldName, bool multiplexed,
                                        DataStore* pDataStore, bool persistent, int32_t size,
                                        DataIntegrity bufferType) :
    FieldArray<T> (fieldName, Generic, multiplexed, false, persistent,
                   bufferType, pDataStore, size) {
}

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

}

template<typename T>
const T* GenericFieldArray<T>::get(uint32_t& size,
                                   MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    // Return the current size get from the Active buffer
    size = pFV->getActiveCurrentSize();
    // Return the value from the Active buffer
    return (pFV->activeBuffer((char*) pFV));
}

template<typename T>
void GenericFieldArray<T>::set(const T* val, uint32_t size,
                               MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimension(size);
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    // Adjust the pending dynamic size
    pFV->setPendingCurrentSize(size);
    // Set the pending buffer
    std::memcpy(pFV->pendingBuffer((char*) pFV), val, size * sizeof(T));
}

template<typename T>
uint32_t GenericFieldArray<T>::getSize(MultiplexingContext* context) {
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    return pFV->getActiveCurrentSize();
}

/****************** END CLASS GenericFieldArray *********************/

template<typename T>
class GenericFieldScalarArray: public GenericFieldArray<T> {
  public:

    GenericFieldScalarArray(const std::string& fieldName, bool multiplexed,
                            DataStore* pDataStore, bool persistent, int32_t size,
                            DataIntegrity bufferType = SingleBuffered);

    ~GenericFieldScalarArray();

    T getCell(uint32_t index, MultiplexingContext* context);

    void setCell(T val, uint32_t index, MultiplexingContext* context);
};

template<typename T>
GenericFieldScalarArray<T>::GenericFieldScalarArray(const std::string& fieldName,
                                                    bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size,
                                                    DataIntegrity bufferType) :
    GenericFieldArray<T> (fieldName, multiplexed, pDataStore, persistent, size,
                          bufferType) {

}

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

}

template<typename T>
T GenericFieldScalarArray<T>::getCell(uint32_t index,
                                      MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size = pFV->getActiveCurrentSize();
    if ((index+1) > size) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldCurrentDimensionOutOfBound.c_str(),
                            StringUtilities::toString(index).c_str(), this->name_.c_str(),
                            StringUtilities::toString(size).c_str());
    }
    // Return the value from the Active buffer
    return (pFV->activeBuffer((char*) pFV)[index]);
}

template<typename T>
void GenericFieldScalarArray<T>::setCell(T val, uint32_t index,
                                         MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimension(index+1);
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    // Adjust the dynamic dimension if it's required
    uint32_t size = pFV->getPendingCurrentSize();
    if ((index + 1) > size)
        pFV->setPendingCurrentSize(index+1);
    // Set cell in the pending buffer
    pFV->pendingBuffer((char*) pFV)[index] = val;
}

/****************** END CLASS GenericFieldScalarArray *********************/

template<typename T>
class GenericFieldStructArray: public GenericFieldArray<T> {
  public:

    GenericFieldStructArray(const std::string& fieldName, bool multiplexed,
                            DataStore* pDataStore, bool persistent, int32_t size,
                            DataIntegrity bufferType = SingleBuffered);

    ~GenericFieldStructArray();

    const T* getCell(uint32_t index, MultiplexingContext* context);

    void setCell(T* val, uint32_t index, MultiplexingContext* context);
};

template<typename T>
GenericFieldStructArray<T>::GenericFieldStructArray(const std::string& fieldName,
                                                    bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size,
                                                    DataIntegrity bufferType) :
    GenericFieldArray<T> (fieldName, multiplexed, pDataStore, persistent, size,
                          bufferType) {

}

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

}

template<typename T>
const T* GenericFieldStructArray<T>::getCell(uint32_t index,
                                             MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size = pFV->getActiveCurrentSize();
    if ((index+1) > size) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldCurrentDimensionOutOfBound.c_str(),
                            StringUtilities::toString(index).c_str(), this->name_.c_str(),
                            StringUtilities::toString(size).c_str());
    }
    // Return the value from the Active buffer
    return &(pFV->activeBuffer((char*) pFV)[index]);
}

template<typename T>
void GenericFieldStructArray<T>::setCell(T* val, uint32_t index,
                                         MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimension(index + 1);
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    // Adjust the dynamic dimension if it's required
    uint32_t size = pFV->getPendingCurrentSize();
    if ((index + 1) > size)
        pFV->setPendingCurrentSize(index+1);
    // Set cell in the pending buffer
    std::memcpy(&(pFV->activeBuffer((char*) pFV)[index]), val, sizeof(T));
}

/****************** END CLASS  GenericFieldStructArray *********************/

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

    ~GenericFieldArray2D();

    const T** get(uint32_t& size1, uint32_t& size2,
                  MultiplexingContext* context);

    void getColumn(uint32_t index, uint32_t size, T* column, uint32_t& currentSize,
                   MultiplexingContext* context);

    const T* getRow(uint32_t index, uint32_t& size,
                    MultiplexingContext* context);

    void set(const T* const * val, uint32_t size1, uint32_t size2,
             MultiplexingContext* context);

    void setColumn(const T* val, uint32_t index, uint32_t size,
                   MultiplexingContext* context);

    void setRow(const T* val, uint32_t index, uint32_t size,
                MultiplexingContext* context);

    void getSize(uint32_t& size1, uint32_t& size2, MultiplexingContext* context);
};

template<typename T>
GenericFieldArray2D<T>::GenericFieldArray2D(const std::string& fieldName,
                                            bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                                            DataIntegrity bufferType) :
    FieldArray2D<T> (fieldName, Generic, multiplexed, false, persistent,
                     bufferType, pDataStore, size1, size2) {
}

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

}

template<typename T>
const T** GenericFieldArray2D<T>::get(uint32_t& size1, uint32_t& size2,
                                      MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Return the current size get from the Active buffer
    pFV->getActiveCurrentSize(size1, size2);
    // Return the value from the Active buffer
    return (const T**) (pFV->activeBuffer((char*) pFV));
}

template<typename T>
void GenericFieldArray2D<T>::getColumn(uint32_t index, uint32_t size,
                                       T* column, uint32_t& currentSize, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    pFV->getActiveCurrentSize(size1, size2);
    if ((index+1) > size2 || size < size1) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldCurrentDimensionsOutOfBound.c_str(),
                            StringUtilities::toString(index).c_str(),
                            StringUtilities::toString(size).c_str(),
                            this->name_.c_str(),
                            StringUtilities::toString(size1).c_str(),
                            StringUtilities::toString(size2).c_str());
    }
    // Fill the column from the active buffer
    currentSize = size1;
    T(*activeVal)[size2];
    activeVal = (T(*)[size2]) pFV->activeBuffer((char*) pFV);
    for (uint32_t i = 0; i < size1; i++) {
        column[i] = activeVal[i][index];
    }
}

template<typename T>
const T* GenericFieldArray2D<T>::getRow(uint32_t index, uint32_t& size,
                                        MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    pFV->getActiveCurrentSize(size1, size2);
    if ((index+1) > size1) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldCurrentDimensionOutOfBound.c_str(),
                            StringUtilities::toString(index).c_str(), this->name_.c_str(),
                            StringUtilities::toString(size1).c_str());
    }
    // Return the row from the active buffer
    size = size2;
    T(*activeVal)[size2];
    activeVal = (T(*)[size2]) pFV->activeBuffer((char*) pFV);
    return activeVal[index];
}

template<typename T>
void GenericFieldArray2D<T>::set(const T* const * val, uint32_t size1,
                                 uint32_t size2, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimensions(size1, size2);
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Adjust the pending dynamic size
    pFV->setPendingCurrentSize(size1, size2);
    // Set the pending buffer
    std::memcpy(pFV->pendingBuffer((char*) pFV), val, size1 * size2 * sizeof(T));
}

template<typename T>
void GenericFieldArray2D<T>::setColumn(const T* val, uint32_t index,
                                       uint32_t size, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimensions(size, index+1);
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Adjust the dynamic dimension if it's required
    uint32_t size1, size2;
    pFV->getPendingCurrentSize(size1, size2);
    uint32_t newSize1 = (size > size1) ? size : size1;
    uint32_t newSize2 = ((index+1) > size2) ? (index+1) : size2;
    pFV->setPendingCurrentSize(newSize1, newSize2);
    // Set column in the pending buffer
    T(*activeVal)[newSize2];
    activeVal = (T(*)[newSize2]) pFV->pendingBuffer((char*) pFV);
    for (uint32_t i = 0; i < size; i++) {
        activeVal[i][index] = val[i];
    }
}

template<typename T>
void GenericFieldArray2D<T>::setRow(const T* val, uint32_t index,
                                    uint32_t size, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimensions(index+1, size);
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Adjust the dynamic dimension if it's required
    uint32_t size1, size2;
    pFV->getPendingCurrentSize(size1, size2);
    uint32_t newSize1 = ((index+1) > size1) ? (index+1) : size1;
    uint32_t newSize2 = (size > size2) ? size : size2;
    pFV->setPendingCurrentSize(newSize1, newSize2);
    // Set column in the pending buffer
    // Set column in the pending buffer
    T(*pendingVal)[newSize2];
    pendingVal = (T(*)[newSize2]) pFV->pendingBuffer((char*) pFV);
    std::memcpy(pendingVal[index], val, size * sizeof(T));
}

template<typename T>
void GenericFieldArray2D<T>::getSize(uint32_t& size1, uint32_t& size2, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    pFV->getActiveCurrentSize(size1, size2);
}

/****************** END CLASS  GenericFieldArray2D *********************/

template<typename T>
class GenericFieldScalarArray2D: public GenericFieldArray2D<T> {
  public:
    GenericFieldScalarArray2D(const std::string& fieldName, bool multiplexed,
                              DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                              DataIntegrity bufferType = SingleBuffered);

    ~GenericFieldScalarArray2D();

    T getCell(uint32_t index1, uint32_t index2,
              MultiplexingContext* context);

    void setCell(T val, uint32_t index1, uint32_t index2,
                 MultiplexingContext* context);

};

template<typename T>
GenericFieldScalarArray2D<T>::GenericFieldScalarArray2D(const std::string& fieldName,
                                                        bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                                                        DataIntegrity bufferType) :
    GenericFieldArray2D<T> (fieldName, multiplexed, pDataStore, persistent, size1, size2,
                            bufferType) {

}

template<typename T>
T GenericFieldScalarArray2D<T>::getCell(uint32_t index1, uint32_t index2,
                                        MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    pFV->getActiveCurrentSize(size1, size2);
    if ( ((index1+1) > size1) || ((index2+1) > size2) ) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldCurrentDimensionsOutOfBound.c_str(),
                            StringUtilities::toString(index1).c_str(),
                            StringUtilities::toString(index2).c_str(),
                            this->name_.c_str(),
                            StringUtilities::toString(size1).c_str(),
                            StringUtilities::toString(size2).c_str());
    }
    // Get cell from the active buffer
    T(*activeVal)[size2];
    activeVal = (T(*)[size2]) pFV->activeBuffer((char*) pFV);
    return activeVal[index1][index2];
}

template<typename T>
void GenericFieldScalarArray2D<T>::setCell(T val, uint32_t index1,
                                           uint32_t index2, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimensions((index1+1), (index2+1));
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Adjust the dynamic dimension if it's required
    uint32_t size1, size2;
    pFV->getPendingCurrentSize(size1, size2);
    uint32_t newSize1 = ((index1+1) > size1) ? (index1+1) : size1;
    uint32_t newSize2 = ((index2+1) > size2) ? (index2+1) : size2;
    pFV->setPendingCurrentSize(newSize1, newSize2);
    // Set cell in the pending buffer
    T(*activeVal)[newSize2];
    activeVal = (T(*)[newSize2]) pFV->pendingBuffer((char*) pFV);
    activeVal[index1][index2] = val;
}

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

}

/****************** END CLASS  GenericFieldScalarArray2D *********************/

template<typename T>
class GenericFieldStructArray2D: public GenericFieldArray2D<T> {
  public:
    GenericFieldStructArray2D(const std::string& fieldName, bool multiplexed,
                              DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                              DataIntegrity bufferType = SingleBuffered);

    ~GenericFieldStructArray2D();

    const T* getCell(uint32_t index1, uint32_t index2,
                     MultiplexingContext* context = 0);

    void setCell(T* val, uint32_t index1, uint32_t index2,
                 MultiplexingContext* context);

};

template<typename T>
GenericFieldStructArray2D<T>::GenericFieldStructArray2D(const std::string& fieldName,
                                                        bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                                                        DataIntegrity bufferType) :
    GenericFieldArray2D<T> (fieldName, multiplexed, pDataStore, persistent, size1, size2,
                            bufferType) {

}

template<typename T>
const T* GenericFieldStructArray2D<T>::getCell(uint32_t index1,
                                               uint32_t index2, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->getSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    pFV->getActiveCurrentSize(size1, size2);
    if ( ((index1+1) > size1) || ((index2+1) > size2) ) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldCurrentDimensionsOutOfBound.c_str(),
                            StringUtilities::toString(index1).c_str(),
                            StringUtilities::toString(index2).c_str(),
                            this->name_.c_str(),
                            StringUtilities::toString(size1).c_str(),
                            StringUtilities::toString(size2).c_str());
    }
    // Get cell from the active buffer
    T(*activeVal)[size2];
    activeVal = (T(*)[size2]) pFV->activeBuffer((char*) pFV);
    return &(activeVal[index1][index2]);
}

template<typename T>
void GenericFieldStructArray2D<T>::setCell(T* val, uint32_t index1,
                                           uint32_t index2, MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    // throw exception in case of NoneContext and multiplexed field.
    if (this->multiplexingManager_ && context->getType() == MultiplexingContext::NoneCtxt)
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    this->checkMaxDimensions((index1+1), (index2+1));
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[][1]>* pFV = this->getFieldValue(slot);
    // Adjust the dynamic dimension if it's required
    uint32_t size1, size2;
    pFV->getPendingCurrentSize(size1, size2);
    uint32_t newSize1 = ((index1+1) > size1) ? (index1+1) : size1;
    uint32_t newSize2 = ((index2+1) > size2) ? (index2+1) : size2;
    pFV->setPendingCurrentSize(newSize1, newSize2);
    // Set cell in the pending buffer
    T(*pendingVal)[newSize2];
    pendingVal = (T(*)[newSize2]) pFV->pendingBuffer((char*) pFV);
    std::memcpy(&(pendingVal[index1][index2]), val, sizeof(T));
}

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

}

/****************** END CLASS  GenericFieldStructArray2D *********************/

class GenericFieldString: public FieldString {
  public:
    GenericFieldString(const std::string& fieldName, bool multiplexed,
                       DataStore* pDataStore, bool persistent, int32_t size,
                       DataIntegrity bufferType = SingleBuffered);

    ~GenericFieldString();

    const char* get(MultiplexingContext* context);

    void set(const char* val, MultiplexingContext* context);

};

/****************** END CLASS  GenericFieldString *********************/

class GenericFieldStringArray: public FieldStringArray {
  public:
    GenericFieldStringArray(const std::string& fieldName, bool multiplexed,
                            DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                            DataIntegrity bufferType = SingleBuffered);
    ~GenericFieldStringArray();

    const char** get(uint32_t& size1, MultiplexingContext* context);

    const char* getString(uint32_t index, MultiplexingContext* context);

    void set(const char** val, uint32_t size1,
             MultiplexingContext* context);

    void setString(const char* val, uint32_t index,
                   MultiplexingContext* context);

};

/****************** END CLASS  GenericFieldStringArray *********************/

} // fesa

#endif // GENERIC_FIELD_H_