SynchronizationLabObjectFactory.cpp

Go to the documentation of this file.

//Copyright GSI 2012
#include <sstream>
#include <fesa-core/Synchronization/SynchronizationLabObjectFactory.h>
#include <fesa-core-gsi/Exception/GSIException.h>

#include <fesa-core-gsi/Synchronization/GSICycleDescriptor.h>
#include <fesa-core-gsi/Synchronization/GSISimulatedCycleDescriptor.h>

#include <fesa-core-gsi/Synchronization/TimingContext.h>
#include <fesa-core-gsi/Synchronization/TimingSimulationContext.h>

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

namespace fesa
{

SynchronizationLabObjectFactory* SynchronizationLabObjectFactory::instance_ = NULL;

SynchronizationLabObjectFactory::SynchronizationLabObjectFactory()
{

}
SynchronizationLabObjectFactory::~SynchronizationLabObjectFactory()
{

}

SynchronizationLabObjectFactory* SynchronizationLabObjectFactory::getInstance()
{

    if (instance_ == NULL)
        instance_ = new fesa::SynchronizationLabObjectFactory();
    return instance_;

}

CycleDescriptor* SynchronizationLabObjectFactory::createOrGetEventCycleDescriptor(const std::string& timingDomain, const std::string& timingCriterion)
{
    return createCycleDescriptor(timingDomain, timingCriterion);
}

CycleDescriptor* SynchronizationLabObjectFactory::createCycleDescriptorLab(const std::string& timingDomain,
                                                                           const std::string& timingCriterion) // Possible name formats: PSB.USER(timingDescriptorName) or PSB.USER.AD (cycleSelector)
{
    const fesa::ProcessConfiguration* configuration =  AbstractEquipment::getInstance()->getProcessConfiguration();
    if(configuration->isDefined(fesa::PropertyTag::TIMING_SIMULATION))
    {
        const std::string file = configuration->getStringValue(fesa::PropertyTag::TIMING_SIMULATION);
        return new fesaGSI::GSISimulatedCycleDescriptor(timingDomain, timingCriterion, file);
    }
    return new fesaGSI::GSICycleDescriptor(timingDomain, timingCriterion);
}

void fesa::SynchronizationLabObjectFactory::releaseInstance()
{
    if (instance_ != NULL)
    {
        delete instance_;
        instance_ = NULL;
    }
}

MultiplexingContext* SynchronizationLabObjectFactory::createTimingContext(long long cycleStamp,  const std::string& cycleName)
{
    return (new fesaGSI::TimingContext(cycleStamp, cycleName));
}

} // fesa