ServiceLocatorRealtimeSplitImplementation.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/RealTime/ServiceLocatorRealtimeSplitImplementation.h>

#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/RealTime/AbstractRTEquipment.h>
#include <fesa-core/RealTime/AbstractRTDeviceClass.h>
#include <fesa-core/RealTime/AbstractEventSourceFactory.h>
#include <fesa-core/RealTime/AbstractEventSource.h>
#include <fesa-core/Server/AbstractServerEquipment.h>
#include <fesa-core/Core/NotificationProducer.h>
#include <fesa-core/DataStore/GlobalDevice.h>

namespace fesa
{

    ServiceLocatorRealtimeSplitImplementation::ServiceLocatorRealtimeSplitImplementation(const std::string& className) :
                    AbstractServiceLocatorImplementation(className)
    {

    }

    ServiceLocatorRealtimeSplitImplementation::~ServiceLocatorRealtimeSplitImplementation()
    {

    }

    void ServiceLocatorRealtimeSplitImplementation::runClassSpecificInitRT() const
    {
        AbstractRTDeviceClass* pRTDeviceClass = AbstractRTEquipment::getInstance()->getRTDeviceClass(className_);
        if (pRTDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "runClassSpecificInitRT");
        }
        pRTDeviceClass->specificInit();
    }

    void ServiceLocatorRealtimeSplitImplementation::runClassSpecificInitServer() const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "classSpecificInitServer",
                        "Realtime");
    }

    void ServiceLocatorRealtimeSplitImplementation::runDeployUnitSpecificInitRT() const
    {
        AbstractRTEquipment::getInstance()->specificInit();
    }

    void ServiceLocatorRealtimeSplitImplementation::runDeployUnitSpecificInitServer() const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "deployUnitSpecificInitServer",
                        "Realtime");
    }

    void ServiceLocatorRealtimeSplitImplementation::enableEventSource(const std::string& eventSourceName) const
    {
                 AbstractEventSource* pEventSource = AbstractEventSourceFactory::getEventSource(className_,eventSourceName);
                 pEventSource->enable();
    }

    void ServiceLocatorRealtimeSplitImplementation::disableEventSource(const std::string& eventSourceName) const
    {
                 AbstractEventSource* pEventSource = AbstractEventSourceFactory::getEventSource(className_,eventSourceName);
                 pEventSource->disable();
    }

    void ServiceLocatorRealtimeSplitImplementation::enableRTEvent(const std::string& logicalEventName,const std::string& eventSourceName) const
    {
                 AbstractEventSource* pEventSource = AbstractEventSourceFactory::getEventSource(className_,eventSourceName);
                 pEventSource->enableEvent(logicalEventName);
    }

    void ServiceLocatorRealtimeSplitImplementation::disableRTEvent(const std::string& logicalEventName,const std::string& eventSourceName) const
    {
                 AbstractEventSource* pEventSource = AbstractEventSourceFactory::getEventSource(className_,eventSourceName);
                 pEventSource->disableEvent(logicalEventName);
    }

    bool ServiceLocatorRealtimeSplitImplementation::isEventEnabled(const std::string& logicalEventName,const std::string& eventSourceName) const
    {
                AbstractEventSource* pEventSource = AbstractEventSourceFactory::getEventSource(className_,eventSourceName);
        return pEventSource->isEventEnabled(logicalEventName);
    }

    void ServiceLocatorRealtimeSplitImplementation::synchronizeSettingFields(const MultiplexingContext& context) const
    {
        AbstractRTDeviceClass* pRTDeviceClass = AbstractRTEquipment::getInstance()->getRTDeviceClass(className_);
        if (pRTDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "synchronizeSettingFields");
        }
        GlobalDevice* pGlobalDevice = pRTDeviceClass->getDeviceFactory()->getGlobalDevice();
        std::vector<AbstractDevice*> deviceCollection =
                        pRTDeviceClass->getDeviceFactory()->getAbstractDeviceCollection();

        // TODO : To remove the const_cast as soon as the FWK deals properly with const parameters using const methods
        pGlobalDevice->synchronizeSettingFields(const_cast<MultiplexingContext&>(context));
        for (std::vector<AbstractDevice*>::iterator device = deviceCollection.begin(); device != deviceCollection.end();
                        device++)
        {
            // TODO : To remove the const_cast as soon as the FWK deals properly with const parameters using const methods
            (*device)->synchronizeSettingFields(const_cast<MultiplexingContext&>(context));
        }
    }

    void ServiceLocatorRealtimeSplitImplementation::triggerPersistency() const
    {
        NotificationProducer::getInstance()->sendCommandMessage("PersistencyTrigger", className_, "");
    }

    AbstractDevice* ServiceLocatorRealtimeSplitImplementation::getDevice(const std::string& deviceName) const
    {
        AbstractRTDeviceClass* pRTDeviceClass = AbstractRTEquipment::getInstance()->getRTDeviceClass(className_);
        if (pRTDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "getDevice");
        }
        AbstractDevice* pDevice = pRTDeviceClass->getDeviceFactory()->getDevice(deviceName);
        if (pDevice == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "getDevice");
        }
        return (pDevice);
    }

    AbstractDevice* ServiceLocatorRealtimeSplitImplementation::getGlobalDevice() const
    {
        AbstractRTDeviceClass* pRTDeviceClass = AbstractRTEquipment::getInstance()->getRTDeviceClass(className_);
        if (pRTDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "getDeviceCollection");
        }
        return (pRTDeviceClass->getDeviceFactory()->getGlobalDevice());
    }

    const std::vector<AbstractDevice*>& ServiceLocatorRealtimeSplitImplementation::getDeviceCollection() const
    {
        AbstractRTDeviceClass* pRTDeviceClass = AbstractRTEquipment::getInstance()->getRTDeviceClass(className_);
        if (pRTDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "getDeviceCollection");
        }
        return (pRTDeviceClass->getDeviceFactory()->getAbstractDeviceCollection());
    }

} //end namespace