AcquisitionField.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef ACQUISITION_FIELD_H_
#define ACQUISITION_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 AcqFieldScalar : public Field<T>
{
  public:

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

    T get(MultiplexingContext*);

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

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

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

}

template<typename T>
T AcqFieldScalar<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 AcqFieldScalar<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());
    // Check if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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  AcqFieldScalar *********************/

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

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

    const T* get(MultiplexingContext*);

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

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

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

}

template<typename T>
const T* AcqFieldStruct<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 AcqFieldStruct<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());
    // Check if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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 AcqFieldStruct *********************/

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

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

    ~AcqFieldArray();

    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>
AcqFieldArray<T>::AcqFieldArray(const std::string& fieldName, bool multiplexed,
                                DataStore* pDataStore, bool persistent, int32_t size,
                                DataIntegrity bufferType) :
    FieldArray<T> (fieldName, Acquisition, multiplexed, false, persistent,
                   bufferType, pDataStore, size) {
}

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

}

template<typename T>
const T* AcqFieldArray<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 AcqFieldArray<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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 AcqFieldArray<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 AcqFieldArray *********************/

template<typename T>
class AcqFieldScalarArray: public AcqFieldArray<T> {
  public:

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

    ~AcqFieldScalarArray();

    T getCell(uint32_t index, MultiplexingContext* context);

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

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

}

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

}

template<typename T>
T AcqFieldScalarArray<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 AcqFieldScalarArray<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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 AcqFieldScalarArray *********************/

template<typename T>
class AcqFieldStructArray: public AcqFieldArray<T> {
  public:

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

    ~AcqFieldStructArray();

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

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

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

}

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

}

template<typename T>
const T* AcqFieldStructArray<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 AcqFieldStructArray<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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  AcqFieldStructArray *********************/

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

    ~AcqFieldArray2D();

    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>
AcqFieldArray2D<T>::AcqFieldArray2D(const std::string& fieldName,
                                    bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                                    DataIntegrity bufferType) :
    FieldArray2D<T> (fieldName, Acquisition, multiplexed, false, persistent,
                     bufferType, pDataStore, size1, size2) {
}

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

}

template<typename T>
const T** AcqFieldArray2D<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 AcqFieldArray2D<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* AcqFieldArray2D<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 AcqFieldArray2D<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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 AcqFieldArray2D<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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 AcqFieldArray2D<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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 AcqFieldArray2D<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  AcqFieldArray2D *********************/

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

    ~AcqFieldScalarArray2D();

    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>
AcqFieldScalarArray2D<T>::AcqFieldScalarArray2D(const std::string& fieldName,
                                                bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                                                DataIntegrity bufferType) :
    AcqFieldArray2D<T> (fieldName, multiplexed, pDataStore, persistent, size1, size2,
                        bufferType) {

}

template<typename T>
T AcqFieldScalarArray2D<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 AcqFieldScalarArray2D<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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>
AcqFieldScalarArray2D<T>::~AcqFieldScalarArray2D() {

}

/****************** END CLASS  AcqFieldScalarArray2D *********************/

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

    ~AcqFieldStructArray2D();

    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>
AcqFieldStructArray2D<T>::AcqFieldStructArray2D(const std::string& fieldName,
                                                bool multiplexed, DataStore* pDataStore, bool persistent, int32_t size1, int32_t size2,
                                                DataIntegrity bufferType) :
    AcqFieldArray2D<T> (fieldName, multiplexed, pDataStore, persistent, size1, size2,
                        bufferType) {

}

template<typename T>
const T* AcqFieldStructArray2D<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 AcqFieldStructArray2D<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 if the set is allowed for acquisition fields
    if (!(context->getAcquisitionAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextAcquisitionField.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>
AcqFieldStructArray2D<T>::~AcqFieldStructArray2D() {

}

/****************** END CLASS  AcqFieldStructArray2D *********************/

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

    ~AcqFieldString();

    const char* get(MultiplexingContext* context);

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

};

/****************** END CLASS  AcqFieldString *********************/

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

    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  AcquisitionFieldStringArray *********************/

} // fesa

#endif // ACQUISITION_FIELD_H_