CycleDescriptor.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <fesa-core/Utilities/Lock.h>
#include <fesa-core/Exception/FesaException.h>

#include <sstream>


namespace fesa
{

CycleDescriptor::CycleDescriptor(const std::string& timingDomain, const std::string& multiplexingCriterion) :
    timingDomain_(timingDomain), timingCriterion_(multiplexingCriterion)
{
    name_ = timingDomain + "." + multiplexingCriterion;
}

CycleDescriptor::~CycleDescriptor()
{

}

int32_t CycleDescriptor::getCycleSelectorId(const std::string& cycleSelectorName)
{
    std::map<std::string, int32_t>::iterator iter;

    Lock lock(cycleSelectorColMutex_);
    iter = cycleSelectorCol_.find(cycleSelectorName);

    if (iter == cycleSelectorCol_.end())
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorCycleSelectorNameNotFound.c_str(),cycleSelectorName.c_str());
    }
    else
    {
        return (*iter).second;
    }
}

const std::string CycleDescriptor::getCycleSelectorName(int32_t cycleSelectorID)
{
    std::map<std::string, int32_t>::const_iterator iter;
    Lock lock(cycleSelectorColMutex_);
    for (iter = cycleSelectorCol_.begin(); iter != cycleSelectorCol_.end(); iter++)
    {
        if ((*iter).second == cycleSelectorID)
        {
            return (*iter).first;
        }
    }
    std::stringstream buf;
    buf << cycleSelectorID;
    throw FesaException(__FILE__, __LINE__, FesaErrorCycleSelectorIDNotFound.c_str(), buf.str().c_str());
}

bool CycleDescriptor::isValidCycleSelector(const std::string& cycleSelectorName)
{
    std::map<std::string, int32_t>::iterator iter;

    Lock lock(cycleSelectorColMutex_);
    iter = cycleSelectorCol_.find(cycleSelectorName);

    if (iter == cycleSelectorCol_.end())
    {
        return false;
    }
    else
    {
        return true;
    }
}

void CycleDescriptor::addSelector(const std::string& cycleSelectorName)
{
    if(isValidCycleSelector(cycleSelectorName))
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorDublicateSelectionCriterion.c_str(),cycleSelectorName.c_str());
    }

    //we start with 0, not with 1
    int32_t newID = static_cast<int32_t>(cycleIdsCol_.size());
    cycleIdsCol_.push_back(newID);
    Lock lock(cycleSelectorColMutex_);
    {
        cycleSelectorCol_.insert(std::make_pair(cycleSelectorName, newID));
    }
}

void CycleDescriptor::renameSelector(const std::string& oldCycleSelectorName,const std::string& newCycleSelectorName)
{
    Lock lock(cycleSelectorColMutex_);
    std::map<std::string, int32_t>::iterator iter = cycleSelectorCol_.find(oldCycleSelectorName);
    if (iter == cycleSelectorCol_.end())
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorCycleSelectorNameNotFound.c_str(),oldCycleSelectorName.c_str());
    }
    int32_t id  = iter->second;
    cycleSelectorCol_.erase(iter);
    cycleSelectorCol_.insert(std::make_pair(newCycleSelectorName, id));
}

const std::string& CycleDescriptor::getTimingDomain()
{
    return timingDomain_;
}

const std::string& CycleDescriptor::getTimingCriterion()
{
    return timingCriterion_;
}

const std::string& CycleDescriptor::getName()
{
    return name_;
}

const std::vector<int32_t>& CycleDescriptor::getCycleIdsCol()
{
    return cycleIdsCol_;
}

const std::map<std::string, int32_t>& CycleDescriptor::getCycleSelectorCol()
{
    return cycleSelectorCol_;
}

} // fesa