ExtendedMultiplexingManager.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

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


namespace fesa
{

ExtendedMultiplexingManager::ExtendedMultiplexingManager(const std::string& name,
                                                         std::vector<std::string> extraCriterionCol, AbstractMultiplexingManager *baseMultiplexingManager) :
    AbstractMultiplexingManager(name, baseMultiplexingManager->getTimingDescriptor())
{
    extraCriterionCol_ = extraCriterionCol;
    baseMultiplexingManager_ = baseMultiplexingManager;
}

int32_t ExtendedMultiplexingManager::getDepth()
{
    // Add one for the default value, which is not included in extraCriterionCol
    return ((static_cast<int32_t>(extraCriterionCol_.size()) + 1) * baseMultiplexingManager_->getDepth());
}

int32_t ExtendedMultiplexingManager::getSlot(MultiplexingContext& context)
{
    int32_t slotOffset = getBlockOffset(context) * baseMultiplexingManager_->getDepth();
    return (slotOffset + baseMultiplexingManager_->getSlot(context));
}

int32_t ExtendedMultiplexingManager::requireSlot(MultiplexingContext& context)
{
    int32_t slotOffset = getBlockOffset(context) * baseMultiplexingManager_->getDepth();
    return (slotOffset * baseMultiplexingManager_->requireSlot(context));
}

int32_t ExtendedMultiplexingManager::getBlockOffset(MultiplexingContext& ctx)
{
    uint32_t i;
    bool found = false;
    if (ctx.getCycleStamp()) //From RT
    {
        for (i = 0; i < extraCriterionCol_.size(); i++)
        {
            if (ctx.match(extraCriterionCol_[i]))
            {
                found = true;
                break;
            }
        }
        // If extraCondition not found, the default one (which is store in the first place) is used.
        if (!found)
        {
            i = 0;
        }
    }
    else //From Server
    {
        std::string str = ctx.getExtraCondition();
        if (str == "") // empty string means the default value is requested
        {
            i = 0;
        }
        else
        {
            for (i = 0; i < extraCriterionCol_.size(); i++)
            {
                if (str == extraCriterionCol_[i])
                {
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                throw FesaException(__FILE__, __LINE__, FesaErrorNotValidExtraCondition.c_str());
            }
        }
    }
    return i + 1;
}

int32_t ExtendedMultiplexingManager::getLastSlot(const std::string& cycleName)
{
    throw FesaException(__FILE__, __LINE__, FesaErrorMethodNotSupportedByMultiplexingManager.c_str());
    return 0;
}

int32_t ExtendedMultiplexingManager::getLastSlot(const std::string& cycleName, const std::string& extraCriterion)
{
    uint32_t i;
    bool found = false;
    for (i = 0; i < extraCriterionCol_.size(); i++)
    {
        if (extraCriterion == extraCriterionCol_[i])
        {
            found = true;
            break;
        }
    }

    if (!found)//use default slot, if ExtraCrit. not found
    {
        i = 0;
    }

    uint32_t slotOffset = (i + 1) * baseMultiplexingManager_->getDepth();
    return (slotOffset + baseMultiplexingManager_->getLastSlot(cycleName));
}

int32_t ExtendedMultiplexingManager::requireSlot(const std::string& cycleName)
{
    throw FesaException(__FILE__, __LINE__, FesaErrorMethodNotSupportedByMultiplexingManager.c_str());
    return 0;
}

int32_t ExtendedMultiplexingManager::requireSlot(const std::string& cycleName, const std::string& extraCriterion)
{
    uint32_t i;
    bool found = false;
    for (i = 0; i < extraCriterionCol_.size(); i++)
    {
        if (extraCriterion == extraCriterionCol_[i])
        {
            found = true;
            break;
        }
    }

    if (!found)//use default slot, if ExtraCrit. not found
    {
        i = 0;
    }

    uint32_t slotOffset = (i + 1) * baseMultiplexingManager_->getDepth();
    return (slotOffset + baseMultiplexingManager_->requireSlot(cycleName));
}

int32_t ExtendedMultiplexingManager::getLastSlot(int32_t cycleId)
{
    throw FesaException(__FILE__, __LINE__, FesaErrorMethodNotSupportedByMultiplexingManager.c_str());
    return 0;
}

int32_t ExtendedMultiplexingManager::getLastSlot(int32_t cycleId, const std::string& extraCriterion)
{
    uint32_t i;
    bool found = false;
    for (i = 0; i < extraCriterionCol_.size(); i++)
    {
        if (extraCriterion == extraCriterionCol_[i])
        {
            found = true;
            break;
        }
    }

    if (!found)//use default slot, if ExtraCrit. not found
    {
        i = 0;
    }

    uint32_t slotOffset = (i + 1) * baseMultiplexingManager_->getDepth();
    return (slotOffset + baseMultiplexingManager_->getLastSlot(cycleId));
}

int32_t ExtendedMultiplexingManager::requireSlot(int32_t cycleId)
{
    throw FesaException(__FILE__, __LINE__, FesaErrorMethodNotSupportedByMultiplexingManager.c_str());
    return 0;
}

int32_t ExtendedMultiplexingManager::requireSlot(int32_t cycleId, const std::string& extraCriterion)
{
    uint32_t i;
    bool found = false;
    for (i = 0; i < extraCriterionCol_.size(); i++)
    {
        if (extraCriterion == extraCriterionCol_[i])
        {
            found = true;
            break;
        }
    }

    if (!found)//use default slot, if ExtraCrit. not found
    {
        i = 0;
    }

    uint32_t slotOffset = (i + 1) * baseMultiplexingManager_->getDepth();
    return (slotOffset + baseMultiplexingManager_->requireSlot(cycleId));
}

} // fesa