AbstractServiceLocator.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Core/AbstractServiceLocator.h>
#include <fesa-core/Core/AbstractServiceLocatorImplementation.h>

namespace fesa
{

    AbstractServiceLocator::AbstractServiceLocator(AbstractServiceLocatorImplementation* abstractImplementation) : pImplementation_(abstractImplementation)
    {

    }

    AbstractServiceLocator::~AbstractServiceLocator()
    {
        delete pImplementation_;
    }

    void AbstractServiceLocator::runClassSpecificInitRT() const
    {
        pImplementation_->runClassSpecificInitRT();
    }

    void AbstractServiceLocator::runClassSpecificInitServer() const
    {
        pImplementation_->runClassSpecificInitServer();
    }

    void AbstractServiceLocator::runDeployUnitSpecificInitRT() const
    {
        pImplementation_->runDeployUnitSpecificInitRT();
    }

    void AbstractServiceLocator::runDeployUnitSpecificInitServer() const
    {
        pImplementation_->runDeployUnitSpecificInitServer();
    }

    void AbstractServiceLocator::enableEventSource(const std::string& eventSourceName) const
    {
        pImplementation_->enableEventSource(eventSourceName);
    }

    void AbstractServiceLocator::disableEventSource(const std::string& eventSourceName) const
    {
        pImplementation_->disableEventSource(eventSourceName);
    }

    void AbstractServiceLocator::enableRTEvent(const std::string& logicalEventName, const std::string& eventSourceName) const
    {
        pImplementation_->enableRTEvent(logicalEventName, eventSourceName);
    }

    void AbstractServiceLocator::disableRTEvent(const std::string& logicalEventName, const std::string& eventSourceName) const
    {
        pImplementation_->disableRTEvent(logicalEventName, eventSourceName);
    }

    bool AbstractServiceLocator::isEventEnabled(const std::string& logicalEventName, const std::string& eventSourceName) const
    {
        return pImplementation_->isEventEnabled(logicalEventName, eventSourceName);
    }

    void AbstractServiceLocator::synchronizeSettingFields(const MultiplexingContext& context) const
    {
        pImplementation_->synchronizeSettingFields(context);
    }

    void AbstractServiceLocator::triggerPersistency() const
    {
        pImplementation_->triggerPersistency();
    }

     const std::vector<AbstractDevice*>& AbstractServiceLocator::getDeviceCollection() const
     {
         return (pImplementation_->getDeviceCollection());
     }

     AbstractDevice* AbstractServiceLocator::getDevice(const std::string& deviceName) const
     {
         return (pImplementation_->getDevice(deviceName));
     }

     AbstractDevice* AbstractServiceLocator::getGlobalDevice() const
     {
         return (pImplementation_->getGlobalDevice());
     }

}// fesa