SingletonHolder.h

Go to the documentation of this file.

#pragma once
 
// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// This code accompanies the book:
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
// Permission to use, copy, modify, distribute and sell this software for any
//     purpose is hereby granted without fee, provided that the above copyright
//     notice appear in all copies and that both that copyright notice and this
//     permission notice appear in supporting documentation.
// The author or Addison-Wesley Longman make no representations about the
//     suitability of this software for any purpose. It is provided "as is"
//     without express or implied warranty.
 
// Simplified from the original code, to just work for simple singletons
// Removed all the code relating to the creation/destruction, threading and
// lifetime policies.
 
#include "MantidKernel/DllConfig.h"
#include <cassert>
#include <cstdlib>
#include <functional>
#include <mutex>
 
namespace Mantid {
namespace Kernel {
 
using SingletonDeleterFn = std::function<void()>;
 
MANTID_KERNEL_DLL void deleteOnExit(const SingletonDeleterFn &func);
 
template <typename T> class SingletonHolder {
public:
  using HeldType = T;
 
  SingletonHolder() = delete;
 
  static T &Instance();
 
private:
#ifndef NDEBUG
  static bool destroyed;
#endif
};
 
// Static field initializers
#ifndef NDEBUG
template <typename T> bool SingletonHolder<T>::destroyed = false;
#endif
 
template <typename T> struct CreateUsingNew {
  static T *create() { return new T; }
  static void destroy(T *p) { delete p; }
};
 
template <typename T>
#if defined(_MSC_VER)
__declspec(noinline)
#endif
    T &
#if defined(__GNUC__) // covers clang too
    __attribute__((noinline))
#endif
    SingletonHolder<T>::Instance() {
  // Initialiazing a local static is thread-safe in C++11
  // The inline lambda call is used to create the singleton once
  // and register an atexit function to delete it
  static T *instance = []() {
    auto local = CreateUsingNew<T>::create();
    deleteOnExit(SingletonDeleterFn([]() {
#ifndef NDEBUG
      destroyed = true;
#endif
      CreateUsingNew<T>::destroy(instance);
    }));
    return local;
  }();
#ifndef NDEBUG
  assert(!destroyed);
#endif
  return *instance;
}
 
} // namespace Kernel
} // namespace Mantid