ClassElement.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI
#include <fesa-core/Utilities/ParserElements/ClassElement.h>
#include <fesa-core/Utilities/ParserElements/ParserElementFactory.h>
#include <fesa-core/Utilities/ParserElements/EventConfigurationElement.h>
#include <fesa-core/Utilities/ParserElements/LogicalEventElement.h>
#include <fesa-core/Utilities/ParserElements/DeviceElement2.h>
#include <fesa-core/Utilities/ParserElements/EventElement.h>
#include <fesa-core/Utilities/ParserElements/ParserElementDefs.h>
#include <fesa-core/Exception/FesaExceptionDef.h>
#include <fesa-core/Core/AbstractDeviceClass.h>
#include <fesa-core/Utilities/XMLParser.h>

namespace fesa
{

ClassElement::ClassElement(AbstractDeviceClass* classRef):
        classRef_(classRef), isInitialized_(false), eventConfigRefsConnected_(false)
{

}

ClassElement::ClassElement()
{

}

ClassElement::~ClassElement()
{

}

void ClassElement::initialize(const std::string& xpath, ElementXML *classElement, ParserElementFactory& parserElementFactory)
{
    if(classElement == NULL)
    {
        //usually we should not need to check this .. however since the impl. of FesaXMLParser is bad and can return NULL-pointers, we better do so
        //TODO: remove NULL-check, when impl. if FesaXMLParser got refactored
        throw FesaException(__FILE__, __LINE__, FesaErrorXMLElementNotFound.c_str(),xpath.c_str());
    }
    loadEventsMappingElement(xpath,classElement,parserElementFactory);
        loadDeviceElements(xpath,classElement,parserElementFactory);

        isInitialized_ = true;

        connectEventConfigRefs();
        fillActiveEventMap();

        eventConfigRefsConnected_ = true;
}

void ClassElement::connectEventConfigRefs()
{
        std::vector<boost::shared_ptr<DeviceElement2> >::iterator iter;
        for(iter=deviceElementCol_.begin();iter!=deviceElementCol_.end();++iter)
        {
                (*iter)->connectEventConfigRefs();
        }
}

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

void ClassElement::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 xpathName = xpath + "/" + (*iter)->name_;
                boost::shared_ptr<LogicalEventElement> temp = parserElementFactory.createLogicalEventElement(shared_from_this());
                temp->initialize(xpathName,*iter,parserElementFactory);
                logicalEventElementCol_.push_back(temp);
        }
}

void ClassElement::loadDeviceElements(const std::string& xpath,ElementXML* classElement, ParserElementFactory& parserElementFactory)
{
        std::vector<ElementXML*>::iterator iter;
        for (iter=classElement->childList_.begin();iter!=classElement->childList_.end();++iter)
        {
                if((*iter)->name_ == DEVICE_ELEMENT_TAG)
                {
                        std::string xpathDeviceElement = xpath + "/" + DEVICE_ELEMENT_TAG;
                        boost::shared_ptr<DeviceElement2> temp = parserElementFactory.createDeviceElement2(shared_from_this(),false);
                        temp->initialize(xpathDeviceElement,*iter,classRef_->getDeviceFactory(),parserElementFactory);
                        deviceElementCol_.push_back(temp);
                }
                if((*iter)->name_ == GLOBAL_DEVICE_ELEMENT_TAG)
                {
                        std::string xpathGlobalElement = xpath + "/" + GLOBAL_DEVICE_ELEMENT_TAG;
                        boost::shared_ptr<DeviceElement2> temp = parserElementFactory.createDeviceElement2(shared_from_this(),true);
                        temp->initialize(xpathGlobalElement,*iter,classRef_->getDeviceFactory(),parserElementFactory);
                        deviceElementCol_.push_back(temp);
                }
        }
}

boost::shared_ptr<EventConfigurationElement> ClassElement::getEventConfigurationElementRef(const std::string& logicalEventName,const std::string& eventConfigurationName) const
{
        if(!isInitialized_)
                throw FesaException(__FILE__, __LINE__, FesaErrorParserElementNotInitialized.c_str());

        std::vector<boost::shared_ptr<LogicalEventElement> >::const_iterator iter;
        for(iter=logicalEventElementCol_.begin();iter!=logicalEventElementCol_.end();++iter)
        {
                if((*iter)->getName() == logicalEventName)
                {
                        return (*iter)->getEventConfigurationElementRef(eventConfigurationName);
                }
        }

        //not found
        throw FesaException(__FILE__, __LINE__, FesaErrorTimingMappingNotConform.c_str(),logicalEventName.c_str());
}

const std::vector<boost::shared_ptr<LogicalEventElement> >& ClassElement::getLogicalElementCol() const
{
        if(!eventConfigRefsConnected_)
                throw FesaException(__FILE__, __LINE__, FesaErrorParserElementNotInitialized.c_str());

        return logicalEventElementCol_;
}

AbstractDeviceClass* ClassElement::getClassRef() const
{
        return classRef_;
}

const std::string& ClassElement::getClassName() const
{
        return classRef_->getName();
}

void ClassElement::fillActiveEventMap()
{
        std::vector<boost::shared_ptr<LogicalEventElement> >::iterator logicalEventIter;
        for(logicalEventIter=logicalEventElementCol_.begin();logicalEventIter!=logicalEventElementCol_.end();logicalEventIter++)
        {
                activeEventMap_.insert(make_pair((*logicalEventIter)->getName(),(*logicalEventIter)->getActiveEventElements()));
        }
}

const EventMap& ClassElement::getActiveEventMap() const
{
        if(!eventConfigRefsConnected_)
                throw FesaException(__FILE__, __LINE__, FesaErrorParserElementNotInitialized.c_str());

        return activeEventMap_;
}

std::vector< EventElementPointer > ClassElement::getActiveEvents(const std::string& logicalEventName) const
{
        if(!eventConfigRefsConnected_)
                throw FesaException(__FILE__, __LINE__, FesaErrorParserElementNotInitialized.c_str());

        std::vector<boost::shared_ptr<LogicalEventElement> >::const_iterator logicalEventIter;
        for(logicalEventIter=logicalEventElementCol_.begin();logicalEventIter!=logicalEventElementCol_.end();logicalEventIter++)
        {
                if((*logicalEventIter)->getName() == logicalEventName )
                        return (*logicalEventIter)->getActiveEventElements();
        }

        //not found
        throw FesaException(__FILE__, __LINE__, FesaErrorLogicalEventNotFound.c_str(),logicalEventName.c_str());
}

}