ServiceLocatorServerSplitImplementation.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Server/ServiceLocatorServerSplitImplementation.h>

#include <fesa-core/Server/AbstractServerDeviceClass.h>
#include <fesa-core/Server/AbstractServerEquipment.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/DataStore/AbstractDeviceFactory.h>
#include <fesa-core/Core/NotificationProducer.h>
#include <fesa-core/Exception/FesaException.h>

namespace fesa
{


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

    }

    ServiceLocatorServerSplitImplementation::~ServiceLocatorServerSplitImplementation()
    {

    }

    void ServiceLocatorServerSplitImplementation::runClassSpecificInitRT() const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "classSpecificInitRT",
                        "Server");
    }

    void ServiceLocatorServerSplitImplementation::runClassSpecificInitServer() const
    {
        AbstractServerDeviceClass* pServerDeviceClass = AbstractServerEquipment::getInstance()->getServerDeviceClass(
                        className_);
        if (pServerDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "runClassSpecificInitServer");
        }
        pServerDeviceClass->specificInit();
    }

    void ServiceLocatorServerSplitImplementation::runDeployUnitSpecificInitRT() const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "deployUnitSpecificInitRT",
                        "Server");
    }

    void ServiceLocatorServerSplitImplementation::runDeployUnitSpecificInitServer() const
    {
        AbstractServerEquipment::getInstance()->specificInit();
    }

    void ServiceLocatorServerSplitImplementation::enableEventSource(const std::string& eventSourceName) const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "enableEventSource", "Server");
    }

    void ServiceLocatorServerSplitImplementation::disableEventSource(const std::string& eventSourceName) const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "disableEventSource",
                        "Server");
    }

    void ServiceLocatorServerSplitImplementation::enableRTEvent(const std::string& eventName,const std::string& eventSourceName) const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "enableRTEvent", "Server");
    }

    void ServiceLocatorServerSplitImplementation::disableRTEvent(const std::string& eventName,const std::string& eventSourceName) const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "disableRTEvent", "Server");
    }

    bool ServiceLocatorServerSplitImplementation::isEventEnabled(const std::string& eventName,const std::string& eventSourceName) const
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "isEventEnable", "Server");
        return false;
    }

    void ServiceLocatorServerSplitImplementation::synchronizeSettingFields(const MultiplexingContext& context) const
    {
        AbstractServerDeviceClass* pServerDeviceClass = AbstractServerEquipment::getInstance()->getServerDeviceClass(
                        className_);
        if (pServerDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "synchronizeSettingFields");
        }
        GlobalDevice* pGlobalDevice = pServerDeviceClass->getDeviceFactory()->getGlobalDevice();
        std::vector<AbstractDevice*> deviceCollection = AbstractServerEquipment::getInstance()->getServerDeviceClass(
                        className_)->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 ServiceLocatorServerSplitImplementation::triggerPersistency() const
    {
    NotificationProducer::getInstance()->sendCommandMessage("PersistencyTrigger", className_, "");
    }

    AbstractDevice* ServiceLocatorServerSplitImplementation::getDevice(const std::string& deviceName) const
    {
        AbstractServerDeviceClass* pServerDeviceClass = AbstractServerEquipment::getInstance()->getServerDeviceClass(
                        className_);
        if (pServerDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "getDevice");
        }
        AbstractDevice* pDevice = pServerDeviceClass->getDeviceFactory()->getDevice(deviceName);
        if (pDevice == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(), "getDevice");
        }
        return (pDevice);
    }

    AbstractDevice* ServiceLocatorServerSplitImplementation::getGlobalDevice() const
    {
        AbstractServerDeviceClass* pServerDeviceClass = AbstractServerEquipment::getInstance()->getServerDeviceClass(
                        className_);
        if (pServerDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "getDeviceCollection");
        }
        return (pServerDeviceClass->getDeviceFactory()->getGlobalDevice());
    }

    const std::vector<AbstractDevice*>& ServiceLocatorServerSplitImplementation::getDeviceCollection() const
    {
        AbstractServerDeviceClass* pServerDeviceClass = AbstractServerEquipment::getInstance()->getServerDeviceClass(
                        className_);
        if (pServerDeviceClass == NULL)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorServiceLocatorServiceNotAvailable.c_str(),
                            "getDeviceCollection");
        }
        return (pServerDeviceClass->getDeviceFactory()->getAbstractDeviceCollection());
    }

} //end namespace