InitializeDataStoreManager.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Utilities/XMLParser.h>
#include <fesa-core/Utilities/ParserElements.h>
#include <fesa-core/Utilities/StringUtilities.h>
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/DataStore/AbstractDevice.h>
#include <fesa-core/DataStore/DomainStore.h>
#include <fesa-core/DataStore/AbstractField.h>
#include <fesa-core/Utilities/ParserElements/ParserElementDefs.h>
#include <cmw-log/Logger.h>

namespace
{
CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.DataStore");
}


namespace fesa
{

InitializeDataStoreManager::InitializeDataStoreManager(const std::string className) :
    globalDeviceElement_(NULL)

{
    className_ = className;
    std::string instanceFile = AbstractEquipment::getInstance()->getDeviceDataFileName();
    parser_ = new XMLParser(instanceFile, true);
    if(logger.isLoggable(CMW::Log::Level::LL_DEBUG))
    {
        std::ostringstream msg;
        msg << "Initialising DataStore for class " << className;
        LOG_DEBUG_IF(logger, msg.str());
    }
}

InitializeDataStoreManager::~InitializeDataStoreManager()
{
    if (globalDeviceElement_)
        delete globalDeviceElement_;

    for (uint32_t i = 0; i < pDeviceElementCol_.size(); i++)
        delete pDeviceElementCol_[i];
    pDeviceElementCol_.clear();

    for (uint32_t i = 0; i < pDomainStoreElementCol_.size(); i++)
        delete pDomainStoreElementCol_[i];

    pDomainStoreElementCol_.clear();
    delete parser_;
}

GlobalDeviceElement& InitializeDataStoreManager::retrieveGlobalDeviceElement()
{
    if (globalDeviceElement_ != NULL)
    {
        return *globalDeviceElement_;
    }
    AttributeXML* pAttr = NULL;
    std::string fieldValue = "";
    std::string extraConditionName = "";
    std::string extraConditionValue = "";

    // restore global device
    pAttr = parser_->extractAttribute(GLOBAL_DEVICE_ELEMENT_TAG,GLOBAL_DEVICE_ELEMENT_ATTRIBUTE_TAG);
    if (pAttr == NULL)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorXMLAttributeNotFound.c_str(), GLOBAL_DEVICE_ELEMENT_TAG.c_str(),
                        GLOBAL_DEVICE_ELEMENT_ATTRIBUTE_TAG.c_str());
    }
    std::string name = pAttr->value_;
    delete pAttr;

    globalDeviceElement_ = new GlobalDeviceElement(name);
    std::string globalDeviceXPath = CLASSES_TAG + "/" + className_ + "/" + GLOBAL_DEVICE_ELEMENT_TAG;
    std::vector<ElementXML*>* pElCol = parser_->extractElementsFromXPath(globalDeviceXPath);
    if (pElCol == NULL)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorXMLElementNotFound.c_str(), globalDeviceXPath.c_str());
    }
    ElementXML* pGlobalEl = (*pElCol)[0];
    delete pElCol;

    // go through the fields
    for (uint32_t i = 0; i < pGlobalEl->childList_.size(); i++)
    {

        ElementXML* pFieldType = pGlobalEl->childList_[i];
        if (pFieldType->name_ != DEVICE_CONFIGURATION_ELEMEMT_TAG && pFieldType->name_ != DEVICE_SETTING_ELEMEMT_TAG && pFieldType->name_
            != "generic" && pFieldType->name_  != DEVICE_ACQUISITION_ELEMEMT_TAG)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorLoadGlobalDeviceElement.c_str());
        }
        if (pFieldType->childList_.size() == 0)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorLoadGlobalDeviceElement.c_str());
        }
        for (uint32_t j = 0; j < pFieldType->childList_.size(); j++)
        {
            ElementXML* pField = pFieldType->childList_[j];
            FieldElement* pFieldElement = new FieldElement(pField->name_);
            pFieldElement->fromPersistency_ = false;
            this->fillElement(pField, pFieldElement);
            globalDeviceElement_->addFieldElement(pFieldElement);
        }
    }
    return *globalDeviceElement_;
}

