6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2026-04-25 11:17:26 +00:00
Code Issues Projects Releases Wiki Activity

Take another big swing at indentation, some consts.

Browse Source
This commit is contained in:
Thomas Harte
2024-12-01 21:44:14 -05:00
parent 31c878b654
commit d3ed485e7a
158 changed files with 12552 additions and 12483 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Storage/TimedEventLoop.hpp
+76 -76
View File
@@ -16,93 +16,93 @@
namespace Storage {
/*!
Provides a mechanism for arbitrarily timed events to be processed according to a fixed-base
discrete clock signal, ensuring correct timing.
Subclasses are responsible for calling @c set_next_event_time_interval to establish the time
until a next event; @c process_next_event will be called when that event occurs, with progression
determined via @c run_for.
Due to the aggregation of total timing information between events, e.g. if an event loop has
a clock rate of 1000 ticks per second and a steady stream of events that occur 10,000 times a second,
bookkeeping is necessary to ensure that 10 events are triggered per tick. Subclasses should call
@c reset_timer if there is a discontinuity in events.
Subclasses may also call @c jump_to_next_event to cause the next event to be communicated instantly.
Subclasses are therefore expected to call @c set_next_event_time_interval upon obtaining an event stream,
and again in response to each call to @c process_next_event while events are ongoing. They may use
@c reset_timer to initiate a distinctly-timed stream or @c jump_to_next_event to short-circuit the timing
loop and fast forward immediately to the next event.
*/
class TimedEventLoop {
public:
/*!
Provides a mechanism for arbitrarily timed events to be processed according to a fixed-base
discrete clock signal, ensuring correct timing.
Subclasses are responsible for calling @c set_next_event_time_interval to establish the time
until a next event; @c process_next_event will be called when that event occurs, with progression
determined via @c run_for.
Due to the aggregation of total timing information between events, e.g. if an event loop has
a clock rate of 1000 ticks per second and a steady stream of events that occur 10,000 times a second,
bookkeeping is necessary to ensure that 10 events are triggered per tick. Subclasses should call
@c reset_timer if there is a discontinuity in events.
Subclasses may also call @c jump_to_next_event to cause the next event to be communicated instantly.
Subclasses are therefore expected to call @c set_next_event_time_interval upon obtaining an event stream,
and again in response to each call to @c process_next_event while events are ongoing. They may use
@c reset_timer to initiate a distinctly-timed stream or @c jump_to_next_event to short-circuit the timing
loop and fast forward immediately to the next event.
Constructs a timed event loop that will be clocked at @c input_clock_rate.
*/
class TimedEventLoop {
public:
/*!
Constructs a timed event loop that will be clocked at @c input_clock_rate.
*/
TimedEventLoop(Cycles::IntType input_clock_rate);
TimedEventLoop(Cycles::IntType input_clock_rate);
/*!
Advances the event loop by @c number_of_cycles cycles.
*/
void run_for(const Cycles cycles);
/*!
Advances the event loop by @c number_of_cycles cycles.
*/
void run_for(const Cycles cycles);
/*!
@returns the number of whole cycles remaining until the next event is triggered.
*/
Cycles::IntType get_cycles_until_next_event() const;
/*!
@returns the number of whole cycles remaining until the next event is triggered.
*/
Cycles::IntType get_cycles_until_next_event() const;
/*!
@returns the input clock rate.
*/
Cycles::IntType get_input_clock_rate() const;
/*!
@returns the input clock rate.
*/
Cycles::IntType get_input_clock_rate() const;
protected:
/*!
Sets the time interval, as a proportion of a second, until the next event should be triggered.
*/
void set_next_event_time_interval(Time interval);
void set_next_event_time_interval(float interval);
protected:
/*!
Sets the time interval, as a proportion of a second, until the next event should be triggered.
*/
void set_next_event_time_interval(Time interval);
void set_next_event_time_interval(float interval);
/*!
Communicates that the next event is triggered. A subclass will idiomatically process that event
and make a fresh call to @c set_next_event_time_interval to keep the event loop running.
*/
virtual void process_next_event() = 0;
/*!
Communicates that the next event is triggered. A subclass will idiomatically process that event
and make a fresh call to @c set_next_event_time_interval to keep the event loop running.
*/
virtual void process_next_event() = 0;
/*!
Optionally allows a subclass to track time within run_for periods; if a subclass implements
advnace then it will receive advance increments that add up to the number of cycles supplied
to run_for, but calls to process_next_event will be precisely interspersed. No time will carry
forward between calls into run_for; a subclass can receive arbitrarily many instructions to
advance before receiving a process_next_event.
*/
virtual void advance([[maybe_unused]] const Cycles cycles) {};
/*!
Optionally allows a subclass to track time within run_for periods; if a subclass implements
advnace then it will receive advance increments that add up to the number of cycles supplied
to run_for, but calls to process_next_event will be precisely interspersed. No time will carry
forward between calls into run_for; a subclass can receive arbitrarily many instructions to
advance before receiving a process_next_event.
*/
virtual void advance([[maybe_unused]] const Cycles cycles) {};
/*!
Resets timing, throwing away any current internal state. So clears any fractional ticks
that the event loop is currently tracking.
*/
void reset_timer();
/*!
Resets timing, throwing away any current internal state. So clears any fractional ticks
that the event loop is currently tracking.
*/
void reset_timer();
/*!
Causes an immediate call to @c process_next_event and a call to @c reset_timer with the
net effect of processing the current event immediately and fast forwarding exactly to the
start of the interval prior to the next event.
*/
void jump_to_next_event();
/*!
Causes an immediate call to @c process_next_event and a call to @c reset_timer with the
net effect of processing the current event immediately and fast forwarding exactly to the
start of the interval prior to the next event.
*/
void jump_to_next_event();
/*!
@returns the amount of time that has passed since the last call to @c set_next_time_interval,
which will always be less than or equal to the time that was supplied to @c set_next_time_interval.
*/
Time get_time_into_next_event();
/*!
@returns the amount of time that has passed since the last call to @c set_next_time_interval,
which will always be less than or equal to the time that was supplied to @c set_next_time_interval.
*/
Time get_time_into_next_event();
private:
Cycles::IntType input_clock_rate_ = 0;
Cycles::IntType cycles_until_event_ = 0;
float subcycles_until_event_ = 0.0f;
};
private:
Cycles::IntType input_clock_rate_ = 0;
Cycles::IntType cycles_until_event_ = 0;
float subcycles_until_event_ = 0.0f;
};
}