singleton.hpp

Go to the documentation of this file.

/*******************************************************************************
 * thrill/common/singleton.hpp
 *
 * Copied and modified from STXXL https://github.com/stxxl/stxxl, which is
 * distributed under the Boost Software License, Version 1.0.
 *
 * Part of Project Thrill - http://project-thrill.org
 *
 * Copyright (C) 2002-2004 Roman Dementiev <[email protected]>
 * Copyright (C) 2008-2010 Andreas Beckmann <[email protected]>
 * Copyright (C) 2009, 2010 Johannes Singler <[email protected]>
 *
 * All rights reserved. Published under the BSD-2 license in the LICENSE file.
 ******************************************************************************/

#pragma once
#ifndef THRILL_COMMON_SINGLETON_HEADER
#define THRILL_COMMON_SINGLETON_HEADER

#include <cstdlib>
#include <mutex>

namespace thrill {
namespace common {

template <typename Instance, bool destroy_on_exit = true>
class Singleton
{
    using instance_type = Instance;
    using instance_pointer = instance_type *;
    using volatile_instance_pointer = volatile instance_pointer;

    static volatile_instance_pointer instance_;

    static instance_pointer CreateInstance();
    static void DestroyInstance();

public:
    Singleton() = default;

    //! non-copyable: delete copy-constructor
    Singleton(const Singleton&) = delete;
    //! non-copyable: delete assignment operator
    Singleton& operator = (const Singleton&) = delete;
    //! move-constructor: default
    Singleton(Singleton&&) = default;
    //! move-assignment operator: default
    Singleton& operator = (Singleton&&) = default;

    inline static instance_pointer GetInstance() {
        if (!instance_)
            return CreateInstance();

        return instance_;
    }
};

template <typename Instance, bool destroy_on_exit>
typename Singleton<Instance, destroy_on_exit>::instance_pointer
Singleton<Instance, destroy_on_exit>::CreateInstance() {
    static std::mutex create_mutex;
    std::unique_lock<std::mutex> lock(create_mutex);
    if (!instance_) {
        instance_ = new instance_type();
        if (destroy_on_exit)
            atexit(DestroyInstance);
    }
    return instance_;
}

template <typename Instance, bool destroy_on_exit>
void Singleton<Instance, destroy_on_exit>::DestroyInstance() {
    instance_pointer inst = instance_;
    // instance = nullptr;
    instance_ = reinterpret_cast<instance_pointer>(size_t(-1));     // bomb if used again
    delete inst;
}

template <typename Instance, bool destroy_on_exit>
typename Singleton<Instance, destroy_on_exit>::volatile_instance_pointer
Singleton<Instance, destroy_on_exit>::instance_ = nullptr;

} // namespace common
} // namespace thrill

#endif // !THRILL_COMMON_SINGLETON_HEADER

/******************************************************************************/