const std::vector<DeviceElement*>& InitializeDataStoreManager::retrieveDeviceElements()
{
    // remove previous devices if any
    for (uint32_t i = 0; i < pDeviceElementCol_.size(); i++)
    {
        delete pDeviceElementCol_[i];
    }
    pDeviceElementCol_.clear();

    std::vector<ElementXML*>* pElCol = NULL;
    std::string extraConditionName = "";
    std::string extraConditionValue = "";

    std::map<int32_t, std::string> mapCycle;
    std::string DeviceInstancesXPath = CLASSES_TAG + "/" + className_ + "/" + DEVICE_ELEMENT_TAG;

    pElCol = parser_->extractElementsFromXPath(DeviceInstancesXPath);
    if (pElCol == NULL)
    {
        LOG_ERROR_IF(logger, "No device-instance found!");
        throw FesaException(__FILE__, __LINE__, FesaErrorXMLElementNotFound.c_str(), DeviceInstancesXPath.c_str());
    }

    //Loop over all device-instance elements
    for (uint32_t i = 0; i < pElCol->size(); i++)
    {
        ElementXML* pDeviceEl = (*pElCol)[i];
        /*
         * Device instance field has attribute name
         * <device-instance name="PSBTestDevice">
         */
        if (pDeviceEl->attributeList_.size() == 0 || pDeviceEl->attributeList_[0]->name_ != DEVICE_ELEMENT_ATTRIBUTE_TAG)
        {
            LOG_DEBUG_IF(logger, "Mandatory attribute 'name' not found on device-instance element!");
            throw FesaException(__FILE__, __LINE__, FesaErrorLoadDeviceElements.c_str());
        }
        AttributeXML* pAttr = pDeviceEl->attributeList_[0];

        DeviceElement* pDeviceElement = new DeviceElement(pAttr->value_);
        pDeviceElementCol_.push_back(pDeviceElement);

        /*
         *<device-instance name="MyTestDevice">
         *    <configuration>
         *        <description value="It's a None PSB device"/>
         *        <accelerator value="ISO"/>
         *        <timingDomain value="PSB"/>
         *        <isMux value="false"/>
         *    </configuration>
         *   <setting>
         *        <amplitude value="20"/>
         *   </setting>
         *</device-instance>
         */        
        for (uint32_t i = 0; i < pDeviceEl->childList_.size(); i++)
        {
            ElementXML* pFieldType = pDeviceEl->childList_[i];
            if (logger.isLoggable(CMW::Log::Level::LL_TRACE))
            {
                std::ostringstream msg;
                msg << "Processing element " << pFieldType->name_ << " in device-instance " << pAttr->value_;
                LOG_TRACE_IF(logger, msg.str());
            }
            if(pFieldType->name_ == EVENTS_MAPPING_ELEMENT_TAG)
            {
                continue;//skip events-mapping element
            }
            if ( pFieldType->name_ != DEVICE_CONFIGURATION_ELEMEMT_TAG && pFieldType->name_ != DEVICE_SETTING_ELEMEMT_TAG && pFieldType->name_ != DEVICE_ACQUISITION_ELEMEMT_TAG )
            {
                std::ostringstream msg;
                msg << "Invalid field sub-part " << pFieldType->name_ << " for device-instance " << pAttr->value_;
                LOG_ERROR_IF(logger, msg.str());
                throw FesaException(__FILE__, __LINE__, FesaErrorLoadDeviceElements.c_str());
            }
            processDeviceFields(pFieldType->childList_, pDeviceElement);
        }
    }
    for (uint32_t i = 0; i < pElCol->size(); i++)
    {
        delete (*pElCol)[i];
    }
    delete pElCol;
    return pDeviceElementCol_;
}

void InitializeDataStoreManager::processDeviceFields(const std::vector<ElementXML*>& fields, DeviceElement* pDeviceElement)
{
    if (fields.size() == 0)
    {
        LOG_ERROR_IF(logger, "processDeviceFields: fields vector can't be empty");
        throw FesaException(__FILE__, __LINE__, FesaErrorLoadDeviceElements.c_str());
    }
    for (uint32_t j = 0; j < fields.size(); j++)
    {
        ElementXML* pField = fields[j];
        FieldElement* pFieldElement = new FieldElement(pField->name_);
        pFieldElement->fromPersistency_ = false;

        // Checking if the ElementXML is a device-related field, in that case it does not have attributes
        // For device-related fields the fieldValue is the concatenation of device names
        if( pField->name_ == DEVICE_RELATIONS_TAG )
        {
            processDeviceRelationField(pField, pFieldElement);
        }
        else if( pField->name_ == EXTRA_MUX_TAG )
        {
            processExtraMuxField(pField, pDeviceElement);
        }
        else
        {
            fillElement(pField, pFieldElement);
        }
        pDeviceElement->addFieldElement(pFieldElement);
    }
}

