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_;
};
 
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