SettingField.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef SETTING_FIELD_H_
#define SETTING_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 SettingFieldScalar: public Field<T> {
  public:
    SettingFieldScalar(const std::string& fieldName, bool multiplexed,
                       bool multiMultiplexed, DataStore* pDataStore, bool persistent, bool shared,
                       const DataIntegrity bufferType = DoubleBuffered);
    ~SettingFieldScalar();

    T get(MultiplexingContext*);

    T getPending(MultiplexingContext*);

    void set(T val, MultiplexingContext*);

};

template<typename T>
SettingFieldScalar<T>::SettingFieldScalar(const std::string& fieldName,
                                          bool multiplexed, bool multiMultiplexed, DataStore* pDataStore,
                                          bool isPersistent, bool shared,
                                          const DataIntegrity bufferType) :
    Field<T> (fieldName, Setting, multiplexed, multiMultiplexed,
              isPersistent, bufferType, pDataStore) {
    // Set properly the attribute isShared
    this->isShared_ = shared;
}

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

}

template<typename T>
T SettingFieldScalar<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);
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Return the value from the pending buffer
        return (pFV->pendingBuffer((char*) pFV));
    }
    else
    {
        // Return the value from the active buffer
        return (pFV->activeBuffer((char*) pFV));
    }
}

template<typename T>
T SettingFieldScalar<T>::getPending(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 pending buffer
    return (pFV->pendingBuffer((char*) pFV));
}

template<typename T>
void SettingFieldScalar<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
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    // Set the pending buffer and register the field
    // to be committed or rolled-back.
    pFV->pendingBuffer((char*) pFV) = val;
    this->registerModifiedField(pFV, context);
}

/****************** END CLASS  SettingFieldScalar *********************/

template<typename T>
class SettingFieldStruct: public Field<T> {
  public:
    SettingFieldStruct(const std::string& fieldName, bool multiplexed,
                       bool multiMultiplexed, DataStore* pDataStore, bool persistent,  bool shared,
                       const DataIntegrity bufferType = DoubleBuffered);
    ~SettingFieldStruct();

    const T* get(MultiplexingContext*);

    const T* getPending(MultiplexingContext*);

    void set(T* val, MultiplexingContext*);

  protected:

    void checkContext(MultiplexingContext* context);
};

template<typename T>
SettingFieldStruct<T>::SettingFieldStruct(const std::string& fieldName,
                                          bool multiplexed, bool multiMultiplexed, DataStore* pDataStore,
                                          bool isPersistent, bool shared,
                                          const DataIntegrity bufferType) :
    Field<T> (fieldName, Setting, multiplexed, multiMultiplexed,
              isPersistent, bufferType, pDataStore) {
    // Set properly the attribute isShared
    this->isShared_ = shared;
}

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

}

template<typename T>
const T* SettingFieldStruct<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);
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Return the value from the pending buffer

        return (const T*) (&(pFV->pendingBuffer((char*) pFV)));
    }
    else
    {
        // Return the value from the active buffer

        return (const T*) (&(pFV->activeBuffer((char*) pFV)));
    }
}

template<typename T>
const T* SettingFieldStruct<T>::getPending(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  (const T*) (&(pFV->pendingBuffer((char*) pFV)));
}

template<typename T>
void SettingFieldStruct<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
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    // Set the pending buffer and register the field
    // to be committed or rolled-back.
    std::memcpy(&pFV->pendingBuffer((char*) pFV), val, sizeof(T));
    this->registerModifiedField(pFV, context);
}

template<typename T>
void SettingFieldStruct<T>::checkContext(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
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
}

/*************************** END CLASS SettingFieldStruct *************/

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

    ~SettingFieldArray();

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

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

    uint32_t getSize(MultiplexingContext* context);

  protected:

    void checkContext(MultiplexingContext* context);
};

template<typename T>
SettingFieldArray<T>::SettingFieldArray(const std::string& fieldName,
                                        bool multiplexed, bool multiMultiplexed, DataStore* pDataStore,
                                        bool isPersistent, bool shared, int32_t size,
                                        const DataIntegrity bufferType) :
    FieldArray<T> (fieldName, Setting, multiplexed, multiMultiplexed,
                   isPersistent, bufferType, pDataStore, size) {
    // Set properly the attribute isShared
    this->isShared_ = shared;
}

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

}

template<typename T>
const T* SettingFieldArray<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();
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Return the value from the pending buffer
        return (const T*) (pFV->pendingBuffer((char*) pFV));
    }
    else
    {
        // Return the value from the active buffer
        return (const T*) (pFV->activeBuffer((char*) pFV));
    }
}