void InitializeDataStoreManager::processDeviceRelationField(const ElementXML* pField, FieldElement* pFieldElement)
{
    std::string fieldValue = "{";
    std::vector<ElementXML*> parameters = pField->childList_;
    // the field is a vector
    pFieldElement->dimension1_ = static_cast<uint32_t>(parameters.size());
    for (uint32_t k = 0; k < parameters.size(); k++)
    {
        // go through the attributes
        for (uint32_t m = 0; m < parameters[k]->attributeList_.size(); m++)
        {
            AttributeXML* pAttr = parameters[k]->attributeList_[m];
            fieldValue = fieldValue + pAttr->name_ + "=" + pAttr->value_ + " ";
        }
        if (k != parameters.size() - 1)
        {
            fieldValue += ",";
        }
    }
    fieldValue += "}";
    pFieldElement->fieldValuesCol_.insert(make_pair(0, fieldValue));
}

void InitializeDataStoreManager::processExtraMuxField(const ElementXML* pField, DeviceElement* pDeviceElement)
{
    std::vector<ElementXML*> criteria = pField->childList_;
    // go through the different elements storing the extra criterion
    for (uint32_t k = 0; k < criteria.size(); k++)
    {
        // go through the attributes
        for (uint32_t m = 0; m < criteria[k]->attributeList_.size(); m++)
        {
            AttributeXML* pAttr = criteria[k]->attributeList_[m];
            if (pAttr->name_.compare("value"))
            {
                pDeviceElement->extraCriterionCol_.push_back(pAttr->value_);
            }
        }
    }
}

void InitializeDataStoreManager::fillElement(const ElementXML* pField, FieldElement* pFieldElement)
{
    std::string fieldValue = getFieldValue(pField);
    if (!fieldValue.empty())
    {
        pFieldElement->fieldValuesCol_.insert(make_pair(0, fieldValue));
    }
    for (uint32_t ext = 0; ext < pField->childList_.size(); ext++)
    {
        ElementXML* child = pField->childList_[ext];
        if (child->name_ == DIM_TAG || child->name_ == DIM1_TAG)
        {
            pFieldElement->dimension1_ = getAttributeValueAsInt(child);
        }
        else if (child->name_ == DIM2_TAG)
        {
            pFieldElement->dimension2_ = getAttributeValueAsInt(child);
        }
    }
    if (logger.isLoggable(CMW::Log::Level::LL_TRACE))
    {
        std::ostringstream msg;
        msg << "Element " << pField->name_ << " has value " << fieldValue;
        msg << ", dim(" << pFieldElement->dimension1_ << ", " << pFieldElement->dimension2_ << ").";
        LOG_TRACE_IF(logger, msg.str());
    }
}

std::string InitializeDataStoreManager::getFieldValue(const ElementXML* pField)
{
    std::string value = getAttributeValue(pField); // most of the fields directly have a value attribute
    if(value.empty())
    {   // Others have an element "value"
        std::vector<ElementXML*>::const_iterator iter = pField->childList_.begin();
        for(;iter!=pField->childList_.end();++iter)
        {
            if((*iter)->name_ == "value")
            {
                value = (*iter)->value_;
            }
        }
    }
    return value;
}

std::string InitializeDataStoreManager::getAttributeValue(const ElementXML* element)
{
    AttributeXML* pAttr;
    for (uint32_t extIdx = 0; extIdx < element->attributeList_.size(); extIdx++)
    {   // looking for the value attribute in the element
        pAttr = element->attributeList_[extIdx];
        if (pAttr->name_ == VALUE_TAG)
        {
            return pAttr->value_;
        }
    }
    return std::string("");
}

uint32_t InitializeDataStoreManager::getAttributeValueAsInt(const ElementXML* element)
{
    std::string value = getAttributeValue(element);
    if (!value.empty())
    {
        uint32_t dim;
        StringUtilities::fromString(dim, value);
        return dim;
    }
    return 0;
}

