GlobalModuleContext.h

 
#pragma once
 
#include <optional>
 
#include "core/module/Event.h"
#include "core/thread/TaskRunner.h"
#include "function/SecureMemoryAllocator.h"
#include "module/GlobalRegisterTable.h"
 
namespace GpgFrontend::Module {
 
class GlobalModuleContext;
class GlobalRegisterTable;
 
class Module;
class ModuleManager;
using ModuleIdentifier = QString;
using ModulePtr = std::shared_ptr<Module>;
using ModuleRawPtr = Module*;
 
using GMCPtr = std::shared_ptr<GlobalModuleContext>;
using GRTPtr = std::shared_ptr<GlobalRegisterTable>;
 
using TaskRunnerPtr = std::shared_ptr<Thread::TaskRunner>;
 
class GPGFRONTEND_CORE_EXPORT GlobalModuleContext : public QObject {
  Q_OBJECT
 public:
  explicit GlobalModuleContext();
 
  ~GlobalModuleContext() override;
 
  auto SearchModule(ModuleIdentifier) -> ModulePtr;
 
  auto GetChannel(ModuleRawPtr) -> int;
 
  static auto GetDefaultChannel(ModuleRawPtr) -> int;
 
  auto GetTaskRunner(ModuleRawPtr) -> std::optional<TaskRunnerPtr>;
 
  auto GetTaskRunner(ModuleIdentifier) -> std::optional<TaskRunnerPtr>;
 
  auto GetGlobalTaskRunner() -> std::optional<TaskRunnerPtr>;
 
  auto RegisterModule(ModulePtr, bool) -> bool;
 
  auto ActiveModule(ModuleIdentifier) -> bool;
 
  auto DeactivateModule(ModuleIdentifier) -> bool;
 
  auto ListenEvent(ModuleIdentifier, EventIdentifier) -> bool;
 
  auto TriggerEvent(EventRefrernce) -> bool;
 
  auto SearchEvent(EventTriggerIdentifier) -> std::optional<EventRefrernce>;
 
  auto GetModuleListening(ModuleIdentifier) -> QList<EventIdentifier>;
 
  auto IsModuleActivated(ModuleIdentifier) -> bool;
 
  auto IsIntegratedModule(ModuleIdentifier) -> bool;
 
  auto ListAllRegisteredModuleID() -> QList<ModuleIdentifier>;
 
 private:
  class Impl;
  SecureUniquePtr<Impl> p_;
};
 
}  // namespace GpgFrontend::Module