filcuc / hope

A simple pure C++11 event loop with signals and slots

Hope

A simple pure C++11 event loop with signals and slots

Notes

This project doesn't aim to become a general purpose library. It was done for fun and scratching my own itch. That said it can be useful for simple command line projects

How it looks?

#include <hope/application.h>
#include <hope/timer.h>

using namespace hope;

class HelloWorldPrinter : public Object {
public:
    void say_hello() {
        std::cout << "Hello World" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    Application app;

    HelloWorldPrinter printer;

    Timer timer;
    timer.set_duration(std::chrono::seconds(1));
    timer.triggered().connect(&printer, &HelloWorldPrinter::say_hello);
    timer.triggered().connect(&app, &Application::quit);
    timer.start();

    return app.exec();
}

Building

The project require a working C++11 compiler

mkdir build
cd build 
cmake ..
cmake --build .

Installing

Follow the build steps and simply execute

sudo make install

hope's Issues

Expose Auto, Direct, Queued, QueuedBlocking to Signal and ObjectInvoker

Start documentation

Research removal of queued signal events on disconnect

This would be cool and gives a lot more safety when deleting an Object from a different thread.
In fact if disconnecting ensure that there will be no more notification than we can safely delete the receiver. The hard part is that implementing this behaviour can cause deadlock

Fix Application + EventLoop + Thread relationships

Create a singleton (or thread local) struct for storing some information important for the current thread.
For example:

• the current thread event loop (This should be set in the EventLoop::exec())
• The Application should create a Thread and invoke its exec(). By not calling the Thread::start() it should not spawn a real thread

A Thread simply run an EventLoop and that's the reason why the Application class own a Thread

Signal should be disconnected on object destruction

Add a new invoker class for calling object methods

This should be usefull when calling an object from a different thread and interfacing with standard std::thread or other frameworks

Support disconnect with sender/receiver + function pointer sintax

In other words a syntax that match the "connect" method

Remove code duplication in Signal.h

Signal should be thread safe

Registration and emit should be thread safe