AbstractEventSourceFactory.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <fesa-core/RealTime/AbstractRealTimeLabObjectFactory.h>
#include <fesa-core/RealTime/TimerEventSource.h>
#include <fesa-core/RealTime/OnDemandEventSource.h>
#include <fesa-core/RealTime/OnDemandConsumerImpl.h>
#include <fesa-core/Diagnostic/FesaStream.h>
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Core/AbstractMsgQueue.h>
#include <fesa-core/Core/MsgQueueFactory.h>

#include <cmw-log/Logger.h>

#include <iostream>


namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.RealTime.AbstractEventSourceFactory");

}

namespace fesa
{

AbstractEventSourceFactory::EventSourceMap AbstractEventSourceFactory::eventSourceMap_;

AbstractEventSourceFactory::AbstractEventSourceFactory()
{

}

AbstractEventSourceFactory::~AbstractEventSourceFactory()
{
}

AbstractEventSource* AbstractEventSourceFactory::createEventSource(const std::string& className, const std::string& eventSourceName,const EventSourceType& type)
{
    if(eventSourceExists(className,eventSourceName))
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorEventSourceExists.c_str(), className.c_str(), eventSourceName.c_str());
    }

    AbstractEventSource* source;

    switch(type)
    {
        case TimingSource:
        {
            source = createTimingEventSource(eventSourceName);
            break;
        }
        case TimerSource:
        {
            source = createTimerEventSource(eventSourceName);
            break;
        }
        case OnDemandSource:
        {
            source = createOnDemandEventSource(className,eventSourceName);
            break;
        }
        case OnSubscriptionSource:
        {
            source = createOnSubscriptionEventSource(eventSourceName);
            break;
        }
        case CustomSource:
        {
            source = createCustomEventSource(eventSourceName);
            break;
        }
        default:
        {
            //This anyhow can never happen ... remove default-case?
            throw FesaException(__FILE__, __LINE__, FesaErrorAbstractEventSourceNotCreated.c_str(), eventSourceName.c_str());
        }
    }

    EventSourceKey key = generateKey(className,eventSourceName);
    eventSourceMap_.insert(std::make_pair(key,source));

    return source;
}

AbstractEventSource* AbstractEventSourceFactory::createTimingEventSource(const std::string& eventSourceName)
{
    if( eventSourceName != TIMING_EVENT_SOURCE_NAME )
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongEventSourceName.c_str(),eventSourceName.c_str(), TIMING_EVENT_SOURCE_NAME.c_str(), TIMING_EVENT_SOURCE_NAME.c_str());
    }

    if (AbstractEquipment::getInstance()->getTimingSimulationMode())
    {
        return labFactory_->createTimingSimulationEventSource(eventSourceName);
    }
    else
    {
        return labFactory_->createTimingEventSource(eventSourceName);
    }
}

AbstractEventSource* AbstractEventSourceFactory::createTimerEventSource(const std::string& eventSourceName)
{
    if(eventSourceName != TIMER_EVENT_SOURCE_NAME )
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongEventSourceName.c_str(),eventSourceName.c_str(), TIMER_EVENT_SOURCE_NAME.c_str(), TIMER_EVENT_SOURCE_NAME.c_str());
    }

    return new TimerEventSource();
}

AbstractEventSource* AbstractEventSourceFactory::createOnDemandEventSource(const std::string& className,const std::string& eventSourceName)
{
    int32_t size = AbstractEquipment::getInstance()->getProcessConfiguration()->getIntValue(PropertyTag::MSG_NUM_MAX);
    AbstractMsgQueue* queue = MsgQueueFactory::getOrCreateMsgQueue(className + eventSourceName, size, true);
    boost::shared_ptr<OnDemandConsumer> eventConsumer(new OnDemandConsumerImpl(queue));
    return new OnDemandEventSource(eventSourceName,eventConsumer);
}

void AbstractEventSourceFactory::deleteEventSources()
{
    EventSourceMap::iterator iter;
    for (iter = eventSourceMap_.begin(); iter != eventSourceMap_.end(); iter++)
    {
        delete iter->second;
    }
    eventSourceMap_.clear();
}

void AbstractEventSourceFactory::startEventSources()
{
    EventSourceMap::iterator eventSourceMapIter;
    for (eventSourceMapIter = eventSourceMap_.begin(); eventSourceMapIter != eventSourceMap_.end(); eventSourceMapIter++)
    {
        const std::string name = eventSourceMapIter->first.first;
        std::ostringstream stream;
        stream << "Starting event source: " << name << ", ClassName: " << eventSourceMapIter->first.second;
        LOG_DEBUG_IF(logger, stream.str());
        eventSourceMapIter->second->start(false, name);
    }
}

void AbstractEventSourceFactory::stopEventSources()
{
    EventSourceMap::iterator iter;
    for (iter = eventSourceMap_.begin(); iter != eventSourceMap_.end(); iter++)
    {
        std::ostringstream stream;
        stream << "Stopping event source: " << iter->first.first << " of class: " << iter->first.second;
        LOG_INFO_IF(logger, stream.str());
        iter->second->stop();
    }
}

AbstractEventSource* AbstractEventSourceFactory::getEventSource(const std::string& className, const std::string& eventSourceName)
{
    EventSourceKey key = generateKey(className,eventSourceName);
    EventSourceMap::iterator iter = eventSourceMap_.find(key);
    if(iter == eventSourceMap_.end())
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorEventSourceNotFound.c_str(), className.c_str(), eventSourceName.c_str());
    }
    return iter->second;
}

bool AbstractEventSourceFactory::eventSourceExists(const std::string& className, const std::string& eventSourceName)
{
    EventSourceKey key = generateKey(className,eventSourceName);
    EventSourceMap::iterator iter = eventSourceMap_.find(key);
    if(iter == eventSourceMap_.end())
    {
        return false;
    }
    return true;
}

AbstractEventSourceFactory::EventSourceKey AbstractEventSourceFactory::generateKey(const std::string& className, const std::string& eventSourceName)
{
    std::string fixedClassName = className;
    if(eventSourceName == TIMER_EVENT_SOURCE_NAME || eventSourceName == TIMING_EVENT_SOURCE_NAME || eventSourceName == ON_SUBSCRIPTION_EVENT_SOURCE_NAME )
    {
        //Timing,Timer and On-Subscription-Event-Source only exist once per equipment.
        //So the className does not matter for them and has to stay empty.
        fixedClassName = "";
    }
    return std::make_pair(fixedClassName,eventSourceName);
}

void AbstractEventSourceFactory::printConfigAll(FesaStream* fesaStream)
{
    EventSourceMap::iterator iter;
    *fesaStream << "\nEVENT-SOURCE-CONFIGS -------------------------------------------------------" << std::endl;
    for (iter = eventSourceMap_.begin(); iter != eventSourceMap_.end(); iter++)
    {
        iter->second->printConfig(fesaStream);
    }
}

void AbstractEventSourceFactory::printStateAll(FesaStream* fesaStream, double elapsedTime)
{
    EventSourceMap::iterator iter;
    *fesaStream << "\nEVENT-SOURCE-STATES -------------------------------------------------------" << std::endl;
    for (iter = eventSourceMap_.begin(); iter != eventSourceMap_.end(); iter++)
    {
        iter->second->printState(fesaStream, elapsedTime);
    }
}

} // fesa