GenericField.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

namespace fesa
{

GenericFieldString::GenericFieldString(const std::string& fieldName, bool multiplexed, DataStore* pDataStore,
                                       bool persistent, int32_t size, DataIntegrity bufferType) :
    FieldString (fieldName, Generic, multiplexed, false, persistent, bufferType, pDataStore, size)
{
}

GenericFieldString::~GenericFieldString() {

}

const char* GenericFieldString::get(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_->getSlot(*context);
    FieldValue<char[]>* pFV = this->getFieldValue(slot);
    return (const char*) pFV->activeBuffer((char*) pFV);
}

void GenericFieldString::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 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);
    // Set the pending buffer
    std::memcpy(pFV->pendingBuffer((char*) pFV), val, (length+1) * sizeof(char));
}

GenericFieldStringArray::GenericFieldStringArray(const std::string& fieldName,
                                                 bool multiplexed, DataStore* pDataStore, bool persistent,
                                                 int32_t size1, int32_t size2, DataIntegrity bufferType) :
    FieldStringArray(fieldName, Generic, multiplexed, false, persistent,
                     bufferType, pDataStore, size1, size2) {
}

GenericFieldStringArray::~GenericFieldStringArray() {

}

const char** GenericFieldStringArray::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<char*[]>* pFV = this->getFieldValue(slot);
    // Return the current size get from the Active buffer
    size = pFV->getActiveCurrentSize();
    return (const char**) pointers_[slot][pFV->activeBuffer()];

}

const char* GenericFieldStringArray::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());
    }
    // Return the value from the Active buffer
    return (const char*) pointers_[slot][pFV->activeBuffer()][index];
}

void GenericFieldStringArray::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 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);
    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));
    }
}

void GenericFieldStringArray::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 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);
    // Adjust the dynamic dimension if it's required
    uint32_t size = pFV->getPendingCurrentSize();
    if ((index + 1) > size)
        pFV->setPendingCurrentSize(index+1);
    // Set the new string in the pending buffer
    std::memcpy(pointers_[slot][pFV->pendingBuffer()][index], val, (length+1)
           * sizeof(char));
}

} // fesa