GlobalEvent.hpp

Go to the documentation of this file.

// <GlobalEvent.h> -*- C++ -*-
 
 
#pragma once
 
#include <memory>
#include "sparta/simulation/Clock.hpp"
#include "sparta/kernel/SpartaHandler.hpp"
#include "sparta/utils/LifeTracker.hpp"
#include "sparta/events/PhasedPayloadEvent.hpp"
#include "sparta/events/SchedulingPhases.hpp"
 
namespace sparta
{
    template<SchedulingPhase sched_phase_T>
    class GlobalEvent;
 
    class GlobalEventProxy
    {
    public:
        GlobalEventProxy() = default;
        GlobalEventProxy(const GlobalEventProxy&) = default;
        GlobalEventProxy & operator=(const GlobalEventProxy&) = default;
 
        template<SchedulingPhase sched_phase_T = SchedulingPhase::Update>
        GlobalEventProxy(const utils::LifeTracker<SpartaHandler> & handler) :
            phase_(sched_phase_T),
            ev_handler_(handler)
        {}
 
        void operator()(void) const
        {
            if(!ev_handler_.expired()) {
                auto sptr = ev_handler_.lock();
                (*(sptr->tracked_object))();
            }
        }
 
        const SchedulingPhase & getSchedulingPhase() const { return phase_; }
 
        ~GlobalEventProxy() = default;
 
    private:
        SchedulingPhase                                 phase_;
        std::weak_ptr<utils::LifeTracker<SpartaHandler>> ev_handler_;
   };
 
    template<SchedulingPhase sched_phase_T = SchedulingPhase::Update>
    class GlobalEvent
    {
    public:
        GlobalEvent(const Clock * clk,
                    const SpartaHandler & event_handler) :
            local_clk_(clk),
            event_handler_(event_handler),
            ev_sched_ptr_(clk->getScheduler()->getGlobalPhasedPayloadEventPtr<sched_phase_T>())
        {}
 
        GlobalEvent(const GlobalEvent& rhs) :
            local_clk_(rhs.local_clk_),
            event_handler_(rhs.event_handler_),
            ev_handler_lifetime_(&event_handler_),
            ev_sched_ptr_(rhs.ev_sched_ptr_)
        {
        }
 
        GlobalEvent(GlobalEvent&& rhs) :
            local_clk_(rhs.local_clk_),
            event_handler_(std::move(rhs.event_handler_)),
            ev_handler_lifetime_(&event_handler_),
            ev_sched_ptr_(rhs.ev_sched_ptr_)
        {
            rhs.ev_handler_lifetime_.reset();
        }
 
        GlobalEvent& operator=(const GlobalEvent& rhs) {
            local_clk_ = rhs.local_clk_;
            event_handler_ = rhs.event_handler_;
            ev_handler_lifetime_ = utils::LifeTracker<SpartaHandler>(&event_handler_);
            ev_sched_ptr_ = rhs.ev_sched_ptr_;
 
            return *this;
        }
 
        GlobalEvent& operator=(GlobalEvent&& rhs) {
            local_clk_ = rhs.local_clk_;
            event_handler_ = std::move(rhs.event_handler_);
            ev_handler_lifetime_ = utils::LifeTracker<SpartaHandler>(&event_handler_);
            ev_sched_ptr_ = rhs.ev_sched_ptr_;
 
            rhs.ev_handler_lifetime_.reset();
 
            return *this;
        }
 
        void schedule(const Clock::Cycle & delay, const Clock * clk) {
            sparta_assert(ev_sched_ptr_ != nullptr);
            sparta_assert(ev_sched_ptr_->getSchedulingPhase() == sched_phase_T);
 
            ev_sched_ptr_->preparePayload(GlobalEventProxy(ev_handler_lifetime_))->schedule(delay, clk);
        }
 
        void schedule(const Clock::Cycle & delay) {
            sparta_assert(ev_sched_ptr_ != nullptr);
            sparta_assert(ev_sched_ptr_->getSchedulingPhase() == sched_phase_T);
 
            ev_sched_ptr_->preparePayload(GlobalEventProxy(ev_handler_lifetime_))->schedule(delay, local_clk_);
        }
 
        void resetHandler(const SpartaHandler & event_handler) {
            event_handler_ = event_handler;
        }
 
        ~GlobalEvent() {
            //std::cout << "Destroy GlobalEvent!\n";
        }
 
        friend class GlobalEventProxy;
 
    private:
        const Clock                          * local_clk_ = nullptr;
        SpartaHandler                          event_handler_;
        utils::LifeTracker<SpartaHandler>      ev_handler_lifetime_{&event_handler_};
        PhasedPayloadEvent<GlobalEventProxy> * ev_sched_ptr_;
    };
 
}