ServiceLocatorUnsplitImplementation.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Core/ServiceLocatorUnsplitImplementation.h>

#include <fesa-core/Core/NotificationProducer.h>
#include <fesa-core/RealTime/AbstractRTDeviceClass.h>
#include <fesa-core/RealTime/AbstractRTEquipment.h>
#include <fesa-core/RealTime/AbstractEventSourceFactory.h>
#include <fesa-core/RealTime/AbstractEventSource.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/Exception/FesaException.h>
#include <fesa-core/Diagnostic/FesaLogger.h>
#include <fesa-core/Utilities/Lock.h>

namespace fesa
{

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

    }

    ServiceLocatorUnsplitImplementation::~ServiceLocatorUnsplitImplementation()
    {

    }

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

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

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

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

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

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

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

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

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

     void ServiceLocatorUnsplitImplementation::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 ServiceLocatorUnsplitImplementation::triggerPersistency() const
     {
         NotificationProducer::getInstance()->sendCommandMessage("PersistencyTrigger", className_, "");
     }

     AbstractDevice* ServiceLocatorUnsplitImplementation::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);
     }

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

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

}//end fesa namespace