template<typename T>
void SettingFieldArray<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    pFV->setPendingCurrentSize(size);
    std::memcpy(pFV->pendingBuffer((char*) pFV), val, size * sizeof(T));
    this->registerModifiedField(pFV, context);
}

template<typename T>
uint32_t SettingFieldArray<T>::getSize(MultiplexingContext* context) {
    // throw exception in case of NULL pointer
    if (context == NULL)
        throw FesaException(__FILE__, __LINE__, FesaErrorNULLPointerToContext.c_str());
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<T[]>* pFV = this->getFieldValue(slot);
    return pFV->getActiveCurrentSize();
}

template<typename T>
void SettingFieldArray<T>::checkContext(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
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
}

/*************************** END CLASS SettingFieldArray *************/

template<typename T>
class SettingFieldScalarArray: public SettingFieldArray<T> {
  public:
    SettingFieldScalarArray(const std::string& fieldName, bool multiplexed,
                            bool multiMultiplexed, DataStore* pDataStore,
                            bool persistent, bool shared, int32_t size,
                            const DataIntegrity bufferType = DoubleBuffered);

    ~SettingFieldScalarArray();

    T getCell(uint32_t index, MultiplexingContext* context);

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

template<typename T>
SettingFieldScalarArray<T>::SettingFieldScalarArray(
    const std::string& fieldName, bool multiplexed, bool multiMultiplexed,
    DataStore* pDataStore, bool isPersistent, bool shared, int32_t size,
    const DataIntegrity bufferType) :
    SettingFieldArray<T> (fieldName, multiplexed, multiMultiplexed, pDataStore,
                          isPersistent, shared, size, bufferType) {

}

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

}

template<typename T>
T SettingFieldScalarArray<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());
    }
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Return the value from the pending buffer
        return pFV->pendingBuffer((char*) pFV)[index];
    }
    else
    {
        // Return the value from the active buffer
        return pFV->activeBuffer((char*) pFV)[index];
    }
}

template<typename T>
void SettingFieldScalarArray<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    uint32_t size = 0;
    // Partial setting method. First set, synchronize pending with active
    if (!pFV->hasPendingChanged()) {
        size = pFV->getActiveCurrentSize();
        pFV->setPendingCurrentSize(size);
        std::memcpy(pFV->pendingBuffer((char*) pFV), pFV->activeBuffer(
                   (char*) pFV), size * sizeof(T));
    }
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    size = pFV->getPendingCurrentSize();
    if ((index + 1) > size)
        pFV->setPendingCurrentSize(index+1);
    // Set cell in the pending buffer
    pFV->pendingBuffer((char*) pFV)[index] = val;
    this->registerModifiedField(pFV, context);
}

/****************** END CLASS  SettingFieldScalarArray *****************/

template<typename T>
class SettingFieldStructArray: public SettingFieldArray<T> {
  public:
    SettingFieldStructArray(const std::string& fieldName, bool multiplexed,
                            bool multiMultiplexed, DataStore* pDataStore, bool persistent, bool shared, int32_t size,
                            const DataIntegrity bufferType = DoubleBuffered);

    ~SettingFieldStructArray();

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

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

};

template<typename T>
SettingFieldStructArray<T>::SettingFieldStructArray(
    const std::string& fieldName, bool multiplexed, bool multiMultiplexed,
    DataStore* pDataStore, bool isPersistent, bool shared, int32_t size,
    const DataIntegrity bufferType) :
    SettingFieldArray<T> (fieldName, multiplexed, multiMultiplexed, pDataStore,
                          isPersistent, shared, size, bufferType) {
}

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

}

template<typename T>
const T* SettingFieldStructArray<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());
    }
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Return the value from the pending buffer
        return &(pFV->pendingBuffer((char*) pFV)[index]);
    }
    else
    {
        // Return the value from the active buffer
        return &(pFV->activeBuffer((char*) pFV)[index]);
    }
}

template<typename T>
void SettingFieldStructArray<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    // Partial setting method. First set, synchronize pending with active
    uint32_t size = 0;
    if (!pFV->hasPendingChanged()) {
        size = pFV->getActiveCurrentSize();
        pFV->setPendingCurrentSize(size);
        std::memcpy(pFV->pendingBuffer((char*) pFV), pFV->activeBuffer(
                   (char*) pFV), size * sizeof(T));
    }
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    size = pFV->getPendingCurrentSize();
    if ((index + 1) > size)
        pFV->setPendingCurrentSize(index+1);
    // Set cell in the pending buffer
    std::memcpy(&(pFV->pendingBuffer((char*) pFV)[index]), val, sizeof(T));
    this->registerModifiedField(pFV, context);
}