const std::vector<DomainStoreElement*>& InitializeDataStoreManager::retrieveDomainStoreElements()
{
    // remove previous devices if any
    for (uint32_t i = 0; i < pDomainStoreElementCol_.size(); i++)
        delete pDomainStoreElementCol_[i];
    pDomainStoreElementCol_.clear();

    std::vector<ElementXML*>* pElCol = NULL;
    AttributeXML* pAttr = NULL;
    std::string fieldValue = "";
    std::string extraConditionName = "";
    std::string extraConditionValue = "";
    std::map<int32_t, std::string> map;

    std::string DomainStoreXPath = CLASSES_TAG + "/" + className_ + "/" + DOMAIN_STORE_TAG;
    pElCol = parser_->extractElementsFromXPath(DomainStoreXPath);

    if(pElCol != NULL) // since DomainStore is optional
    {
        //Loop over all device fields in vector pElCol
        for (uint32_t i = 0; i < pElCol->size(); i++)
        {
            ElementXML* pDomainEl = (*pElCol)[i];

            if( pDomainEl->attributeList_.size() == 0 || pDomainEl->attributeList_[0]->name_ != DOMAIN_STORE_ATTRIBUTE_TAG )
            {
                throw FesaException(__FILE__, __LINE__, FesaErrorLoadDomainStoreElements.c_str());
            }
            pAttr = pDomainEl->attributeList_[0];

            DomainStoreElement* pDomainStoreElement = new DomainStoreElement(pAttr->value_);
            pDomainStoreElementCol_.push_back(pDomainStoreElement);
            /*
             *<domain-data name="PSB">
             *    <const>
             *        <description value="It's a None PSB device"/>
             *        <accelerator value="ISO"/>
             *        <timingDomain value="PSB"/>
             *        <isMux value="false"/>
             *    </const>
             *   <persistent>
             *        <amplitude value="20">
             *            <extra-criterion name="PSB.PARTY.PROT" value="30"/>
             *            <extra-criterion name="PSB.DEST.DUMP" value="40"/>
             *            <extra-criterion name="PSB.DEST.PS" value="50"/>
             *        </amplitude>
             *    </persistent>
             *    <volatile>
             *        <offset value="-13"/>
             *    </volatile>
             *</domain-data>
             */
            //The children of the device instance tag are <configuration>, <setting> or <generic>
            for (uint32_t i = 0; i < pDomainEl->childList_.size(); i++)
            {
                ElementXML* pFieldType = pDomainEl->childList_[i];
                if (pFieldType->name_ != DEVICE_CONFIGURATION_ELEMEMT_TAG && pFieldType->name_ != DEVICE_SETTING_ELEMEMT_TAG && pFieldType->name_ != GENERIC_TAG )
                {
                    throw FesaException(__FILE__, __LINE__, FesaErrorLoadDomainStoreElements.c_str());
                }
                if (pFieldType->childList_.size() > 0)
                {
                    throw FesaException(__FILE__, __LINE__, FesaErrorLoadDomainStoreElements.c_str());
                }
                for (uint32_t j = 0; j < pFieldType->childList_.size(); j++)
                {
                    ElementXML* pField = pFieldType->childList_[j];

                    FieldElement* pFieldElement = new FieldElement(pField->name_);
                    pFieldElement->fromPersistency_ = false;
                    this->fillElement(pField, pFieldElement);

                    pDomainStoreElement->addFieldElement(pFieldElement);
                }
            }

            for (uint32_t i = 0; i < pElCol->size(); i++)
            {
                delete (*pElCol)[i];
            }
            delete pElCol;
        }
    }
    return pDomainStoreElementCol_;
}

int32_t InitializeDataStoreManager::getRollingManagerDepth()
{
    std::vector<ElementXML*>* pElCol;
    std::vector<ElementXML*>::iterator pElColIter;
    std::vector<AttributeXML*>::iterator AttrIter;

    std::string RollingMuxManagerXPath = CLASSES_TAG + "/" + className_ + "/" + MUX_ROLLING_TAG;
    pElCol = parser_->extractElementsFromXPath(RollingMuxManagerXPath);

    int32_t depth = -1;

    if (pElCol == NULL)
    {
        return ROLLING_DEFAULT_SIZE;
    }

    for (pElColIter = pElCol->begin(); pElColIter != pElCol->end(); pElColIter++)
    {
        for (AttrIter = (*pElColIter)->attributeList_.begin(); AttrIter != (*pElColIter)->attributeList_.end(); AttrIter++)
        {
            if ( (*AttrIter)->name_ == MUX_DEPTH_TAG )
            {
                depth = atoi((*AttrIter)->value_.c_str());
            }
        }
    }

    for (uint32_t i = 0; i < pElCol->size(); i++)
    {
        delete (*pElCol)[i];
    }
    delete pElCol;

    if (depth == -1)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorXMLElementNotFound.c_str(), MUX_ROLLING_TAG.c_str());
    }

    return depth;
}
} // fesa