ConfigurationField.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef CONFIGURATION_FIELD_H_
#define CONFIGURATION_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>

namespace fesa
{

/****************** CLASS  ConfigFieldScalar *********************/
template<typename T>
class ConfigFieldScalar : public Field<T> {
  public:

    ConfigFieldScalar(const std::string& fieldName, DataStore* pDataStore,
                      const DataIntegrity bufferType = SingleBuffered);
    ~ConfigFieldScalar();

    T get();

    //  /*!
    //   * \fn getAsString
    //   * \brief Retrieves field value of configuration field as string
    //   */
    //  const std::string getAsString();

};

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

}

template<typename T>
ConfigFieldScalar<T>::ConfigFieldScalar(const std::string& fieldName, DataStore* pDataStore,
                                        const DataIntegrity bufferType) :
    Field<T> (fieldName, Configuration, false, false, false, bufferType,
              pDataStore) {
}

template<typename T>
T ConfigFieldScalar<T>::get() {
    return (this->fieldValue_->activeBuffer((char*) this->fieldValue_));
}

//template<typename T>
//const std::string ConfigFieldScalar<T>::getAsString() {
//      T value = this->fieldValue_->activeBuffer((char*) this->fieldValue_);
//      std::string result;
//      Converter<T>::valueToString(value, result);
//      return result;
//}

/****************** END CLASS  ConfigFieldScalar *********************/

/****************** CLASS  ConfigFieldStruct *********************/
template<typename T>
class ConfigFieldStruct: public Field<T> {
  public:

    ConfigFieldStruct(const std::string& fieldName, DataStore* pDataStore,
                      const DataIntegrity bufferType = SingleBuffered);
    ~ConfigFieldStruct();

    const T* get();

    //  /*!
    //   * \fn getAsString
    //   * \brief Retrieves field value of configuration field as string
    //   */
    //  const std::string getAsString();

};

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

}

template<typename T>
ConfigFieldStruct<T>::ConfigFieldStruct(const std::string& fieldName, DataStore* pDataStore,
                                        const DataIntegrity bufferType) :
    Field<T> (fieldName, Configuration, false, false, false, bufferType,
              pDataStore) {
}

template<typename T>
const T* ConfigFieldStruct<T>::get() {
    return (&(this->fieldValue_->activeBuffer((char*) this->fieldValue_)));
}

//template<typename T>
//const std::string ConfigFieldStruct<T>::getAsString() {
//      T value = this->fieldValue_->activeBuffer((char*) this->fieldValue_);
//      std::string result;
//      Converter<T>::valueToString(value, result);
//      return result;
//}

/****************** END class ConfigFieldStruct ****************/

/*** class ConfigFieldArray base class for ConfigFieldScalarArray and ConfigFieldStructArray ***/
template<typename T>
class ConfigFieldArray: public FieldArray<T> {
  public:
    ConfigFieldArray(const std::string& fieldName, DataStore* pDataStore, int32_t size,
                     const DataIntegrity bufferType = SingleBuffered);

    ~ConfigFieldArray();

    const T* get(uint32_t& size);

    uint32_t getSize();
};

template<typename T>
ConfigFieldArray<T>::ConfigFieldArray(const std::string& fieldName,
                                      DataStore* pDataStore, int32_t size,
                                      const DataIntegrity bufferType) :
    FieldArray<T> (fieldName, Configuration, false, false, false, bufferType,
                   pDataStore, size) {

}

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

}

template<typename T>
const T* ConfigFieldArray<T>::get(uint32_t& size) {
    size = this->fieldValue_->getActiveCurrentSize();
    return (const T*) (this->fieldValue_->activeBuffer(
                           (char*) this->fieldValue_));
}

template<typename T>
uint32_t ConfigFieldArray<T>::getSize() {
    return this->fieldValue_->getActiveCurrentSize();
}

/****************** END CLASS  ConfigFieldArray *********************/

/****************** CLASS  ConfigFieldScalarArray *********************/
template<typename T>
class ConfigFieldScalarArray: public ConfigFieldArray<T> {
  public:
    ConfigFieldScalarArray(const std::string& fieldName, DataStore* pDataStore, int32_t size,
                           const DataIntegrity bufferType = SingleBuffered);

    ~ConfigFieldScalarArray();

    T getCell(uint32_t index);

};

template<typename T>
ConfigFieldScalarArray<T>::ConfigFieldScalarArray(const std::string& fieldName,
                                                  DataStore* pDataStore, int32_t size,   const DataIntegrity bufferType) :
    ConfigFieldArray<T> (fieldName, pDataStore, size,
                         bufferType) {

}

template<typename T>
T ConfigFieldScalarArray<T>::getCell(uint32_t index) {
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size = this->fieldValue_->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 this->fieldValue_->activeBuffer((char*) this->fieldValue_)[index];
}

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

}

/****************** END CLASS  ConfigFieldScalarArray *****************/

/****************** CLASS  ConfigFieldStructArray *****************/
template<typename T>
class ConfigFieldStructArray: public ConfigFieldArray<T> {
  public:
    ConfigFieldStructArray(const std::string& fieldName, DataStore* pDataStore, int32_t size,
                           const DataIntegrity bufferType = SingleBuffered);

    ~ConfigFieldStructArray();

    const T* getCell(uint32_t index);

};

template<typename T>
ConfigFieldStructArray<T>::ConfigFieldStructArray(const std::string& fieldName,
                                                  DataStore* pDataStore, int32_t size,   const DataIntegrity bufferType) :
    ConfigFieldArray<T> (fieldName, pDataStore, size,
                         bufferType) {

}