/****************** END CLASS  SettingFieldStructArray *****************/

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

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

  protected:

    void checkContext(MultiplexingContext* context);
};

template<typename T>
SettingFieldArray2D<T>::SettingFieldArray2D(const std::string& fieldName,
                                            bool multiplexed, bool multiMultiplexed, DataStore* pDataStore,
                                            bool isPersistent, bool shared, int32_t size1, int32_t size2,
                                            const DataIntegrity bufferType) :
    FieldArray2D<T> (fieldName, Setting, multiplexed, multiMultiplexed,
                     isPersistent, bufferType, pDataStore, size1, size2) {
    // Set properly the attribute isShared
    this->isShared_ = shared;
}

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

}

template<typename T>
const T** SettingFieldArray2D<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);
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Return the value from the pending buffer
        return (const T**) (pFV->pendingBuffer((char*) pFV));
    }
    else
    {
        // Return the value from the active buffer
        return (const T**) (pFV->activeBuffer((char*) pFV));
    }
}

template<typename T>
void SettingFieldArray2D<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];
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Value from the pending buffer
        activeVal = (T(*)[size2]) pFV->pendingBuffer((char*) pFV);
    }
    else
    {
        // Value from the active buffer
        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* SettingFieldArray2D<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
    // 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];
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Value from the pending buffer
        activeVal = (T(*)[size2]) pFV->pendingBuffer((char*) pFV);
    }
    else
    {
        // Value from the active buffer
        activeVal = (T(*)[size2]) pFV->activeBuffer((char*) pFV);
    }
    return activeVal[index];
}

template<typename T>
void SettingFieldArray2D<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    pFV->setPendingCurrentSize(size1, size2);
    std::memcpy(pFV->pendingBuffer((char*) pFV), val, size1 * size2 * sizeof(T));
    this->registerModifiedField(pFV, context);
}

template<typename T>
void SettingFieldArray2D<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    uint32_t size1=0, size2=0;
    // Partial setting method. First set, synchronize pending with active
    if (!pFV->hasPendingChanged()) {
        pFV->getActiveCurrentSize(size1, size2);
        pFV->setPendingCurrentSize(size1, size2);
        std::memcpy(pFV->pendingBuffer((char*) pFV), pFV->activeBuffer(
                   (char*) pFV), size1 * size2
               * sizeof(T));
    }
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    // Adjust the pending dynamic size
    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(*pendingVal)[newSize2];
    pendingVal = (T(*)[newSize2]) pFV->pendingBuffer((char*) pFV);
    for (uint32_t i = 0; i < size; i++) {
        pendingVal[i][index] = val[i];
    }
    this->registerModifiedField(pFV, context);
}

template<typename T>
void SettingFieldArray2D<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    uint32_t size1=0, size2=0;
    // Partial setting method. First set, synchronize pending with active
    if (!pFV->hasPendingChanged()) {
        pFV->getActiveCurrentSize(size1, size2);
        pFV->setPendingCurrentSize(size1, size2);
        std::memcpy(pFV->pendingBuffer((char*) pFV), pFV->activeBuffer(
                   (char*) pFV), size1 * size2
               * sizeof(T));
    }
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    // Adjust the pending dynamic size
    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));
    this->registerModifiedField(pFV, context);
}

template<typename T>
void SettingFieldArray2D<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);
}

template<typename T>
void SettingFieldArray2D<T>::checkContext(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
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
}

/****************** END CLASS  SettingFieldArray2D *****************/

template<typename T>
class SettingFieldScalarArray2D: public SettingFieldArray2D<T> {
  public:
    SettingFieldScalarArray2D(const std::string& fieldName,
                              bool multiplexed, bool multiMultiplexed,
                              DataStore* pDataStore, bool persistent, bool shared, int32_t size1, int32_t size2,
                              const DataIntegrity bufferType = DoubleBuffered);
    ~SettingFieldScalarArray2D();

    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>
SettingFieldScalarArray2D<T>::SettingFieldScalarArray2D(
    const std::string& fieldName, bool multiplexed, bool multiMultiplexed,
    DataStore* pDataStore, bool isPersistent, bool shared, int32_t size1, int32_t size2,
    const DataIntegrity bufferType) :
    SettingFieldArray2D<T> (fieldName, multiplexed, multiMultiplexed,
                            pDataStore, isPersistent, shared, size1, size2, bufferType) {
}

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

}

