FieldStringArray.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <fesa-core/Synchronization/AbstractMultiplexingManager.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Utilities/ParserElements.h>
#include <fesa-core/Utilities/StringUtilities.h>
#include <fesa-core/Exception/FesaException.h>

#include <cstring>


namespace fesa
{

FieldStringArray::FieldStringArray(const std::string& fieldName, const FieldCategory fieldCategory, bool multiplexed,
                                   bool multiMultiplexed, bool persistent, DataIntegrity bufferType,
                                   DataStore* pDataStore, int32_t arrayLength, int32_t stringLength) :
    AbstractField(fieldName, fieldCategory, multiplexed, multiMultiplexed, persistent, bufferType, pDataStore),
    maxSize1_(arrayLength),
    maxSize2_(stringLength),
    pointers_(NULL)
{
}

FieldStringArray::~FieldStringArray()
{
    int32_t depth = 1;

    if (this->multiplexingManager_)
    {
        depth = this->multiplexingManager_->getDepth();
    }

    for (int32_t i = 0; i < depth; i++)
    {
        for (int32_t k = 0; k < buffer_; k++)
        {
            delete pointers_[i][k];
        }
        delete pointers_[i];
    }
    delete pointers_;
}

void FieldStringArray::initialize(FieldElement& fieldElement)
{
    if (fieldElement.dimension1_ > 0)
    {
        this->maxSize1_ = fieldElement.dimension1_;

    }
    if (fieldElement.dimension2_ > 0)
    {
        this->maxSize2_ = fieldElement.dimension2_;

    }

}

uint32_t FieldStringArray::getFieldValueSize()
{
    if (valueSize_ == 0)
    {
        // add + 1 to the maxSize2_ for the '\0' character
        valueSize_ = static_cast<uint32_t>(sizeof(FieldValue<char*[]>)) + static_cast<uint32_t>(sizeof(char)) * (this->maxSize1_) * (this->maxSize2_ + 1)
            * buffer_;
    }
    return valueSize_;
}

void FieldStringArray::setFieldValueAddress(char* pFV, bool initFieldsFlag)
{
    int32_t depth = 1;

    if (this->multiplexingManager_)
    {
        depth = this->multiplexingManager_->getDepth();
    }

    //attach field to provided memory
    this->fieldValue_ = (FieldValue<char *[]>*) pFV;

    // allocate the table of pointers
    pointers_ = (char****) new char***[depth];

    for (int32_t i = 0; i < depth; i++)
    {
        pointers_[i] = (char***) new char**[buffer_];
        for (int32_t k = 0; k < buffer_; k++)
        {
            pointers_[i][k] = (char **) new char*[maxSize1_];
        }

        if (initFieldsFlag)
            new (pFV) FieldValue<char *[]> (buffer_, maxSize1_);

        pFV += sizeof(FieldValue<char *[]>);

        for (int32_t k = 0; k < buffer_; k++)
        {
            for (uint32_t j = 0; j < this->maxSize1_; j++)
            {
                pointers_[i][k][j] = pFV;
                pFV += (sizeof(char) * (this->maxSize2_ + 1));
            }
        }
    }
}

FieldValue<char *[]>* FieldStringArray::getFieldValue(int32_t slot)
{

    char* address = (char*) this->fieldValue_;
    address += valueSize_ * slot;
    return (FieldValue<char *[]>*) address;

}

void FieldStringArray::copyValue(uint32_t slot, std::string& str)
{
    // Copy the string into a temp string because the original one cannot be modified because
    // it is used to populate the other slots if the filed is multiplexed.
    std::string arrayTmp = str;

    StringUtilities::removeBrackets(arrayTmp);
    std::vector<std::string> tokens;

    StringUtilities::getElements(arrayTmp, tokens);

    FieldValue<char *[]>* pFV = this->getFieldValue(slot);

    if(tokens.size() > maxSize1_)
        throw FesaException(__FILE__, __LINE__, FesaErrorValueExceedsLimits.c_str(),str.c_str(),name_.c_str());

    pFV->setPendingCurrentSize (static_cast<uint32_t>(tokens.size()));
    pFV->setActiveCurrentSize (static_cast<uint32_t>(tokens.size()));

    for (uint32_t j = 0; j < maxSize1_; j++)
    {
        if (tokens.size() > j)
        {
            if (maxSize2_ < tokens[j].size())
                throw FesaException(__FILE__, __LINE__, FesaErrorValueExceedsLimits.c_str(),str.c_str(),name_.c_str());

            int32_t size = static_cast<uint32_t>(tokens[j].size());

            std::memcpy(pointers_[slot][pFV->activeBuffer()][j], tokens[j].c_str(), size * sizeof(char));
            pointers_[slot][pFV->activeBuffer()][j][size] = '\0';

            std::memcpy(pointers_[slot][pFV->pendingBuffer()][j], tokens[j].c_str(), size * sizeof(char));
            pointers_[slot][pFV->pendingBuffer()][j][size] = '\0';
        }
        else
        {
            pointers_[slot][pFV->activeBuffer()][j][0] = '\0';
            pointers_[slot][pFV->pendingBuffer()][j][0] = '\0';
        }
    }
}

void FieldStringArray::getValueToStore(int32_t slot, std::string& value)
{
    value = "{";

    FieldValue<char *[]>* pFV = this->getFieldValue(slot);

    uint32_t currentSize = pFV->getActiveCurrentSize();

    for (uint32_t j = 0; j < currentSize; j++)
    {
        if (pFV->hasPendingChanged() || pFV->isToBeSync())
        {
            value += pointers_[slot][pFV->pendingBuffer()][j];
        }
        else
        {
            value += pointers_[slot][pFV->activeBuffer()][j];
        }
        if (j != currentSize - 1)
            value += ",";
    }
    value += "}";
}

void FieldStringArray::getMaxSize(uint32_t& size1, uint32_t& size2) {
    size1 = this->maxSize1_;
    size2 = this->maxSize2_;

}

uint32_t  FieldStringArray::getSize(MultiplexingContext* context)
{
    // 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
    return pFV->getActiveCurrentSize();
}

} // fesa