From 1bd545590afccc62070e4c7603fe1a37b6288db0 Mon Sep 17 00:00:00 2001 From: Roland Conybeare Date: Mon, 23 Oct 2023 12:01:29 -0400 Subject: [PATCH] bugfix: include paths --- include/xo/reactor/DirectSourcePtr.hpp | 28 +-- include/xo/reactor/LastReducer.hpp | 248 ++++++++++++------------- include/xo/reactor/SecondarySource.hpp | 3 +- 3 files changed, 139 insertions(+), 140 deletions(-) diff --git a/include/xo/reactor/DirectSourcePtr.hpp b/include/xo/reactor/DirectSourcePtr.hpp index db9c7734..8947a74a 100644 --- a/include/xo/reactor/DirectSourcePtr.hpp +++ b/include/xo/reactor/DirectSourcePtr.hpp @@ -2,24 +2,24 @@ #pragma once -#include "reactor/SecondarySource.hpp" -#include "reactor/LastReducer.hpp" -#include "reactor/EventTimeFn.hpp" +#include "SecondarySource.hpp" +#include "LastReducer.hpp" +#include "EventTimeFn.hpp" namespace xo { - namespace reactor { - template - using DirectSource = SecondarySource>>; + namespace reactor { + template + using DirectSource = SecondarySource>>; - /* use when Event is ref::rp for some T */ - template - using DirectSourcePtr = SecondarySource>>; + /* use when Event is ref::rp for some T */ + template + using DirectSourcePtr = SecondarySource>>; - } /*namespace reactor*/ + } /*namespace reactor*/ } /*namespace xo*/ /* end DirectSourcePtr.hpp */ diff --git a/include/xo/reactor/LastReducer.hpp b/include/xo/reactor/LastReducer.hpp index 86a5913c..b18f1a09 100644 --- a/include/xo/reactor/LastReducer.hpp +++ b/include/xo/reactor/LastReducer.hpp @@ -2,153 +2,153 @@ #pragma once -#include "reactor/Reducer.hpp" +#include "Reducer.hpp" #include namespace xo { - namespace reactor { - /* implementation record used in LastReducer. - * LastReducer (see below) remembers a single event, - * + will be updated on successive calls to - * LastReducer.include_event() - * - * need to remember the _first_ (& therefore earliest) - * event timestamp in such a wave, since that establishes when simulator - * should deliver the event -- even if event is subsequently - * overwritten. - * - * once event is delivered, timestamp can reset - * - * otherwise if upstream producer sends events with - * future timestamps, can get indefinite postponement - * with simulation clock failing to catch up to event time. - * - */ - - template - class EventRecd { - public: - using utc_nanos = xo::time::utc_nanos; + namespace reactor { + /* implementation record used in LastReducer. + * LastReducer (see below) remembers a single event, + * + will be updated on successive calls to + * LastReducer.include_event() + * + * need to remember the _first_ (& therefore earliest) + * event timestamp in such a wave, since that establishes when simulator + * should deliver the event -- even if event is subsequently + * overwritten. + * + * once event is delivered, timestamp can reset + * + * otherwise if upstream producer sends events with + * future timestamps, can get indefinite postponement + * with simulation clock failing to catch up to event time. + * + */ - public: - EventRecd() = default; - EventRecd(utc_nanos tm, Event ev) : trigger_tm_{tm}, ev_{ev} {} - EventRecd(utc_nanos tm, Event && ev) : trigger_tm_{tm}, ev_{std::move(ev)} {} + template + class EventRecd { + public: + using utc_nanos = xo::time::utc_nanos; - public: - /* if sim, deliver event when simulation clock reaches - * .trigger_tm; .trigger_tm can be earlier than .ev time - */ - utc_nanos trigger_tm_; - /* event to deliver */ - Event ev_; - }; + public: + EventRecd() = default; + EventRecd(utc_nanos tm, Event ev) : trigger_tm_{tm}, ev_{ev} {} + EventRecd(utc_nanos tm, Event && ev) : trigger_tm_{tm}, ev_{std::move(ev)} {} - /* reducer that just remembers the last event - * - * Require: - * - Event is null-contructible - * - Event is copyable - * - * LastReducer provides reentrancy support. This support doesn't operate - * if Event copy is not deep, e.g. for Event = rpn - * - * .include_event() - * /-------\ -----------------> /------\ - * | empty | | full | - * \-------/ <----------------- \------/ - * . .annex_one() . - * . . - * .is_empty()=true .is_empty()=false - */ - template> - class LastReducer : public ReducerBase { - public: - using utc_nanos = xo::time::utc_nanos; + public: + /* if sim, deliver event when simulation clock reaches + * .trigger_tm; .trigger_tm can be earlier than .ev time + */ + utc_nanos trigger_tm_; + /* event to deliver */ + Event ev_; + }; - public: - LastReducer() = default; - LastReducer(EventTimeFn const & evtfn) : ReducerBase(evtfn) {} + /* reducer that just remembers the last event + * + * Require: + * - Event is null-contructible + * - Event is copyable + * + * LastReducer provides reentrancy support. This support doesn't operate + * if Event copy is not deep, e.g. for Event = rpn + * + * .include_event() + * /-------\ -----------------> /------\ + * | empty | | full | + * \-------/ <----------------- \------/ + * . .annex_one() . + * . . + * .is_empty()=true .is_empty()=false + */ + template> + class LastReducer : public ReducerBase { + public: + using utc_nanos = xo::time::utc_nanos; - bool is_empty() const { return empty_flag_; } - /* require: .is_empty() = false */ - utc_nanos next_tm() const { - return this->last_ev_[this->last_ix_].trigger_tm_; - //return this->event_tm(this->last_ev_[this->last_ix_]); - } - /* #of events stored in this reducer (0 or 1) */ - uint32_t n_event() const { return this->empty_flag_ ? 0 : 1; } + public: + LastReducer() = default; + LastReducer(EventTimeFn const & evtfn) : ReducerBase(evtfn) {} - Event const & last_annexed_ev() const { - return this->last_ev_[1 - this->last_ix_].ev_; - } + bool is_empty() const { return empty_flag_; } + /* require: .is_empty() = false */ + utc_nanos next_tm() const { + return this->last_ev_[this->last_ix_].trigger_tm_; + //return this->event_tm(this->last_ev_[this->last_ix_]); + } + /* #of events stored in this reducer (0 or 1) */ + uint32_t n_event() const { return this->empty_flag_ ? 0 : 1; } - EventRecd & include_event_aux(Event const & ev) { - EventRecd & evr - = this->last_ev_[this->last_ix_]; + Event const & last_annexed_ev() const { + return this->last_ev_[1 - this->last_ix_].ev_; + } - if (this->empty_flag_) { - /* evr.trigger_tm will be preserved across - * successive calls to .include_event(); - * until .annex_one() - */ - evr.trigger_tm_ = this->event_tm(ev); + EventRecd & include_event_aux(Event const & ev) { + EventRecd & evr + = this->last_ev_[this->last_ix_]; - this->empty_flag_ = false; - } + if (this->empty_flag_) { + /* evr.trigger_tm will be preserved across + * successive calls to .include_event(); + * until .annex_one() + */ + evr.trigger_tm_ = this->event_tm(ev); - return evr; - } /*include_event_aux*/ + this->empty_flag_ = false; + } - void include_event(Event const & ev) { - EventRecd & evr - = this->include_event_aux(ev); + return evr; + } /*include_event_aux*/ - evr.ev_ = ev; - } /*include_event*/ + void include_event(Event const & ev) { + EventRecd & evr + = this->include_event_aux(ev); - void include_event(Event && ev) { - EventRecd & evr - = this->include_event_aux(ev); - - evr.ev_ = std::move(ev); - } /*include_event*/ + evr.ev_ = ev; + } /*include_event*/ - Event & annex_one() { - std::uint32_t annexed_ix = this->last_ix_; + void include_event(Event && ev) { + EventRecd & evr + = this->include_event_aux(ev); - /* since .empty_flag is true, - * next call to .include_event_aux() will - * capture new timestamp - */ - this->empty_flag_ = true; - this->last_ix_ = (1 - this->last_ix_); + evr.ev_ = std::move(ev); + } /*include_event*/ - return this->last_ev_[annexed_ix].ev_; - } /*annex_one*/ + Event & annex_one() { + std::uint32_t annexed_ix = this->last_ix_; - // ----- Inherited from ReducerBase ----- + /* since .empty_flag is true, + * next call to .include_event_aux() will + * capture new timestamp + */ + this->empty_flag_ = true; + this->last_ix_ = (1 - this->last_ix_); - //utc_nanos event_tm(Event const & ev) const { return this->event_tm_fn_(ev); } + return this->last_ev_[annexed_ix].ev_; + } /*annex_one*/ - private: - /* true when reducer contains 0 queued events, - * not counting any annexed event - */ - bool empty_flag_ = true; + // ----- Inherited from ReducerBase ----- - /* .last_ev[.last_ix] updated by .include_event() - */ - std::uint32_t last_ix_ = 0; - /* remember two events - * (a) a single queued event (updated by .include_event()) - * (b) a single removed event (reported by .annex_one()) - * - * roles of .last_ev[0], .last_ev[1] reverse each time .annex_one() runs - */ - std::array, 2> last_ev_; - }; /*LastReducer*/ - } /*namespace reactor*/ + //utc_nanos event_tm(Event const & ev) const { return this->event_tm_fn_(ev); } + + private: + /* true when reducer contains 0 queued events, + * not counting any annexed event + */ + bool empty_flag_ = true; + + /* .last_ev[.last_ix] updated by .include_event() + */ + std::uint32_t last_ix_ = 0; + /* remember two events + * (a) a single queued event (updated by .include_event()) + * (b) a single removed event (reported by .annex_one()) + * + * roles of .last_ev[0], .last_ev[1] reverse each time .annex_one() runs + */ + std::array, 2> last_ev_; + }; /*LastReducer*/ + } /*namespace reactor*/ } /*namespace xo*/ /* end LastReducer.hpp */ diff --git a/include/xo/reactor/SecondarySource.hpp b/include/xo/reactor/SecondarySource.hpp index c58c2e92..3b10de63 100644 --- a/include/xo/reactor/SecondarySource.hpp +++ b/include/xo/reactor/SecondarySource.hpp @@ -2,9 +2,8 @@ #pragma once -//#include "time/Time.hpp" +#include "EventSource.hpp" #include "Sink.hpp" -//#include "xo/reactor/DirectSource.hpp" #include "Reactor.hpp" #include "HeapReducer.hpp" #include "xo/callback/CallbackSet.hpp"