PlatformEvent.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include <utility>
#include <vector>
 
#include "common/Module.h"
#include "common/Subscription.h"
 
namespace ssq {
class Table;
class Class;
}  // namespace ssq
 
namespace eve {
namespace platform_event {
 
struct Variant {
    enum class Type { Nil, Int, String, Ptr };
    Type                  type = Type::Nil;
    int64_t               i    = 0;
    std::string           s;
    void*                 p = nullptr;
    std::shared_ptr<void> owner;
 
    static Variant makeNil() { return {}; }
    static Variant makeInt(int64_t v) {
        Variant x;
        x.type = Type::Int;
        x.i    = v;
        return x;
    }
    static Variant makeString(std::string v) {
        Variant x;
        x.type = Type::String;
        x.s    = std::move(v);
        return x;
    }
    static Variant makePtr(void* v) {
        Variant x;
        x.type = Type::Ptr;
        x.p    = v;
        return x;
    }
    template <class T>
    static Variant makeOwnedPtr(T* v) {
        Variant x;
        x.type = Type::Ptr;
        x.p    = v;
        if (v) x.owner = std::shared_ptr<void>(v, [](void* p) { delete static_cast<T*>(p); });
        return x;
    }
    bool ownsPointer() const { return static_cast<bool>(owner); }
};
 
class EVENGINE_API_FOUNDATION Message {
public:
    Message(const std::string& name, const std::vector<Variant>& vargs = {});
    ~Message();
 
    const std::string          name;
    const std::vector<Variant> args;
};
 
class EVENGINE_API_FOUNDATION PlatformEvent : public Module {
public:
    Module_REG(PlatformEvent);
    virtual ~PlatformEvent();
 
    void push(Message* msg);
    void push(std::unique_ptr<Message> msg);
    void pushData(std::string name, std::string data = "");
    Message* poll();
    std::unique_ptr<Message> pollOwned();
    std::string pollName();
    std::string getLastData() const;
    std::string pollData();
    virtual void clear();
 
    void setPollObserver(std::function<void(const Message&)> observer) {
        legacyPollSubscription_.dispose();
        pollObserver_ = std::move(observer);
        if (pollObserver_) legacyPollSubscription_ = pollObservers_.subscribe(pollObserver_);
    }
 
    const std::function<void(const Message&)>& pollObserver() const { return pollObserver_; }
 
    [[nodiscard("retain Subscription or explicitly dispose it")]] eve::Subscription subscribePoll(
        std::function<void(const Message&)> callback);
 
    [[nodiscard]] std::uint64_t pollObserverFailureCount() const noexcept { return pollObserverFailures_; }
 
    virtual void pump() = 0;
    virtual Message* wait() = 0;
    std::unique_ptr<Message> waitOwned() { return std::unique_ptr<Message>(wait()); }
 
protected:
    virtual void wakeWaiters() {}
 
    std::mutex                           queueMu_;
    std::queue<std::unique_ptr<Message>> queue;
    std::string                          lastData_;
    std::function<void(const Message&)>  pollObserver_;
    eve::Observer<Message>               pollObservers_;
    eve::Subscription                    legacyPollSubscription_;
    std::uint64_t                        pollObserverFailures_ = 0;
};
 
}  // namespace platform_event
}  // namespace eve