AbstractRTDeviceClass.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/RealTime/AbstractRTDeviceClass.h>
#include <fesa-core/RealTime/AbstractRTEquipment.h>
#include <fesa-core/DataStore/FieldSynchroManager.h>
#include <fesa-core/DataStore/AbstractDevice.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/DataStore/AbstractDeviceFactory.h>
#include <fesa-core/Synchronization/NoneContext.h>
#include <fesa-core/Core/AbstractDeviceClass.h>

namespace fesa
{
    AbstractRTDeviceClass::AbstractRTDeviceClass(const std::string& name, const std::string& version) :
        AbstractDeviceClass(name, version)
    {
        // Register itself
        //TODO move this call out of the constructor, or at least use dependency injection
        AbstractRTEquipment::getInstance()->registerDeviceClass(this);
    }

    AbstractRTDeviceClass::AbstractRTDeviceClass() :
        AbstractDeviceClass("", "")
    {
        //This constructor is only used for Mocking
        //TODO fix first constructor
    }

    AbstractRTDeviceClass::~AbstractRTDeviceClass()
    {
        //TODO
        // clean all the collections rtLayerInfoCol_, rtActionInfoCol_, rtSchedulingInfoCol_
        // But it's an intricate problem:
        // But those collections can contain pointer on elements
        // which are managed by the base class(es) and more complex, in the context of
        // a complex inheritance tree a base class A can be extended by several classes and therefore
        // the class A should keep track of the object that point to it (kind of smart pointer)
        // For the time being only the collection are automatically deleted.
        // The resources allocated for the elements (just memory)
        // are freed by the OS when the program exit.


        try
        {
            AbstractRTEquipment::getInstance()->deregisterDeviceClass(name_);
        }
        // the class might have already been deleted
        catch (FesaException ex)
        {

        }
    }

    void AbstractRTDeviceClass::initialize()
    {
        // The user's init is now called
        specificInit();

        // Synchronize the setting fields
        FieldSynchroManager* pFieldSynchroManager = FieldSynchroManager::getInstance();
        pFieldSynchroManager->commitModifiedFieldSynchronization();

        AbstractDeviceFactory* pAbstractDeviceFactory = getDeviceFactory();
        const std::vector<AbstractDevice*>& abstractDevCol = pAbstractDeviceFactory->getAbstractDeviceCollection();
        for (uint32_t i = 0; i < abstractDevCol.size(); ++i)
        {
            abstractDevCol[i]->synchronizeSettingFields();
        }

        GlobalDevice* pGlobalDevice = pAbstractDeviceFactory->getGlobalDevice();
        if (pGlobalDevice != NULL)
        {
            pGlobalDevice->synchronizeSettingFields();
        }
    }

    void AbstractRTDeviceClass::addDiagnosticSchedulingUnitInfo(std::vector<RTSchedulingUnitInfo*>& schedulingUnitInfo)
    {
        //Attention!!!! Every developer who uses the same names will produce undefined behavior!!

        RTSchedulingUnitInfo* temp = new RTSchedulingUnitInfo();

        temp->name_ = DIAGNOSTIC_LAYER;
        temp->actionName_ = "RTDiagnosticSetting";
        temp->className_ = name_;
        temp->selectionCriterion_ = "";
        temp->eventName_ = "diagnosticEvent";
        temp->eventField_ = "diagnosticEvent";

        schedulingUnitInfo.push_back(temp);
    }

    void AbstractRTDeviceClass::addDiagnosticRTActionInfo(RTActionInfoCol& actionInfoCol)
    {
        //Attention!!!! Every developer who uses the same names will produce undefined behavior!!

        RTActionInfo* actionInfo = new RTActionInfo();
        actionInfo->className_ = name_;
        std::string s = "RTDiagnosticSetting";
        actionInfoCol.insert(std::make_pair(s, actionInfo));
    }

    void AbstractRTDeviceClass::addDiagnosticEvents(ElementXML* xmlElementClass)
    {
        //Attention!!!! Every developer who uses the same names will produce undefined behavior!!

        //add to events mapping
        ElementXML* eventsMapping =  getOrCreateXMLElement(xmlElementClass,"events-mapping");
        ElementXML* logicalEvent =  getOrCreateXMLElement(eventsMapping,"diagnosticEvent");
        ElementXML* eventConfiguration =  getOrCreateXMLElement(logicalEvent,"event-configuration");
        addXMLAttribute(eventConfiguration,"name","diag-event-configuration");
        ElementXML* eventSource =  getOrCreateXMLElement(eventConfiguration,"OnDemand");
        ElementXML* event =  getOrCreateXMLElement(eventSource,"on-demand-event-source-ref");
        addXMLAttribute(event,"name",DIAG_EVENT_SOURCE_NAME);

        //add to global device
        ElementXML* globalInstance =  getOrCreateXMLElement(xmlElementClass,"global-instance");
        ElementXML* globalInstanceEventsMapping =  getOrCreateXMLElement(globalInstance,"events-mapping");
        ElementXML* globalInstanceDiagEvent =  getOrCreateXMLElement(globalInstanceEventsMapping,"diagnosticEvent");
        ElementXML* globalInstanceDiagEventConfigRef =  getOrCreateXMLElement(globalInstanceDiagEvent,"event-configuration-ref");
        addXMLAttribute(globalInstanceDiagEventConfigRef,"name","diag-event-configuration");
    }

    ElementXML* AbstractRTDeviceClass::getOrCreateXMLElement(ElementXML* baseElement,std::string name)
    {
        std::vector<ElementXML*>::iterator iter;
        for (iter=baseElement->childList_.begin();iter!=baseElement->childList_.end();iter++)
        {
                if((*iter)->name_ == name)
                {
                        return *iter;
                }
        }

        //notfound
                ElementXML* element =  new ElementXML;
                element->name_ = name;
                baseElement->childList_.push_back(element);
                return element;
    }

    void AbstractRTDeviceClass::addXMLAttribute(ElementXML* baseElement,std::string name,std::string value)
    {
        AttributeXML* attr =  new AttributeXML;
        attr->name_ = name;
        attr->value_ = value;
                baseElement->attributeList_.push_back(attr);
    }
}