GpgFunctionObject.h

 
#ifndef GPGFRONTEND_ZH_CN_TS_FUNCTIONOBJECT_H
#define GPGFRONTEND_ZH_CN_TS_FUNCTIONOBJECT_H
 
#include <mutex>
 
#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 std::mutex g_channel_mutex_map_lock;
    static std::map<int, std::mutex> g_channel_mutex_map;
 
    {
      std::lock_guard<std::mutex> guard(g_channel_mutex_map_lock);
      if (g_channel_mutex_map.find(channel) == g_channel_mutex_map.end()) {
        g_channel_mutex_map[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) {
      // lock this channel
      std::lock_guard<std::mutex> guard(g_channel_mutex_map[channel]);
 
      // double check
      if ((_p_pbj = (T*)(p_storage->FindObjectInChannel(channel))) != nullptr)
        return *_p_pbj;
 
      // do create object of this channel
      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