event.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_EVENT_HEADER
#define LIBFILEZILLA_EVENT_HEADER

#include "libfilezilla.hpp"

#include <tuple>
#include <typeinfo>

namespace fz {

class FZ_PUBLIC_SYMBOL event_base
{
public:
    event_base() = default;
    virtual ~event_base() = default;

    event_base(event_base const&) = default;
    event_base& operator=(event_base const&) = default;
    event_base(event_base &&) = default;
    event_base& operator=(event_base &&) = default;

    virtual size_t derived_type() const = 0;
};

size_t FZ_PUBLIC_SYMBOL get_unique_type_id(std::type_info const& id);

template<typename UniqueType, typename...Values>
class simple_event final : public event_base
{
public:
    typedef UniqueType unique_type;
    typedef std::tuple<Values...> tuple_type;

    using event_base::event_base;

    template<typename First_Value, typename...Remaining_Values>
    explicit simple_event(First_Value&& value, Remaining_Values&& ...values)
        : v_(std::forward<First_Value>(value), std::forward<Remaining_Values>(values)...)
    {
    }

    inline static size_t type() {
        // Exporting templates from DLLs is problematic to say the least. It breaks
        // ODR, so we use this trick that goes over the type name.
        static size_t const v = get_unique_type_id(typeid(UniqueType*));
        return v;
    }

    virtual size_t derived_type() const override {
        return type();
    }

    mutable tuple_type v_;
};

class event_source{};

class event_with_source_base : public event_base
{
public:
    using event_base::event_base;
    virtual event_source* source() const  = 0;
};

template<typename UniqueType, typename...Values>
class event_with_source final : public event_with_source_base
{
public:
    typedef UniqueType unique_type;
    typedef std::tuple<Values...> tuple_type;

    using event_with_source_base::event_with_source_base;

    template<typename First_Value, typename...Remaining_Values>
    explicit event_with_source(First_Value&& value, Remaining_Values&& ...values)
        : v_(std::forward<First_Value>(value), std::forward<Remaining_Values>(values)...)
    {
    }

    inline static size_t type() {
        static size_t const v = get_unique_type_id(typeid(UniqueType*));
        return v;
    }

    virtual size_t derived_type() const override {
        return type();
    }

    virtual event_source* source() const override {
        return static_cast<event_source*>(std::get<0>(v_));
    }

    mutable tuple_type v_;
};

template<typename T>
bool same_type(event_base const& ev)
{
    return ev.derived_type() == T::type();
}

typedef unsigned long long timer_id;

struct timer_event_type{};

typedef simple_event<timer_event_type, timer_id> timer_event;

}

#endif