GpgFunctionObject.h

 
#pragma once
 
#include <mutex>
 
#include "core/GpgFrontendCoreExport.h"
#include "core/function/basic/ChannelObject.h"
#include "core/function/basic/SingletonStorage.h"
#include "core/function/basic/SingletonStorageCollection.h"
#include "core/utils/MemoryUtils.h"
 
namespace GpgFrontend {
 
auto GPGFRONTEND_CORE_EXPORT GetChannelObjectInstance(
    const std::type_info& type, int channel) -> ChannelObject*;
 
auto GPGFRONTEND_CORE_EXPORT CreateChannelObjectInstance(
    const std::type_info& type, int channel,
    SecureUniquePtr<ChannelObject> channel_object) -> ChannelObject*;
 
auto GPGFRONTEND_CORE_EXPORT
GetGlobalFunctionObjectTypeLock(const std::type_info& type) -> std::mutex&;
 
template <typename T>
class SingletonFunctionObject : public ChannelObject {
 public:
  SingletonFunctionObject(const SingletonFunctionObject<T>&) = delete;
 
  auto operator=(const SingletonFunctionObject<T>&)
      -> SingletonFunctionObject& = delete;
 
  static auto GetInstance(int channel = GpgFrontend::kGpgFrontendDefaultChannel)
      -> T& {
    static_assert(std::is_base_of_v<SingletonFunctionObject<T>, T>,
                  "T not derived from SingletonFunctionObject<T>");
 
    const auto& type = typeid(T);
    std::lock_guard<std::mutex> guard(GetGlobalFunctionObjectTypeLock(type));
    auto* channel_object = GetChannelObjectInstance(type, channel);
    if (channel_object == nullptr) {
      channel_object = CreateChannelObjectInstance(
          type, channel,
          ConvertToChannelObjectPtr(SecureCreateUniqueObject<T>(channel)));
    }
    return *static_cast<T*>(channel_object);
  }
 
  static auto CreateInstance(
      int channel, const std::function<ChannelObjectPtr(void)>& factory) -> T& {
    static_assert(std::is_base_of_v<SingletonFunctionObject<T>, T>,
                  "T not derived from SingletonFunctionObject<T>");
 
    const auto& type = typeid(T);
    std::lock_guard<std::mutex> guard(GetGlobalFunctionObjectTypeLock(type));
    return *static_cast<T*>(
        CreateChannelObjectInstance(type, channel, factory()));
  }
 
  static void ReleaseChannel(int channel) {
    SingletonStorageCollection::GetInstance(false)
        ->GetSingletonStorage(typeid(T))
        ->ReleaseChannel(channel);
  }
 
  static auto GetDefaultChannel() -> int {
    return ChannelObject::GetDefaultChannel();
  }
 
  [[nodiscard]] auto GetChannel() const -> int {
    return ChannelObject::GetChannel();
  }
 
  static auto GetAllChannelId() -> std::vector<int> {
    return SingletonStorageCollection::GetInstance(false)
        ->GetSingletonStorage(typeid(T))
        ->GetAllChannelId();
  }
 
  SingletonFunctionObject(T&&) = delete;
 
  SingletonFunctionObject(const T&) = delete;
 
  void operator=(const T&) = delete;
 
 protected:
  SingletonFunctionObject() = default;
 
  explicit SingletonFunctionObject(int channel)
      : ChannelObject(channel, typeid(T).name()) {}
 
  virtual ~SingletonFunctionObject() = default;
};
}  // namespace GpgFrontend