DeviceElement2.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Utilities/ParserElements/DeviceElement2.h>
#include <fesa-core/Utilities/ParserElements/ClassElement.h>
#include <fesa-core/Utilities/ParserElements/ParserElementFactory.h>
#include <fesa-core/Utilities/ParserElements/DeviceLogicalEventElement.h>
#include <fesa-core/Utilities/ParserElements/ParserElementDefs.h>
#include <fesa-core/Exception/FesaExceptionDef.h>
#include <fesa-core/DataStore/AbstractDeviceFactory.h>
#include <fesa-core/Core/AbstractDeviceClass.h>
#include <fesa-core/DataStore/AbstractDevice.h>
#include <fesa-core/Utilities/XMLParser.h>

namespace fesa
{

DeviceElement2::DeviceElement2(boost::shared_ptr<ClassElement> parent,bool isGlobalDevice):
        parentClassElement_(parent), isInitialized_(false), isGlobalDevice_(isGlobalDevice)
{

}

DeviceElement2::DeviceElement2()
{

}

DeviceElement2::~DeviceElement2()
{

}

void DeviceElement2::initialize(const std::string& xpath, ElementXML *deviceElement,AbstractDeviceFactory* factory, ParserElementFactory& parserElementFactory)
{
        std::string deviceName = loadAttribute(xpath,deviceElement,DEVICE_ELEMENT_ATTRIBUTE_TAG);

        if(isGlobalDevice_)
        {
                deviceRef_ = (AbstractDevice*)factory->getGlobalDevice();
        }
        else
        {
                deviceRef_ = factory->getDevice(deviceName);
        }

        loadEventsMappingElement(xpath,deviceElement,parserElementFactory);
        isInitialized_ = true;
}

void DeviceElement2::loadEventsMappingElement(const std::string& xpath,ElementXML* deviceElement, ParserElementFactory& parserElementFactory)
{
        std::vector<ElementXML*>::iterator iter;
        for (iter=deviceElement->childList_.begin();iter!=deviceElement->childList_.end();++iter)
        {
                if((*iter)->name_ == EVENTS_MAPPING_ELEMENT_TAG)
                {
                        std::string xpathEventsMappingElement = xpath + "/" + EVENTS_MAPPING_ELEMENT_TAG;
                        loadLogicalEventElements(xpathEventsMappingElement,*iter,parserElementFactory);
                }
        }
}

void DeviceElement2::loadLogicalEventElements(const std::string& xpath,ElementXML* eventsMappingElement, ParserElementFactory& parserElementFactory)
{
        std::vector<ElementXML*>::iterator iter;
        for (iter=eventsMappingElement->childList_.begin();iter!=eventsMappingElement->childList_.end();++iter)
        {
                std::string xpathLogicalEventElement = xpath + "/" + (*iter)->name_;
                boost::shared_ptr<DeviceLogicalEventElement> temp = parserElementFactory.createDeviceLogicalEventElement();
                temp->initialize(xpathLogicalEventElement,*iter);
                logicalEventElementCol_.push_back(temp);
        }
}

void DeviceElement2::connectEventConfigRefs()
{
        if(!isInitialized_)
                throw FesaException(__FILE__, __LINE__, FesaErrorParserElementNotInitialized.c_str());

        std::vector<boost::shared_ptr<DeviceLogicalEventElement> >::iterator iter;
        for (iter=logicalEventElementCol_.begin();iter!=logicalEventElementCol_.end();++iter)
        {
                (*iter)->connectEventConfigRef(deviceRef_,parentClassElement_);
        }
}

std::string DeviceElement2::loadAttribute(const std::string& xpath, ElementXML* element,const std::string& attributeName)
{
    std::vector<AttributeXML*>::iterator attributeIter;
    for(attributeIter = element->attributeList_.begin();attributeIter != element->attributeList_.end();attributeIter++)
    {
        if((*attributeIter)->name_ == attributeName)
        {
                return (*attributeIter)->value_;
        }
    }

   //not found
   throw FesaException(__FILE__, __LINE__, FesaErrorXMLAttributeNotFound.c_str(),xpath.c_str(),attributeName.c_str());
}

AbstractDevice* DeviceElement2::getDeviceRef() const
{
        if(!isInitialized_)
                throw FesaException(__FILE__, __LINE__, FesaErrorParserElementNotInitialized.c_str());

        return deviceRef_;
}

}