TimingSimulationStructures.cpp

Go to the documentation of this file.

//Copyright GSI 2012
#include <fesa-core/Utilities/StringUtilities.h>
#include <fesa-core-gsi/Exception/GSIException.h>
#include <fesa-core-gsi/RealTime/TimingSimulationStructures.h>

namespace fesaGSI
{
        EventConfig::EventConfig(fesa::ElementXML* config)
        {
        type_ = Event;

        if(config->attributeList_.size() < 2)//payload is a "may"
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }

                std::vector<fesa::AttributeXML*>::iterator attributeIter;
                for(attributeIter = config->attributeList_.begin();attributeIter != config->attributeList_.end();attributeIter++)
                {
                        if((*attributeIter)->name_ == "eventname")
                        {
                                eventName_ =  (*attributeIter)->value_;
                        }
                        else if((*attributeIter)->name_ == "delay")
                        {
                                fesa::StringUtilities::fromString(delay_, (*attributeIter)->value_);
                        }
                        else if((*attributeIter)->name_ == "payload")
                        {
                                payload_ =  (*attributeIter)->value_;
                        }
                        else
                        {
                                //dont throw error, since TimingSimulationEventBurstElement inherits from us
                        }
                }
        }

        EventBurstConfig::EventBurstConfig(fesa::ElementXML* config) : EventConfig(config)
    {
        type_ = EventBurst;
        if(config->attributeList_.size() < 5)
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }

                std::vector<fesa::AttributeXML*>::iterator attributeIter;
                for(attributeIter = config->attributeList_.begin();attributeIter != config->attributeList_.end();attributeIter++)
                {
                        if((*attributeIter)->name_ == "period")
                        {
                                fesa::StringUtilities::fromString(period_, (*attributeIter)->value_);
                                if(period_ <= 0)
                                        throw GSIException(__FILE__,__LINE__,FESAGSIErrorWrongEventPeriod.c_str());
                        }
                        else if((*attributeIter)->name_ == "occurrences")
                        {
                                fesa::StringUtilities::fromString(occurrences_, (*attributeIter)->value_);
                                if(occurrences_ <= 0)
                                        throw GSIException(__FILE__,__LINE__,FESAGSIErrorWrongEventOcurrences.c_str());
                        }
                        else
                        {
                                //dont throw error ... the baseclass attributes
                        }
                }
    }

    EventSequenceConfig::EventSequenceConfig(fesa::ElementXML* config)
    {
        if(config->attributeList_.size() < 1)
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }

                std::vector<fesa::AttributeXML*>::iterator attributeIter;
                for(attributeIter = config->attributeList_.begin();attributeIter != config->attributeList_.end();attributeIter++)
                {
                        if((*attributeIter)->name_ == "name")
                        {
                                name_ =(*attributeIter)->value_;
                        }
                        else
                        {
                                throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                        }
                }

                std::vector<fesa::ElementXML*>::iterator childIter;
        for(childIter = config->childList_.begin();childIter != config->childList_.end();childIter++)
        {
                EventConfig *temp;
                if((*childIter)->name_ == "event")
                {
                        temp = new EventConfig(*childIter);
                        events_.push_back(temp);
                }
                else if((*childIter)->name_ == "event-burst")
                {
                        temp = new EventBurstConfig(*childIter);
                        events_.push_back(temp);
                }
                else
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }
        }
    }

    EventSequenceConfig::~EventSequenceConfig()
    {
        std::vector<EventConfig*>::iterator iter;
        for(iter= events_.begin();iter!=events_.end();iter++)
        {
                delete *iter;
        }
    }

    TelegramDataConfig::TelegramDataConfig(fesa::ElementXML* config)
    {
        //the defaults
        destination_ = spCon_ = "";
        particleType_ = -1;

                std::vector<fesa::AttributeXML*>::iterator attributeIter;
                for(attributeIter = config->attributeList_.begin();attributeIter != config->attributeList_.end();attributeIter++)
                {
                        if((*attributeIter)->name_ == "DEST")
                        {
                                destination_ = (*attributeIter)->value_;
                        }
                        else if((*attributeIter)->name_ == "PARTY")
                        {
                                particleType_ = (*attributeIter)->value_;
                        }
                        else if((*attributeIter)->name_ == "SPCON")
                        {
                                spCon_ = (*attributeIter)->value_;
                        }
                        else
                        {
                                throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                        }
                }
    }

    CycleConfig::CycleConfig(fesa::ElementXML* config,long cycleID)
    {
        cycleID_ = cycleID;

        if(config->attributeList_.size() < 3)
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }

                std::vector<fesa::AttributeXML*>::iterator attributeIter;

                for(attributeIter = config->attributeList_.begin();attributeIter != config->attributeList_.end();attributeIter++)
                {
                        if((*attributeIter)->name_ == "basic-period-multiple")
                        {
                                fesa::StringUtilities::fromString(basicPeriodMultiple_, (*attributeIter)->value_);
                                if(basicPeriodMultiple_ <= 0)
                                        throw GSIException(__FILE__,__LINE__,FESAGSIErrorWrongBasicPeriod.c_str());
                        }
                        else if((*attributeIter)->name_ == "event-sequence-name-ref")
                        {
                                eventSequenceName_ = (*attributeIter)->value_;
                        }
                        else if((*attributeIter)->name_ == "name")
                        {
                                cycleName_ = (*attributeIter)->value_;
                        }
                        else
                        {
                                throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                        }
                }
                telegramData_ = NULL; //the default
                std::vector<fesa::ElementXML*>::iterator childIter;
        for(childIter = config->childList_.begin();childIter != config->childList_.end();childIter++)
        {
                if((*childIter)->name_ == "telegram-data")
                {
                        telegramData_ = new TelegramDataConfig(*childIter);
                }
        }
    }

    SuperCycleConfig::SuperCycleConfig()
    {
                //The cycleID's start at 1
                cycleIDCounter_ = 1;
    }

    void SuperCycleConfig::initialize(fesa::ElementXML* config)
    {
        if(config->attributeList_.size() < 1)
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }

                std::vector<fesa::AttributeXML*>::iterator attributeIter;
                for(attributeIter = config->attributeList_.begin();attributeIter != config->attributeList_.end();attributeIter++)
                {
                        if((*attributeIter)->name_ == "shift-delay")
                        {
                                fesa::StringUtilities::fromString(shiftDelay_, (*attributeIter)->value_);
                                if(shiftDelay_ < 0)
                                        throw GSIException(__FILE__,__LINE__,FESAGSIErrorWrongShiftDelay.c_str());
                        }
                        else
                        {
                                throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                        }
                }

                std::vector<fesa::ElementXML*>::iterator childIter;
        for(childIter = config->childList_.begin();childIter != config->childList_.end();childIter++)
        {
                if((*childIter)->name_ == "cycle")
                {
                        cycleCol_.push_back(CycleConfig(*childIter,cycleIDCounter_));
                        cycleIDCounter_++;
                }
        }
    }

    void SuperCycleConfig::linkEventSequences(std::vector<EventSequenceConfig*>& eventSequenceCol)
    {
        bool found = false;
        std::vector<CycleConfig>::iterator cycleIter;
        std::vector<EventSequenceConfig*>::iterator eventSeqIter;
        for(cycleIter= cycleCol_.begin();cycleIter!=cycleCol_.end();cycleIter++)
        {
                found = false;
                for(eventSeqIter=eventSequenceCol.begin();eventSeqIter!=eventSequenceCol.end();eventSeqIter++)
                {
                        if(cycleIter->eventSequenceName_ == (*eventSeqIter)->name_)
                        {
                                cycleIter->eventSequenceRef_ = *eventSeqIter;
                                found = true;
                                continue;//next cycle
                        }
                }
                if(!found)//if the EventSequence, used by this cycle cannot be located
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }
        }
    }

    DomainConfig::DomainConfig(fesa::ElementXML* config)
    {
        if(config->attributeList_.size() < 2)
                {
                        throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
                }

                std::vector<fesa::AttributeXML*>::iterator attributeIter;
                for(attributeIter = config->attributeList_.begin();attributeIter != config->attributeList_.end();attributeIter++)
                {
                        if((*attributeIter)->name_ == "name")
                        {
                                name_ =(*attributeIter)->value_;
                        }
                        if((*attributeIter)->name_ == "enable")
                        {
                                fesa::StringUtilities::fromString(enable_, (*attributeIter)->value_);
                        }
                }

                std::vector<fesa::ElementXML*>::iterator childIter;
        for(childIter = config->childList_.begin();childIter != config->childList_.end();childIter++)
        {
                if((*childIter)->name_ == "super-cycle")
                {
                        superCycle_.initialize(*childIter);
                }
                if((*childIter)->name_ == "event-sequence")
                {
                        eventSequenceCol_.push_back(new EventSequenceConfig(*childIter));
                }
        }
        //links the cycles to concrete EventSequences
        superCycle_.linkEventSequences(eventSequenceCol_);
    }

    DomainConfig::~DomainConfig()
    {
        std::vector<EventSequenceConfig*>::iterator iter;
        for(iter= eventSequenceCol_.begin();iter!=eventSequenceCol_.end();iter++)
        {
                delete *iter;
        }
    }

    TimingSimulationConfig::TimingSimulationConfig(const std::string& timingSimulationConfigFile)
    {
        timingSimulationConfigFile_ = timingSimulationConfigFile;
        fesa::XMLParser parser(timingSimulationConfigFile_,true);

        //get the Element-collection
        std::vector<fesa::ElementXML*>* pElCol = parser.extractElements("timing-simulation");

        if (pElCol == NULL)
        {
            throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
        }
        if(pElCol->size() != 1)
        {
                throw GSIException(__FILE__, __LINE__, FesaGSITimingSimulationFileCorrupt.c_str());
        }

        std::vector<fesa::ElementXML*>::iterator TSElement = pElCol->begin();
        std::vector<fesa::AttributeXML*>::iterator attributeIter;
        std::vector<fesa::ElementXML*>::iterator domainIter;

        //fill direct class attributes
        for(attributeIter = (*TSElement)->attributeList_.begin();attributeIter != (*TSElement)->attributeList_.end();attributeIter++)
        {
                if((*attributeIter)->name_ == "basic-period-length")
                {
                fesa::StringUtilities::fromString(basicPeriodLengthMs_, (*attributeIter)->value_);
                if(basicPeriodLengthMs_ == 0)
                        throw GSIException(__FILE__,__LINE__,FESAGSIErrorWrongBasicPeriodLength.c_str());
            }
                if((*attributeIter)->name_ == "repetition")
                {
                        fesa::StringUtilities::fromString(superCycleRepetition_, (*attributeIter)->value_);
                        if(superCycleRepetition_ < -1)
                                throw GSIException(__FILE__,__LINE__,FESAGSIErrorWrongRepetitionAttribute.c_str());
                }
        }

        //pass the collection-part down for each timing domain
        for(domainIter = (*TSElement)->childList_.begin();domainIter != (*TSElement)->childList_.end();domainIter++)
        {
                timingDomainCol_.push_back(new DomainConfig(*domainIter));
        }

        for (unsigned int i = 0; i < pElCol->size(); i++)
        {
            delete (*pElCol)[i];
        }
                delete pElCol;
    }

    TimingSimulationConfig::~TimingSimulationConfig()
    {
        std::vector<DomainConfig*>::iterator iter;
        for(iter= timingDomainCol_.begin();iter!=timingDomainCol_.end();iter++)
        {
                delete *iter;
        }
    }
}