StoreManager.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Persistency/StoreManager.h>

#include <fesa-core/Persistency/PersistencyUnit.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/DataStore/DomainStore.h>
#include <fesa-core/DataStore/AbstractDevice.h>
#include <fesa-core/DataStore/AbstractField.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Utilities/XMLParser.h>
#include <fesa-core/Exception/FesaException.h>


namespace fesa
{

const std::string StoreManager::GLOBAL_DEVICE_TAG = "global-instance";
const std::string StoreManager::DEVICE_INSTANCE_TAG = "device-instance";
const std::string StoreManager::DOMAIN_STORE_TAG = "domain-data";

StoreManager::StoreManager()
{
}

StoreManager::~StoreManager()
{
}

void StoreManager::restore(GlobalDevice& globalDevice, std::vector<AbstractDevice*>& deviceCol,
                           std::vector<DomainStore*>& domainStoreCol, const std::string& className)
{
    std::string persistencyFile = AbstractEquipment::getInstance()->getPersistencyFileName(className);
    XMLParser parser(persistencyFile, true);

    try
    {
        // Get the list of fields of the GlobalDevice
        GlobalDeviceElement* globalDeviceElement = retrieveGlobalDeviceElement(parser);

        globalDevice.restoreFromElement(*globalDeviceElement);
        delete globalDeviceElement;
    }
    catch (FesaException& ex)
    {
        throw FesaException(ex.getFileName(), ex.getLineNumber(), FesaErrorRestoringGlobalDevice.c_str());
    }

    std::vector<DeviceElement*>* pDeviceElementCol = retrieveDeviceElements(parser);

    try
    {
        for (uint32_t iDevEl = 0; iDevEl < pDeviceElementCol->size(); iDevEl++)
        {
            for (uint32_t iDev = 0; iDev < deviceCol.size(); iDev++)
            {
                if ((*pDeviceElementCol)[iDevEl]->getName() == deviceCol[iDev]->name.get())
                {

                    deviceCol[iDev]->restoreFromElement(*((*pDeviceElementCol)[iDevEl]));
                    delete (*pDeviceElementCol)[iDevEl];
                    break;
                }
            }
        }
        delete pDeviceElementCol;
    }
    catch (FesaException& ex)
    {
        throw FesaException(ex.getFileName(), ex.getLineNumber(), FesaErrorRestoringDevices.c_str());
    }

    std::vector<DomainStoreElement*>* pDomainStoreElementCol = retrieveDomainStoreElements(parser);

    try
    {
        if (pDomainStoreElementCol)
        {
            for (uint32_t iDomEl = 0; iDomEl < pDomainStoreElementCol->size(); iDomEl++)
            {
                for (uint32_t iDom = 0; iDom < domainStoreCol.size(); iDom++)
                {
                    if ((*pDomainStoreElementCol)[iDomEl]->getName() == domainStoreCol[iDom]->name.get())
                    {
                        const std::vector<AbstractField*>& pFieldCol = domainStoreCol[iDom]->getFieldCollection();
                        for (uint32_t fieldIdx = 0; fieldIdx < pFieldCol.size(); fieldIdx++)
                        {
                            if (pFieldCol[fieldIdx]->isPersistent())
                            {
                                FieldElement* fieldElement = (*pDomainStoreElementCol)[iDomEl]->getFieldElement(
                                    pFieldCol[fieldIdx]->getName());
                                if (fieldElement != NULL)
                                {
                                    pFieldCol[fieldIdx]->restore(*fieldElement);
                                }
                                else
                                {
                                    throw FesaException(__FILE__, __LINE__,
                                                        FesaErrorDataStoreElementRetrievingFieldElement.c_str(),
                                                        pFieldCol[fieldIdx]->getName().c_str());
                                }
                            }
                        }

                        break;
                    }
                    delete (*pDomainStoreElementCol)[iDomEl];
                }
                delete pDomainStoreElementCol;
            }
        }
    }
    catch (FesaException& ex)
    {
        throw FesaException(ex.getFileName(), ex.getLineNumber(), FesaErrorRestoringDomainStores.c_str());
    }
}

void StoreManager::store(PersistencyUnit& pu)
{
    // Store we use a tmp file and at the end we rename it
    std::string tmpFileName = pu.getPersistencyFileName() + ".tmp";
    {
        XMLParser parser(tmpFileName, false);

        parser.createFile();
        parser.startDocument();
        parser.startElement("persistency-unit");
        parser.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
        parser.writeAttribute("xsi:noNamespaceSchemaLocation", "");
        parser.writeAttribute("class", pu.getGlobalDevice().className.getAsString());
        parser.writeAttribute("version", pu.getGlobalDevice().version.getAsString());
        parser.writeNewline();
        parser.startElement("FEC-name");
        parser.writeAttribute("value", pu.getGlobalDevice().fecName.getAsString());
        parser.endElement();
        parser.writeNewline();

        // store the global device
        parser.startElement(GLOBAL_DEVICE_TAG);
        parser.writeAttribute("name", pu.getGlobalDevice().getName());
        parser.writeNewline();

        // retrieve all fields

        storeFields(parser, pu.getGlobalDevice().getPersistentFieldsCollection(), GLOBAL_DEVICE_TAG);

        parser.endElement();
        parser.writeNewline();

        // loop over all devices in vector
        for (std::vector<AbstractDevice*>::const_iterator dev = pu.getDeviceCollection().begin(); dev
                 != pu.getDeviceCollection().end(); dev++)
        {
            parser.writeNewline();
            parser.startElement(DEVICE_INSTANCE_TAG);
            parser.writeAttribute("name", (*dev)->getName());
            parser.writeNewline();

            // store settings
            storeFields(parser, (*dev)->getPersistentFieldsCollection(), DEVICE_INSTANCE_TAG);
            parser.endElement();
            parser.writeNewline();
        }

        // loop over all domains in vector
        for (std::vector<DomainStore*>::const_iterator domain = pu.getDomainStoreCollection().begin(); domain
                 != pu.getDomainStoreCollection().end(); domain++)
        {
            parser.writeNewline();
            parser.startElement(DOMAIN_STORE_TAG);
            parser.writeAttribute("name", (*domain)->getName());
            parser.writeNewline();
            // store fields
            storeFields(parser, (*domain)->getPersistentFieldsCollection(), DOMAIN_STORE_TAG);
            parser.endElement();
            parser.writeNewline();

        }
        parser.endElement();
        parser.endDocument();
    }
    //parser has been deleted, therefroe we can safely rename the temp file
    rename(tmpFileName.c_str(), pu.getPersistencyFileName().c_str());
}

void StoreManager::storeFields(XMLParser& parser, const std::vector<AbstractField*>& fields, std::string dataStore)
{
    std::string fieldName;
    std::string criterion;
    std::string fieldValue;
    std::string cycleName;
    std::string cycleId;

    FieldElement* fieldElement = new FieldElement("");

    for (std::vector<AbstractField*>::const_iterator itFields = fields.begin(); itFields != fields.end(); ++itFields)
    {

        if (!(*itFields)->isPersistent())
            continue;

        fieldName = (*itFields)->getName();

        /*
         * <amplitude>
         <cycle id="1" name="AD" 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"/>
         </cycle>
         <cycle id="2" name="NORMGPS" value="20">
         <extra-criterion name="PSB.PARTY.PROT" value="35"/>
         <extra-criterion name="PSB.DEST.DUMP" value="45"/>
         <extra-criterion name="PSB.DEST.PS" value="55"/>
         </cycle>

         </amplitude>
        */

        (*itFields)->store(*fieldElement);

        parser.startElement(fieldName);
        parser.writeNewline();

        // go through each cycle
        for (std::map<int32_t, std::string>::iterator cycle = fieldElement->cyclesNamesCol_.begin(); cycle
                 != fieldElement->cyclesNamesCol_.end(); cycle++)
        {

            cycleName = cycle->second;
            cycleId = StringUtilities::toString(cycle->first);

            parser.startElement("cycle");
            parser.writeAttribute("id", cycleId);
            parser.writeAttribute("name", cycleName);
            int32_t cycleIdTmp;
            Converter<int32_t>::stringToValue(cycleId, &cycleIdTmp);
            // retrieve the value
            std::map<int32_t, std::string>::iterator iterValue = fieldElement->fieldValuesCol_.find(cycleIdTmp);
            parser.writeAttribute("value", iterValue->second);

            parser.writeNewline();

            // go through each extra condition value
            std::map<std::string, std::string> extraConditions =
                fieldElement->fieldExtraValuesCol_.find(cycleIdTmp)->second;

            for (std::map<std::string, std::string>::iterator extraCondition = extraConditions.begin(); extraCondition
                     != extraConditions.end(); extraCondition++)
            {

                parser.startElement("extra-criterion");
                parser.writeAttribute("name", extraCondition->first);
                parser.writeAttribute("name", extraCondition->second);
                parser.endElement();
                parser.writeNewline();
            }

            // end cycle
            parser.endElement();
            parser.writeNewline();
        }

        // end fieldname
        parser.endElement();
        parser.writeNewline();

    }

    delete fieldElement;
}

GlobalDeviceElement* StoreManager::retrieveGlobalDeviceElement(XMLParser& parser)
{

    GlobalDeviceElement* globalDevice = NULL;

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

    std::map<int32_t, std::string> mapCycle;
    std::map<int32_t, std::string> mapExtraCondition;

    // restore global device

    pAttr = parser.extractAttribute(GLOBAL_DEVICE_TAG, "name");
    if (!pAttr)
    {
        return NULL;
    }

    globalDevice = new GlobalDeviceElement(pAttr->value_);

    pElCol = parser.extractElements(GLOBAL_DEVICE_TAG);

    if (!pElCol)
        return NULL;

    ElementXML* pGlobalEl = (*pElCol)[0];

    this->fillElements(pGlobalEl, globalDevice);

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

std::vector<DeviceElement*>* StoreManager::retrieveDeviceElements(XMLParser& parser)
{

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

    std::map<int32_t, std::string> mapCycle;
    std::vector<std::map<int32_t, std::string> > vMapsExtraCondition;
    std::vector<std::string> vNamesExtraCondition;

    std::vector<DeviceElement*>* pDeviceElementCol = new std::vector<DeviceElement*>();

    pElCol = parser.extractElements(DEVICE_INSTANCE_TAG);

    if (!pElCol)
        return NULL;

    //Loop over all device fields in vector pElCol
    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_ != "name")
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorLoadDeviceElements.c_str());
        }
        pAttr = pDeviceEl->attributeList_[0];

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

        this->fillElements(pDeviceEl, pDeviceElement);

    }

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

    return pDeviceElementCol;
}