template<typename T>
const T* ConfigFieldStructArray<T>::getCell(uint32_t index) {
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size = this->fieldValue_->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 &(this->fieldValue_->activeBuffer((char*) this->fieldValue_)[index]);
}

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

}

/****************** END CLASS  ConfigFieldStructArray *****************/

/*** CLASS  ConfigFieldArray2D base class for ConfigFiedScalarArray2D and ConfigFieldStructArray2D ***/
template<typename T>
class ConfigFieldArray2D : public FieldArray2D<T> {
  public:

    ConfigFieldArray2D(const std::string& fieldName, DataStore* pDataStore, int32_t size1, int32_t size2,
                       const DataIntegrity bufferType = SingleBuffered);

    ~ConfigFieldArray2D();

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

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

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

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

};

template<typename T>
ConfigFieldArray2D<T>::ConfigFieldArray2D(const std::string& fieldName,
                                          DataStore* pDataStore, int32_t size1, int32_t size2,
                                          const DataIntegrity bufferType) :
    FieldArray2D<T> (fieldName, Configuration, false, false, false, bufferType,
                     pDataStore, size1, size2) {
}

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

}

template<typename T>
const T** ConfigFieldArray2D<T>::get(uint32_t& size1, uint32_t& size2) {
    this->fieldValue_->getActiveCurrentSize(size1, size2);
    return (const T**) this->fieldValue_->activeBuffer(
        (char*) this->fieldValue_);
}

template<typename T>
void ConfigFieldArray2D<T>::getColumn(uint32_t index, uint32_t size,
                                      T* column, uint32_t& currentSize) {

    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    this->fieldValue_->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());
    }
    currentSize = size1;
    T(*activeVal)[size2];
    activeVal = (T(*)[size2]) this->fieldValue_->activeBuffer((char*) this->fieldValue_);
    for (uint32_t i = 0; i < size1; i++) {
        column[i] = activeVal[i][index];
    }
}

template<typename T>
const T* ConfigFieldArray2D<T>::getRow(uint32_t index, uint32_t& size) {

    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    this->fieldValue_->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]) this->fieldValue_->activeBuffer((char*) this->fieldValue_);
    return activeVal[index];
}

template<typename T>
void ConfigFieldArray2D<T>::getSize(uint32_t& size1, uint32_t& size2) {
    this->fieldValue_->getActiveCurrentSize(size1, size2);
}
/****************** END CLASS  ConfigFieldArray2D *****************/

template<typename T>
class ConfigFieldScalarArray2D: public ConfigFieldArray2D<T> {
  public:

    ConfigFieldScalarArray2D(const std::string& fieldName, DataStore* pDataStore, int32_t size1, int32_t size2,
                             const DataIntegrity bufferType = SingleBuffered);

    ~ConfigFieldScalarArray2D();

    T getCell(uint32_t index1, uint32_t index2);

};

template<typename T>
ConfigFieldScalarArray2D<T>::ConfigFieldScalarArray2D(
    const std::string& fieldName, DataStore* pDataStore, int32_t size1, int32_t size2,
    const DataIntegrity bufferType) :
    ConfigFieldArray2D<T> (fieldName, pDataStore, size1, size2,
                           bufferType) {
}

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

}

template<typename T>
T ConfigFieldScalarArray2D<T>::getCell(uint32_t index1,
                                       uint32_t index2) {
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    this->fieldValue_->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());
    }

    T(*activeVal)[size2];
    activeVal = (T(*)[size2]) this->fieldValue_->activeBuffer(
        (char*) this->fieldValue_);
    return activeVal[index1][index2];
}

/****************** END CLASS  ConfigFieldScalarArray2D *****************/

template<typename T>
class ConfigFieldStructArray2D: public ConfigFieldArray2D<T> {
  public:

    ConfigFieldStructArray2D(const std::string& fieldName,
                             DataStore* pDataStore, int32_t size1, int32_t size2,
                             const DataIntegrity bufferType = SingleBuffered);

    ~ConfigFieldStructArray2D();

    const T* getCell(uint32_t index1, uint32_t index2);

};

template<typename T>
ConfigFieldStructArray2D<T>::ConfigFieldStructArray2D(
    const std::string& fieldName, DataStore* pDataStore, int32_t size1, int32_t size2,
    const DataIntegrity bufferType) :
    ConfigFieldArray2D<T> (fieldName, pDataStore, size1, size2,
                           bufferType) {
}

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

}

template<typename T>
const T* ConfigFieldStructArray2D<T>::getCell(uint32_t index1,
                                              uint32_t index2) {
    // Check against dynamic dimensions. Exception is thrown in case of out of bound
    uint32_t size1, size2;
    this->fieldValue_->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());
    }

    T(*activeVal)[size2];
    activeVal = (T(*)[size2]) this->fieldValue_->activeBuffer(
        (char*) this->fieldValue_);

    return &(activeVal[index1][index2]);
}

/****************** END CLASS  ConfigFieldStructArray2D *****************/

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

    ~ConfigFieldString();

    const char* get();

    const std::string getAsString();

};

/**************************** END ConfigFieldString **********************/

class ConfigFieldStringArray: public FieldStringArray {
  public:

    ConfigFieldStringArray(const std::string& fieldName, DataStore* pDataStore, int32_t size1, int32_t size2,
                           const DataIntegrity bufferType = SingleBuffered);
    ~ConfigFieldStringArray();

    const char** get(uint32_t& size1);

    const char* getString(uint32_t index);

};

/**************************** END ConfigFieldStringArray **********************/

} // fesa

#endif // CONFIGURATION_FIELD_H_