SettingField.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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


namespace fesa
{

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

SettingFieldString::~SettingFieldString() {

}

const char* SettingFieldString::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<char[]>* pFV = this->getFieldValue(slot);
    // Return the value from the Active buffer
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Value from the pending buffer
        return (const char*) pFV->pendingBuffer((char*) pFV);
    }
    else
    {
        // Value from the active buffer
        return (const char*) pFV->activeBuffer((char*) pFV);
    }
}

void SettingFieldString::set(const char* 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__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    uint32_t length = static_cast<uint32_t>(strlen(val));
    if (length > this->maxSize_) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldMaxDimensionOutOfBound.c_str(),
                            StringUtilities::toString(length).c_str(), this->name_.c_str(),
                            StringUtilities::toString(maxSize_).c_str());
    }
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<char[]>* pFV = this->getFieldValue(slot);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    // Set the pending buffer including teh null character(length+1)
    std::memcpy(pFV->pendingBuffer((char*) pFV), val, (length+1) * sizeof(char));
    this->registerModifiedField(pFV, context);
}

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

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

SettingFieldStringArray::~SettingFieldStringArray() {

}

const char** SettingFieldStringArray::get(uint32_t& size1,
                                          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<char *[]>* pFV = this->getFieldValue(slot);
    // Return the current size get from the Active buffer
    size1 = pFV->getActiveCurrentSize();
    if ((context->getSettingAccessMask() & MultiplexingContext::CHECK_FLAG_TO_BE_SYNC) && pFV->isToBeSync())
    {
        // Value from the pending buffer
        return (const char**) pointers_[slot][pFV->pendingBuffer()];
    }
    else
    {
        // Value from the active buffer
        return (const char**) pointers_[slot][pFV->activeBuffer()];
    }
}

const char* SettingFieldStringArray::getString(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<char *[]>* 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())
    {
        // Value from the pending buffer
        return (const char*) pointers_[slot][pFV->pendingBuffer()][index];
    }
    else
    {
        // Value from the active buffer
        return (const char*) pointers_[slot][pFV->activeBuffer()][index];
    }
}

void SettingFieldStringArray::set(const char ** val, uint32_t size1,
                                  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__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    uint32_t maxLength = 0;
    for (uint32_t i = 0; i < size1; i++) {
        maxLength = (strlen(val[i])>maxLength) ? static_cast<uint32_t>(strlen(val[i])) : maxLength;
    }
    if ((size1) > maxSize1_ || maxLength > maxSize2_) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldMaxDimensionsOutOfBound.c_str(),
                            StringUtilities::toString(size1).c_str(),
                            StringUtilities::toString(maxLength).c_str(),
                            this->name_.c_str(),
                            StringUtilities::toString(maxSize1_).c_str(),
                            StringUtilities::toString(maxSize2_).c_str());
    }
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<char *[]>* 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);
    for (uint32_t i = 0; i < size1; i++) {
        uint32_t length = static_cast<uint32_t>(strlen(val[i]));
        // copy the string including the null character(length+1)
        std::memcpy(pointers_[slot][pFV->pendingBuffer()][i], val[i],
               (length+1) * sizeof(char));
    }
    this->registerModifiedField(pFV, context);
}

void SettingFieldStringArray::setString(const char* 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
    if (!(context->getSettingAccessMask() & MultiplexingContext::SET_ALLOWED))
        throw FesaException(__FILE__, __LINE__, FesaErrorNoneContextforMuxedField.c_str(),
                            this->name_.c_str());
    // Check against Max dimensions. Exception is thrown in case of out of bound
    uint32_t length = static_cast<uint32_t>(strlen(val));
    if ((index+1) > maxSize1_ || length > maxSize2_) {
        throw FesaException(__FILE__, __LINE__,
                            FesaErrorFieldMaxDimensionsOutOfBound.c_str(),
                            StringUtilities::toString(index+1).c_str(),
                            StringUtilities::toString(length).c_str(),
                            this->name_.c_str(),
                            StringUtilities::toString(maxSize1_).c_str(),
                            StringUtilities::toString(maxSize2_).c_str());
    }
    // Retrieve the right FieldValue according to the slot
    uint32_t slot = (this->multiplexingManager_ == NULL) ? 0
        : this->multiplexingManager_->requireSlot(*context);
    FieldValue<char *[]>* pFV = this->getFieldValue(slot);
    // reset toBeSync flag of the field value
    this->resetToBeSync(slot);
    // Partial setting method. First set, synchronize pending with active
    if (!pFV->hasPendingChanged()) {
        uint32_t size = pFV->getActiveCurrentSize();
        pFV->setPendingCurrentSize(size);
        std::memcpy(pointers_[slot][pFV->pendingBuffer()][0],
               pointers_[slot][pFV->activeBuffer()][0],
               this->maxSize1_ * (this->maxSize2_ + 1) * sizeof(char));
    }
    // Adjust the dynamic dimension if it's required
    uint32_t size = pFV->getPendingCurrentSize();
    if ((index + 1) > size)
        pFV->setPendingCurrentSize(index+1);
    std::memcpy(pointers_[slot][pFV->pendingBuffer()][index], val, (length+1)
           * sizeof(char));
    this->registerModifiedField(pFV, context);
}

/**************************** END CLASS FieldStringArray **********************/

} // fesa