ModuleManager.h

 
#pragma once
 
#include <mutex>
#include <vector>
 
#include "core/function/SecureMemoryAllocator.h"
#include "core/function/basic/GpgFunctionObject.h"
#include "core/module/Event.h"
#include "core/utils/MemoryUtils.h"
 
namespace GpgFrontend::Thread {
class TaskRunner;
}
 
namespace GpgFrontend::Module {
 
using TaskRunnerPtr = std::shared_ptr<Thread::TaskRunner>;
 
class Event;
class Module;
class GlobalModuleContext;
class ModuleManager;
 
using EventRefrernce = std::shared_ptr<Event>;
using ModuleIdentifier = QString;
using ModulePtr = std::shared_ptr<Module>;
using ModuleMangerPtr = std::shared_ptr<ModuleManager>;
using GMCPtr = std::shared_ptr<GlobalModuleContext>;
using Namespace = QString;
using Key = QString;
using LPCallback = std::function<void(Namespace, Key, int, std::any)>;
 
class GPGFRONTEND_CORE_EXPORT ModuleManager
    : public SingletonFunctionObject<ModuleManager> {
 public:
  explicit ModuleManager(int channel);
 
  virtual ~ModuleManager() override;
 
  void RegisterModule(ModulePtr);
 
  auto IsModuleActivated(ModuleIdentifier) -> bool;
 
  void TriggerEvent(EventRefrernce);
 
  void ActiveModule(ModuleIdentifier);
 
  void DeactiveModule(ModuleIdentifier);
 
  auto GetTaskRunner(ModuleIdentifier) -> std::optional<TaskRunnerPtr>;
 
  auto UpsertRTValue(Namespace, Key, std::any) -> bool;
 
  auto RetrieveRTValue(Namespace, Key) -> std::optional<std::any>;
 
  auto ListenRTPublish(QObject*, Namespace, Key, LPCallback) -> bool;
 
  auto ListRTChildKeys(const QString&, const QString&) -> std::vector<Key>;
 
 private:
  class Impl;
  SecureUniquePtr<Impl> p_;
};
 
template <typename T, typename... Args>
void RegisterModule(Args&&... args) {
  ModuleManager::GetInstance().RegisterModule(
      GpgFrontend::SecureCreateSharedObject<T>(std::forward<Args>(args)...));
}
 
template <typename T, typename... Args>
void RegisterAndActivateModule(Args&&... args) {
  auto& manager = ModuleManager::GetInstance();
  auto module =
      GpgFrontend::SecureCreateSharedObject<T>(std::forward<Args>(args)...);
  manager.RegisterModule(module);
  manager.ActiveModule(module->GetModuleIdentifier());
}
 
template <typename... Args>
void TriggerEvent(const EventIdentifier& event_id, Args&&... args,
                  Event::EventCallback e_cb = nullptr) {
  ModuleManager::GetInstance().TriggerEvent(
      std::move(MakeEvent(event_id, std::forward<Args>(args)..., e_cb)));
}
 
auto GPGFRONTEND_CORE_EXPORT IsModuleAcivate(ModuleIdentifier) -> bool;
 
auto GPGFRONTEND_CORE_EXPORT UpsertRTValue(const QString& namespace_,
                                           const QString& key,
                                           const std::any& value) -> bool;
 
auto GPGFRONTEND_CORE_EXPORT ListenRTPublishEvent(QObject*, Namespace, Key,
                                                  LPCallback) -> bool;
 
auto GPGFRONTEND_CORE_EXPORT ListRTChildKeys(const QString& namespace_,
                                             const QString& key)
    -> std::vector<Key>;
 
template <typename T>
auto RetrieveRTValueTyped(const QString& namespace_, const QString& key)
    -> std::optional<T> {
  auto any_value =
      ModuleManager::GetInstance().RetrieveRTValue(namespace_, key);
  if (any_value && any_value->type() == typeid(T)) {
    return std::any_cast<T>(*any_value);
  }
  return std::nullopt;
}
 
template <typename T>
auto RetrieveRTValueTypedOrDefault(const QString& namespace_,
                                   const QString& key, const T& defaultValue)
    -> T {
  auto any_value =
      ModuleManager::GetInstance().RetrieveRTValue(namespace_, key);
  if (any_value && any_value->type() == typeid(T)) {
    return std::any_cast<T>(*any_value);
  }
  return defaultValue;
}
 
}  // namespace GpgFrontend::Module