WeakSingleton.h

#ifndef PROFILER_SRC_MOLPRO_PROFILER_TREE_SINGLE_H
#define PROFILER_SRC_MOLPRO_PROFILER_TREE_SINGLE_H
 
#include "Profiler.h"
 
#include <algorithm>
#include <cassert>
#include <list>
#include <memory>
#include <string>
#include <mutex>
 
namespace molpro {
namespace profiler {
 
// FIXME improve description
template <class Object>
struct WeakSingleton {
 
  using key_t = std::tuple<std::string, std::weak_ptr<Object>, Object*>;
 
  template <typename... T>
  static std::shared_ptr<Object> single(const std::string& key, T&&... constructor_args) {
    std::lock_guard<decltype(WeakSingleton::s_reg_lock)> lock(s_reg_lock);
    std::shared_ptr<Object> result = nullptr;
    auto& reg = registry();
    auto it = std::find_if(begin(reg), end(reg), [&key](const key_t& el) { return std::get<0>(el) == key; });
    if (it != reg.end())
      result = std::get<1>(*it).lock();
    if (!result) {
      result = std::make_shared<Object>(std::forward<T>(constructor_args)...);
      reg.emplace_back(key_t{key, result, result.get()});
    }
    return result;
  }
 
  static std::shared_ptr<Object> single() {
    std::lock_guard<decltype(WeakSingleton::s_reg_lock)> lock(s_reg_lock);
    auto& reg = registry();
    std::shared_ptr<Object> instance = reg.empty() ? nullptr : std::get<1>(reg.back()).lock();
    if (not instance) { // default zero-depth instance
      auto result = Profiler::single("default");
      result->set_max_depth(0);
      // It is our job to keep the default instance alive by always retaining a shared_ptr
      // to it. This way, callers don't have to manage the default instance's lifetime.
      default_instance_saver() = result;
      return result;
    }
    return instance;
  }
 
  static void erase(Object* obj) {
    std::lock_guard<decltype(WeakSingleton::s_reg_lock)> lock(s_reg_lock);
    auto& reg = registry();
    auto it = std::find_if(begin(reg), end(reg), [obj](const key_t& el) { return std::get<2>(el) == obj; });
    if (it != reg.end())
      reg.erase(it);
  }
 
  static void erase(const std::string& key) {
    std::lock_guard<decltype(WeakSingleton::s_reg_lock)> lock(s_reg_lock);
    auto& reg = registry();
    auto it = std::find_if(begin(reg), end(reg), [&key](const key_t& el) { return std::get<0>(el) == key; });
    if (it != reg.end())
      reg.erase(it);
  }
 
  static void clear() {
    std::lock_guard<decltype(WeakSingleton::s_reg_lock)> lock(s_reg_lock);
    registry().clear();
  }
 
private:
  static std::recursive_mutex s_reg_lock;
 
  static std::list<key_t>& registry() {
    static std::list<key_t> reg;
    return reg;
  }
 
  static std::shared_ptr<Object>& default_instance_saver() {
    static std::shared_ptr<Object> saver;
    return saver;
  }
};
 
template <class Object>
std::recursive_mutex WeakSingleton<Object>::s_reg_lock;
 
 
} // namespace profiler
} // namespace molpro
#endif // PROFILER_SRC_MOLPRO_PROFILER_TREE_SINGLE_H