event.h

Go to the documentation of this file.

// Copyright (C) 2013-2020 iFunFactory Inc. All Rights Reserved.
//
// This work is confidential and proprietary to iFunFactory Inc. and
// must not be used, disclosed, copied, or distributed without the prior
// consent of iFunFactory Inc.

#ifndef INCLUDE_FUNAPI_SYSTEM_EVENT_H_
#define INCLUDE_FUNAPI_SYSTEM_EVENT_H_

#include <boost/any.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <funapi/network/session.h>
#include <funapi/time/wall_clock.h>
#include <funapi/types.h>
#include <google/protobuf/message.h>

#include <map>
#include <typeinfo>


namespace fun {

typedef Uuid EventId;

typedef Uuid EventTag;
FUNAPI_DLL_VISIBILITY extern const EventTag kNullEventTag;


class FUNAPI_DLL_VISIBILITY Event {
  public:
    typedef function<
        void(const string &/*event_name*/,
             const EventId &/*event_id*/,
             const EventTag &/*event_tag*/,
             const Ptr<Session> &/*associated_session*/)> TimeoutHandler;

    template <typename EventT>
    struct EventTypeCaster {
      typedef Ptr<const EventT> result_type;
      Ptr<const EventT> operator()(const Ptr<const void> &t);
    };

    template <typename EventT>
    static void RegisterHandler(
        const function<ChainAction(Ptr<const EventT>)> &h);

    template <typename EventT>
    static void RegisterHandler(ChainAction (handler)(Ptr<const EventT>));

    static void RegisterTimeoutHandler(const TimeoutHandler &handler);

    template <typename EventT>
    static bool Post(Ptr<EventT> event);
    template <typename EventT>
    static bool Post(Ptr<EventT> event, const EventTag &event_tag);
    template <typename EventT>
    static bool Post(Ptr<EventT> event, const string &event_name);
    template <typename EventT>
    static bool Post(Ptr<EventT> event, const string &event_name,
                     const EventTag &event_tag);

    static bool Invoke(const function<void()> &func);
    static bool Invoke(const function<void()> &func, const EventTag &event_tag);
    static bool Invoke(const function<void()> &func, const string &event_name);
    static bool Invoke(const function<void()> &func, const string &event_name,
                       const EventTag &event_tag);

    static void Resume(const EventTag &event_tag);

    static void Abort();

  private:
    typedef function<ChainAction (Ptr<const void>)> VoidedHandler;

    static void RegisterHandler(const std::type_info &, const VoidedHandler &);
    static bool Post(const std::type_info &, Ptr<const void>);
    static bool Post(const std::type_info &,
                     Ptr<const void>,
                     const EventTag &event_tag);
    static bool Post(const std::type_info &, Ptr<const void>, const string &);
    static bool Post(const std::type_info &,
                     Ptr<const void>,
                     const string &,
                     const EventTag &event_tag);
};


FUNAPI_DLL_VISIBILITY void ProcessNextEventAfterTimeout(const EventTag &tag);


FUNAPI_DLL_VISIBILITY const EventTag &GetCurrentEventTag();


FUNAPI_DLL_VISIBILITY void SetEventName(const string &name);
FUNAPI_DLL_VISIBILITY const string &GetEventName();
FUNAPI_DLL_VISIBILITY DEPRECATED(void DebugSetEventName(const string &name));
FUNAPI_DLL_VISIBILITY DEPRECATED(const string &DebugGetEventName());


FUNAPI_DLL_VISIBILITY WallClock::Duration GetEventQueueDelay();


template <typename EventT>
Ptr<const EventT> Event::EventTypeCaster<EventT>::operator()(
    const Ptr<const void> &t) {
  return boost::static_pointer_cast<const EventT, const void>(t);
}


template <typename EventT>
void Event::RegisterHandler(const function<ChainAction(Ptr<const EventT>)> &h) {
#ifndef _WIN32
  VoidedHandler f = VoidedHandler(
      boost::bind(h, boost::bind(EventTypeCaster<EventT>(), _1)));
  RegisterHandler(typeid(EventT), f);
#else  // _WIN32
  RegisterHandler(typeid(EventT),
    [h](Ptr<const void> p) {
    const EventT *ep = static_cast<const EventT*>(p.get());
    return h(Ptr<const EventT>(p, ep));
  });
#endif  // _WIN32
}


template <typename EventT>
void Event::RegisterHandler(ChainAction (handler)(Ptr<const EventT>)) {
  RegisterHandler(typename EventT::Handler(handler));
}


template <typename EventT>
bool Event::Post(Ptr<EventT> event) {
  return Post(typeid(EventT), event);
}


template <typename EventT>
bool Event::Post(Ptr<EventT> event, const EventTag &event_tag) {
  return Post(typeid(EventT), event, event_tag);
}


template <typename EventT>
bool Event::Post(Ptr<EventT> event, const string &event_name) {
  return Post(typeid(EventT), event_name, event);
}


template <typename EventT>
bool Event::Post(Ptr<EventT> event, const string &event_name,
                 const EventTag &event_tag) {
  return Post(typeid(EventT), event, event_name, event_tag);
}

}  // namespace fun

#endif  // INCLUDE_FUNAPI_SYSTEM_EVENT_H_