Events.hpp

#ifndef _LDAPLUSPLUS_EVENTS_EVENTS_HPP_
#define _LDAPLUSPLUS_EVENTS_EVENTS_HPP_


#include <list>
#include <memory>
#include <mutex>
#include <thread>
#include <unordered_set>

namespace ldaplusplus {
namespace events {


class Event
{
    public:
        Event(std::string id);

        const std::string & id() const;

    private:
        std::string id_;
};


class EventListenerInterface
{
    public:
        virtual void on_event(std::shared_ptr<Event> event) = 0;

        virtual ~EventListenerInterface(){};
};


class FunctionEventListener : public EventListenerInterface
{
    public:
        FunctionEventListener(std::function<void(std::shared_ptr<Event>)> listener);

        void on_event(std::shared_ptr<Event> event) override;

    private:
        std::function<void(std::shared_ptr<Event>)> listener_;
};


class EventDispatcherInterface
{
    public:
        virtual void add_listener(std::shared_ptr<EventListenerInterface> listener) = 0;

        virtual void remove_listener(std::shared_ptr<EventListenerInterface> listener) = 0;

        virtual void dispatch(std::shared_ptr<Event> event) = 0;

        std::shared_ptr<EventListenerInterface> add_listener(
            std::function<void(std::shared_ptr<Event>)> listener
        ) {
            auto l = std::make_shared<FunctionEventListener>(listener);

            add_listener(l);

            return l;
        }

        template <class ListenerType, typename... Args>
        std::shared_ptr<EventListenerInterface> add_listener(Args... args) {
            auto l = std::make_shared<ListenerType>(args...);

            add_listener(l);

            return l;
        }

        template <class EventType, typename... Args>
        void dispatch(Args... args) {
            auto event = std::make_shared<EventType>(args...);

            dispatch(event);
        }

        virtual ~EventDispatcherInterface(){};
};


class EventDispatcher : public EventDispatcherInterface
{
    public:
        void add_listener(std::shared_ptr<EventListenerInterface> listener) override;
        void remove_listener(std::shared_ptr<EventListenerInterface> listener) override;
        void dispatch(std::shared_ptr<Event> event) override;

    private:
        std::list<std::shared_ptr<EventListenerInterface> > listeners_;
};


class EventDispatcherComposition
{
    public:
        EventDispatcherComposition() :
            event_dispatcher_(std::make_shared<EventDispatcher>())
        {}

        std::shared_ptr<EventDispatcherInterface> get_event_dispatcher() {
            return event_dispatcher_;
        }

        void set_event_dispatcher(std::shared_ptr<EventDispatcherInterface> dispatcher) {
            event_dispatcher_ = dispatcher;
        }

    private:
        std::shared_ptr<EventDispatcherInterface> event_dispatcher_;
};


class ThreadSafeEventDispatcher : public EventDispatcherInterface
{
    public:
        virtual void add_listener(std::shared_ptr<EventListenerInterface> listener) override;
        virtual void remove_listener(std::shared_ptr<EventListenerInterface> listener) override;
        virtual void dispatch(std::shared_ptr<Event> event) override;

        void process_events();

    private:
        std::mutex listeners_mutex_;
        std::list<std::shared_ptr<EventListenerInterface> > listeners_;

        std::mutex deleted_listeners_mutex_;
        std::unordered_set<std::shared_ptr<EventListenerInterface> > deleted_listeners_;

        std::mutex events_mutex_;
        std::list<std::shared_ptr<Event> > events_;
};


class SameThreadEventDispatcher : public ThreadSafeEventDispatcher
{
    public:
        SameThreadEventDispatcher();

        virtual void dispatch(std::shared_ptr<Event> event) override;

    private:
        std::thread::id thread_id_;
};

}  // namespace events
}  // namespace ldaplusplus

#endif  // _LDAPLUSPLUS_EVENTS_EVENTS_HPP_