template<typename T>
T SettingFieldScalarArray2D<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];
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Value from the pending buffer
        activeVal = (T(*)[size2]) pFV->pendingBuffer((char*) pFV);
    }
    else
    {
        // Value from the active buffer
        activeVal = (T(*)[size2]) pFV->activeBuffer((char*) pFV);
    }
    return activeVal[index1][index2];
}

template<typename T>
void SettingFieldScalarArray2D<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    uint32_t size1=0, size2=0;
    // Partial setting method. First set, synchronize pending with active
    // in terms of value and currentSize
    if (!pFV->hasPendingChanged()) {
        pFV->getActiveCurrentSize(size1, size2);
        pFV->setPendingCurrentSize(size1, size2);
        std::memcpy(pFV->pendingBuffer((char*) pFV), pFV->activeBuffer(
                   (char*) pFV), size1 * size2
               * sizeof(T));
    }
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    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;
    this->registerModifiedField(pFV, context);
}

/****************** END CLASS  SettingFieldScalarArray2D *****************/

template<typename T>
class SettingFieldStructArray2D: public SettingFieldArray2D<T> {
  public:
    SettingFieldStructArray2D(const std::string& fieldName,
                              bool multiplexed, bool multiMultiplexed,
                              DataStore* pDataStore, bool persistent, bool shared, int32_t size1, int32_t size2,
                              const DataIntegrity bufferType = DoubleBuffered);
    ~SettingFieldStructArray2D();

    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>
SettingFieldStructArray2D<T>::SettingFieldStructArray2D(
    const std::string& fieldName, bool multiplexed, bool multiMultiplexed,
    DataStore* pDataStore, bool isPersistent, bool shared, int32_t size1, int32_t size2,
    const DataIntegrity bufferType) :
    SettingFieldArray2D<T> (fieldName, multiplexed, multiMultiplexed,
                            pDataStore, isPersistent, shared, size1, size2, bufferType) {
    this->isPersistent_ = isPersistent;
}

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

}

template<typename T>
const T* SettingFieldStructArray2D<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];
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Value from the pending buffer
        activeVal = (T(*)[size2]) pFV->pendingBuffer((char*) pFV);
    }
    else
    {
        // Value from the active buffer
        activeVal = (T(*)[size2]) pFV->activeBuffer((char*) pFV);
    }
    return &(activeVal[index1][index2]);
}

template<typename T>
void SettingFieldStructArray2D<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());
    // Check if the set is allowed
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongSourceContextSettingField.c_str(),
                            this->name_.c_str());
    this->checkContext(context);
    // 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);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    uint32_t size1=0, size2=0;
    // Partial setting method. First set, synchronize pending with active
    if (!pFV->hasPendingChanged()) {
        pFV->getActiveCurrentSize(size1, size2);
        pFV->setPendingCurrentSize(size1, size2);
        std::memcpy(pFV->pendingBuffer((char*) pFV), pFV->activeBuffer(
                   (char*) pFV), size1 * size2
               * sizeof(T));
    }
    // Set the pending buffer and pending dynamic size.
    // Register the field to be committed or rolled-back.
    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);
    T(*pendingVal)[newSize2];
    pendingVal = (T(*)[newSize2]) pFV->pendingBuffer((char*) pFV);
    std::memcpy(&(pendingVal[index1][index2]), val, sizeof(T));
    this->registerModifiedField(pFV, context);
}

/****************** END CLASS  SettingFieldStructArray2D *****************/

class SettingFieldString: public FieldString {
  public:
    SettingFieldString(const std::string& fieldName, bool multiplexed,
                       bool multiMultiplexed, DataStore* pDataStore, bool persistent, bool shared, int32_t size,

                       const DataIntegrity bufferType = DoubleBuffered);

    ~SettingFieldString();

    const char* get(MultiplexingContext* context);

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

/**************************** END CLASS SettingFieldString **********************/

class SettingFieldStringArray: public FieldStringArray {
  public:
    SettingFieldStringArray(const std::string& fieldName,
                            bool multiplexed, bool multiMultiplexed,
                            DataStore* pDataStore, bool persistent, bool shared, int32_t size1, int32_t size2,
                            const DataIntegrity bufferType = DoubleBuffered);

    ~SettingFieldStringArray();

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

    const char** get(uint32_t& size1, uint32_t& size2,
                     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 SettingFieldStringArray **********************/

} // fesa

#endif // SETTING_FIELD_H_