RollingMultiplexingManager.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Synchronization/RollingMultiplexingManager.h>

#include <fesa-core/Synchronization/CycleDescriptor.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Exception/FesaException.h>

#include <sstream>


namespace fesa
{

RollingMultiplexingManager::RollingMultiplexingManager(std::string& name, CycleDescriptor* timingDescriptor,
                                                       RollingMultiplexingDataManager* dataManager) :
    AbstractMultiplexingManager(name, timingDescriptor), dataManager_(dataManager)
{
}

RollingMultiplexingManager::RollingMultiplexingManager(RollingMultiplexingDataManager* dataManager) :
    AbstractMultiplexingManager("ROLLING", NULL), dataManager_(dataManager)
{

}

int32_t RollingMultiplexingManager::getLastSlot(const std::string& cycleName)
{
    int32_t cycleId = timingDescriptor_->getCycleSelectorId(cycleName);
    int32_t slot = dataManager_->findCycleIdBackward(cycleId);

    // check if the slot contains the value of the virtual accelerator
    if (slot == -1)
    {
        std::ostringstream errorStringStream;
        errorStringStream << cycleId;
        throw FesaException(__FILE__, __LINE__, FesaErrorVAcceleratorSlotValueNotCorrect.c_str(), errorStringStream.str().c_str());
    }

    return slot;
}

int32_t RollingMultiplexingManager::getLastSlot(int32_t cycleId)
{

    int32_t slot = dataManager_->findCycleIdBackward(cycleId);

    // check if the slot contains the value of the virtual accelerator
    if (slot == -1)
    {
        std::ostringstream errorStringStream;
        errorStringStream << cycleId;
        throw FesaException(__FILE__, __LINE__, FesaErrorVAcceleratorSlotValueNotCorrect.c_str(), errorStringStream.str().c_str());
    }

    return slot;
}


int32_t RollingMultiplexingManager::getSlot(MultiplexingContext& context)
{
    int32_t slot = -1;

    if (context.getCycleStamp() != 0)
    {
        slot = dataManager_->findCycleStampBackward(context.getCycleStamp());
    }

    if (slot == -1)
    {
        int32_t cycleId = timingDescriptor_->getCycleSelectorId(context.getCycleName());
        slot = dataManager_->findCycleIdBackward(cycleId);
        if (slot != -1)
        {
            context.setCycleStamp(dataManager_->getCycleStamp(slot));
        }
    }

    // check if the slot contains the value of the virtual accelerator
    if (slot == -1)
    {
        // throw an exception
        throw FesaException(__FILE__, __LINE__, FesaErrorVAcceleratorSlotValueNotCorrect.c_str(),
                            context.getCycleName().c_str());
    }

    return slot;
}

int32_t RollingMultiplexingManager::requireSlot(const std::string& cycleName)
{
    throw FesaException(__FILE__, __LINE__, FesaErrorRollingManagerRequiresCycleStamp.c_str());
    return -1;

}


int32_t RollingMultiplexingManager::requireSlot(int32_t cycleId)
{
    throw FesaException(__FILE__, __LINE__, FesaErrorRollingManagerRequiresCycleStamp.c_str());
    return -1;

}

int32_t RollingMultiplexingManager::requireSlot(MultiplexingContext& context)
{
    if (context.getCycleStamp() == 0)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorWrongContext.c_str());
    }
    int32_t slot = dataManager_->findCycleStampBackward(context.getCycleStamp());

    if (slot == -1)
    {
        int32_t cycleId = timingDescriptor_->getCycleSelectorId(context.getCycleName());
        slot = dataManager_->nextPosition(context.getCycleStamp(), cycleId);
    }

    return slot;
}

} // fesa