EventNode.hpp

Go to the documentation of this file.

// <EventNode.h> -*- C++ -*-
 
 
#pragma once
 
#include <set>
#include <memory>
#include <string>
 
#include "sparta/simulation/Clock.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/events/SchedulingPhases.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
namespace sparta
{
 
    // Forward declare the Scheduler -- not used by EventNode
    class Scheduler;
    class Scheduleable;
    class StartupEvent;
 
    class EventNode : public TreeNode
    {
    protected:
 
        EventNode(TreeNode * event_set,
                  const std::string & name,
                  sparta::SchedulingPhase sched_phase) :
            TreeNode(nullptr, name, name + " EventNode"),
            sched_phase_(sched_phase)
        {
            sparta_assert(event_set != nullptr,
                        "Events must created with an EventSet: " << name);
            setExpectedParent_(event_set);
            ensureParentIsEventSet_(event_set);
            event_set->addChild(this);
        }
 
        EventNode(const EventNode&) = delete;
 
        EventNode(EventNode&&) = delete;
 
        EventNode& operator=(const EventNode &) = delete;
 
        virtual ~EventNode() = default;
 
        static Scheduler * determineScheduler(const Clock * clk) {
            if (!clk) {
                return nullptr;
            }
            auto scheduler = clk->getScheduler();
            sparta_assert(scheduler, "Clock with no scheduler passed to EventNode::determineScheduler()");
            return scheduler;
        }
 
        friend StartupEvent;
 
    public:
 
        const char * getLabel() const {
            return getName().c_str();
        }
 
        sparta::SchedulingPhase getSchedulingPhase() const {
            return sched_phase_;
        }
 
        virtual Scheduleable & getScheduleable() = 0;
 
        virtual void participateInAutoPrecedence(bool participate) {
            participate_in_auto_precedence_ = participate;
        }
 
        virtual bool doesParticipateInAutoPrecedence() const {
            return participate_in_auto_precedence_;
        }
 
    private:
 
        void ensureParentIsEventSet_(sparta::TreeNode* parent);
 
        const sparta::SchedulingPhase sched_phase_;
 
        bool participate_in_auto_precedence_ = true;
    };
}