GpgFunctionObject.h

 
#ifndef GPGFRONTEND_ZH_CN_TS_FUNCTIONOBJECT_H
#define GPGFRONTEND_ZH_CN_TS_FUNCTIONOBJECT_H
 
#include "GpgConstants.h"
 
namespace GpgFrontend {
 
class GPGFRONTEND_CORE_EXPORT ChannelObject {
 public:
  ChannelObject() noexcept;
 
  ChannelObject(int channel);
 
  static int GetDefaultChannel();
 
  [[nodiscard]] int GetChannel() const;
 
  void SetChannel(int channel);
 
 private:
  int channel_ = _default_channel;            
  static constexpr int _default_channel = 0;  
};
 
class GPGFRONTEND_CORE_EXPORT SingletonStorage {
 public:
  void ReleaseChannel(int channel);
 
  ChannelObject* FindObjectInChannel(int channel);
 
  std::vector<int> GetAllChannelId();
 
  ChannelObject* SetObjectInChannel(int channel,
                                    std::unique_ptr<ChannelObject> p_obj);
 
 private:
  std::shared_mutex instances_mutex_;  
  std::map<int, std::unique_ptr<ChannelObject>>
      instances_map_;  
};
 
class GPGFRONTEND_CORE_EXPORT SingletonStorageCollection {
 public:
  static SingletonStorageCollection* GetInstance(bool force_refresh);
 
  SingletonStorage* GetSingletonStorage(const std::type_info&);
 
 private:
  std::shared_mutex storages_mutex_;  
  std::map<size_t, std::unique_ptr<SingletonStorage>> storages_map_;
};
template <typename T>
class SingletonFunctionObject : public ChannelObject {
 public:
  SingletonFunctionObject(const SingletonFunctionObject<T>&) = delete;
 
  SingletonFunctionObject& operator=(const SingletonFunctionObject<T>&) =
      delete;
 
  static T& GetInstance(
      int channel = GpgFrontend::GPGFRONTEND_DEFAULT_CHANNEL) {
    static_assert(std::is_base_of<SingletonFunctionObject<T>, T>::value,
                  "T not derived from SingletonFunctionObject<T>");
 
    auto p_storage =
        SingletonStorageCollection::GetInstance(false)->GetSingletonStorage(
            typeid(T));
 
    auto* _p_pbj = (T*)(p_storage->FindObjectInChannel(channel));
 
    if (_p_pbj == nullptr) {
      auto new_obj = std::unique_ptr<ChannelObject>(new T(channel));
      return *(T*)(p_storage->SetObjectInChannel(channel, std::move(new_obj)));
    } else {
      return *_p_pbj;
    }
  }
 
  static T& CreateInstance(
      int channel,
      std::function<std::unique_ptr<ChannelObject>(void)> factory) {
    static_assert(std::is_base_of<SingletonFunctionObject<T>, T>::value,
                  "T not derived from SingletonFunctionObject<T>");
 
    auto p_storage =
        SingletonStorageCollection::GetInstance(false)->GetSingletonStorage(
            typeid(T));
 
    auto _p_pbj = (T*)(p_storage->FindObjectInChannel(channel));
 
    if (_p_pbj == nullptr) {
      return *(
          T*)(p_storage->SetObjectInChannel(channel, std::move(factory())));
    } else
      return *_p_pbj;
  }
 
  static void ReleaseChannel(int channel) {
    SingletonStorageCollection::GetInstance(false)
        ->GetSingletonStorage(typeid(T))
        ->ReleaseChannel(channel);
  }
 
  static int GetDefaultChannel() { return ChannelObject::GetDefaultChannel(); }
 
  [[nodiscard]] int GetChannel() const { return ChannelObject::GetChannel(); }
 
  static std::vector<int> GetAllChannelId() {
    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) {}
 
  virtual ~SingletonFunctionObject() = default;
};
}  // namespace GpgFrontend
 
#endif  // GPGFRONTEND_ZH_CN_TS_FUNCTIONOBJECT_H