eventy 0.4.3
Easy to use event-loop dispatcher mechanism
To use this package, run the following command in your project's root directory:
Manual usage
Put the following dependency into your project's dependences section:
Eventy
Easy-to-use event-loop dispatcher framework for D-based applications
Getting started
The engine
The first thing every Eventy-based application will need is an instance of the Engine
.
This provides the user with a single object instance of the Engine
class by which
the user can register event types, signal handlers for said events and the ability
to trigger or push events into the engine.
The simplest way to get a new engine up and running is as follow:
Engine engine = new Engine();
This will create a new engine initializing all of its internals such that it is ready for use.
Event types
Event types are effectively just numbers. The use of these is to be able to connect events pushed into the engine with their respective signal handlers (which are registered to handle one or more event types).
Let's create two event types, with IDs 1
and 2
:
engine.addEventType(new EventType(1));
engine.addEventType(new EventType(2));
This will tell the engine to create two new event types with tags 1
and 2
respectively.
Signal handlers
We're almost done. So far we have created a new engine for handling our event tyoes and
the triggering of events. What is missing is something to handle those event types when
an event of one of those types is pushed into the engine. Such handlers are referred to as
signal handlers and in Eventy these are instances of the Signal
class.
We're going to create a signal that can handle both of the event types 1
and 2
that we
registered earlier on. We can do this by creating a class that inherits from the Signal
base class:
class SignalHandler1 : Signal
{
this()
{
super([1,2]);
}
public override void handler(Event e)
{
import std.stdio;
writeln("Running event", e.getID());
}
}
We need to tell the Signal
class two things:
- What event typess it will handle
- What to run for said event types
The first of these two is very easy, this is what you see in the constructor this()
:
this()
{
super([1,2]);
}
The super([1,2])
call tells the Signal class that this signal handler handles those
two IDs, namely 1
and 2
.
As for what to run, that is specified by overriding the void handler(Event)
method
in the Signal
class. In our case we make it write to the console the ID of the event
(which would end up either being 1
or 2
seeing as this handler is only registered
for those event types).
import std.stdio;
writeln("Running event", e.id);
We're almost there, trust me. The last thing to do is to register this signal handler with the engine, we do so as follows:
Signal j = new SignalHandler1();
engine.addSignalHandler(j);
Triggering events
Now comes the fun part, you can add events into the system by pushing them to the core as follows:
Event eTest = new Event(1);
engine.push(eTest);
eTest = new Event(2);
engine.push(eTest);
You will then see something like this:
Running event1
Running event2
or:
Running event1
Running event2
Despite us pushing the events into the engine in the order of 1
and then 2
, the
scheduling of such threads is up to the Linux kernel and hence one could be run before
the other.
Release notes
v0.4.3
Completely overhauled Eventy system for the v0.4.3 release
Removed the event-loop for a better system (for now) whereby we just dispatch signal handlers on the call to `push(Event)`.
In a future release I hope to bring the event loop back but in a signal-based manner, such that we can support deferred events and priorities and such
- Registered by Tristan B. Velloza Kildaire
- 0.4.3 released 2 years ago
- deavmi/eventy
- LGPL v3
- Copyright © 2020, Tristan B. Kildaire
- Authors:
- Dependencies:
- none
- Versions:
-
0.4.3 2022-Nov-28 0.4.1 2022-Nov-28 0.4.0 2022-Nov-28 0.3.3 2022-Nov-26 0.3.2 2022-Nov-26 - Download Stats:
-
-
0 downloads today
-
0 downloads this week
-
0 downloads this month
-
286 downloads total
-
- Score:
- 0.8
- Short URL:
- eventy.dub.pm