FieldString.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

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

#include <cstring>


namespace fesa
{

FieldString::FieldString(const std::string& fieldName, const FieldCategory fieldCategory, bool multiplexed,
                         bool multiMultiplexed, bool persistent, DataIntegrity bufferType, DataStore* pDataStore, int32_t size) :
    AbstractField(fieldName, fieldCategory, multiplexed, multiMultiplexed, persistent,bufferType, pDataStore), maxSize_(size)

{

}

FieldString::~FieldString()
{
}


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

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

}

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

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



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

    if (initFieldsFlag)
    {
        for (int32_t i = 0; i < depth; i++)
        {
            FieldValue<char[]>* temp = new (pFV) FieldValue<char[]> (buffer_, maxSize_);
            if (!temp)
            {
                throw FesaException(__FILE__, __LINE__, FesaErrorSettingFieldValueAddress.c_str(), name_.c_str());
            }
            pFV += this->valueSize_;
        }
    }

}


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

    }

}

uint32_t FieldString::getFieldValueSize()
{

    if (valueSize_ == 0)
    {
        valueSize_ = static_cast<uint32_t>(sizeof(FieldValue<char[]>)) + static_cast<uint32_t>(sizeof(char)) * (this->maxSize_ + 1) * buffer_; // add +1 for the symbol '\0' at the end of the string
    }
    return valueSize_;
}

void FieldString::copyValue(uint32_t slot, std::string& str)
{
    int32_t currentSize = str.size() < this->maxSize_ ? static_cast<uint32_t>(str.size()) : this->maxSize_;


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

    std::memcpy(pFV->activeBuffer((char*)pFV), str.c_str(), currentSize * sizeof(char));
    pFV->activeBuffer((char*)pFV)[currentSize] = '\0';
    std::memcpy(pFV->pendingBuffer((char*)pFV), str.c_str(), currentSize * sizeof(char));
    pFV->pendingBuffer((char*)pFV)[currentSize] = '\0';

}

void FieldString::getValueToStore(int32_t slot,std::string& str)
{

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

    if (pFV->hasPendingChanged() || pFV->isToBeSync())
    {
        str = pFV->pendingBuffer((char*)pFV);
    }
    else
    {
        str = pFV->activeBuffer((char*)pFV);
    }

}

uint32_t FieldString::getMaxSize()
{
    return this->maxSize_;
}

} // fesa