std::vector<DomainStoreElement*>* StoreManager::retrieveDomainStoreElements(XMLParser& parser)
{

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

    std::vector<DomainStoreElement*>* pDomainStoreElementCol = new std::vector<DomainStoreElement*>();

    // since DomainStore is optional the extraction is done with mandatoryElement = false
    pElCol = parser.extractElements(DOMAIN_STORE_TAG);

    if (!pElCol)
    {
        return NULL;
    }

    //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_ != "name")
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorLoadDomainStoreElements.c_str());
        }

        DomainStoreElement* pDomainStoreElement = new DomainStoreElement(pAttr->value_);
        pDomainStoreElementCol->push_back(pDomainStoreElement);
        this->fillElements(pDomainEl, pDomainStoreElement);

    }

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

    return pDomainStoreElementCol;
}

void StoreManager::fillElements(ElementXML* dataStoreXML, DataStoreElement* dataStoreElement)
{

    AttributeXML* pAttr = NULL;
    int32_t cycleId = -1;
    std::string cycleName;
    std::string fieldValue;
    std::map<std::string, std::string> map;

    // format of each field
    /*
     * <amplitude>
     <cycle id="56" name="AD" 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"/>
     </cycle>
     <cycle id="22" name="NORMGPS" value="20">
     <extra-criterion name="PSB.PARTY.PROT" value="35"/>
     <extra-criterion name="PSB.DEST.DUMP" value="45"/>
     <extra-criterion name="PSB.DEST.PS" value="55"/>
     </cycle>

     </amplitude>
    */

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

        ElementXML* pField = dataStoreXML->childList_[i];
        FieldElement* pFieldElement = new FieldElement(pField->name_);

        pFieldElement->fromPersistency_ = true;

        // for each cycle
        for (uint32_t j = 0; j < pField->childList_.size(); j++)
        {

            ElementXML* pCycle = pField->childList_[j];

            fieldValue = "";
            for (uint32_t idx = 0; idx < pCycle->attributeList_.size(); idx++)
            {
                pAttr = pCycle->attributeList_[idx];
                if (pAttr->name_ == "id")
                {
                    Converter<int32_t>::stringToValue(pAttr->value_, &cycleId);
                }
                else if (pAttr->name_ == "name")
                {
                    cycleName = pAttr->value_;
                }
                else if (pAttr->name_ == "value")
                {
                    fieldValue = pAttr->value_;
                }

                else if (pAttr->name_.at(0) == 'b')
                {
                    fieldValue = fieldValue + " " + pAttr->name_ + "=\"" + pAttr->value_ + "\"";
                }
            }

            pFieldElement->cyclesNamesCol_.insert(make_pair(cycleId, cycleName));
            pFieldElement->fieldValuesCol_.insert(make_pair(cycleId, fieldValue));

            // for each extra condition
            for (uint32_t ext = 0; ext < pCycle->childList_.size(); ext++)
            {

                std::string extraConditionName = "";
                std::string extraConditionValue = "";

                ElementXML* pExtraCondition = pCycle->childList_[ext];
                if (pExtraCondition->attributeList_.size() == 0)
                {
                    throw FesaException(__FILE__, __LINE__, FesaErrorLoadGlobalDeviceElement.c_str());
                }

                for (uint32_t extIdx = 0; extIdx < pExtraCondition->attributeList_.size(); extIdx++)
                {
                    pAttr = pExtraCondition->attributeList_[extIdx];
                    if (pAttr->name_ == "name")
                    {
                        extraConditionName = pAttr->value_;
                    }
                    else if (pAttr->name_ == "value")
                    {
                        extraConditionValue = pAttr->value_;
                    }
                    // TODO change this according to the new format. Take a look at the initialization store manager
                    else if (pAttr->name_.at(0) == 'b')
                    {
                        extraConditionValue = extraConditionValue + " " + pAttr->name_ + "=\"" + pAttr->value_
                            + "\"";
                    }
                }
                if (extraConditionName == "" || extraConditionValue == "")
                {
                    throw FesaException(__FILE__, __LINE__, FesaErrorLoadGlobalDeviceElement.c_str());
                }

                map.insert(make_pair(extraConditionName, extraConditionValue));

            }

            pFieldElement->fieldExtraValuesCol_.insert(make_pair(cycleId, map));

        }
        dataStoreElement->addFieldElement(pFieldElement);

    }
}

} // fesa