Event.h

 
#pragma once
 
#include <any>
#include <functional>
#include <optional>
 
#include "core/GpgFrontendCore.h"
#include "core/model/DataObject.h"
#include "module/sdk/GFSDKModule.h"
 
namespace GpgFrontend::Module {
 
class Event;
 
using EventReference = std::shared_ptr<Event>;
using EventIdentifier = QString;
using EventTriggerIdentifier = QString;
using Evnets = std::vector<Event>;
 
class GPGFRONTEND_CORE_EXPORT Event {
 public:
  using ParameterValue = std::any;
  using EventIdentifier = QString;
  using ListenerIdentifier = QString;
  using EventCallback =
      std::function<void(EventIdentifier, ListenerIdentifier, DataObjectPtr)>;
  struct ParameterInitializer {
    QString key;
    QString value;
  };
 
  explicit Event(const QString&,
                 std::initializer_list<ParameterInitializer> = {},
                 EventCallback = nullptr);
 
  ~Event();
 
  auto operator[](const QString& key) const -> std::optional<ParameterValue>;
 
  auto operator==(const Event& other) const -> bool;
 
  auto operator!=(const Event& other) const -> bool;
 
  auto operator<(const Event& other) const -> bool;
 
  auto operator<=(const Event& other) const -> bool;
 
  explicit operator QString() const;
 
  auto GetIdentifier() -> EventIdentifier;
 
  auto GetTriggerIdentifier() -> EventTriggerIdentifier;
 
  void AddParameter(const QString& key, const QString& value);
 
  void ExecuteCallback(ListenerIdentifier, DataObjectPtr);
 
  auto ToModuleEvent() -> GFModuleEvent*;
 
 private:
  class Impl;
  SecureUniquePtr<Impl> p_;
};
 
template <typename... Args>
auto MakeEvent(const EventIdentifier& event_id, Args&&... args,
               Event::EventCallback e_cb) -> EventReference {
  std::initializer_list<Event::ParameterInitializer> params = {
      Event::ParameterInitializer{std::forward<Args>(args)}...};
  return GpgFrontend::SecureCreateSharedObject<Event>(event_id, params, e_cb);
}
 
}  // namespace GpgFrontend::Module