libcruft-util/singleton.hpp

100 lines
2.7 KiB
C++
Raw Normal View History

2018-03-22 15:06:48 +11:00
/*
2018-08-04 15:14:06 +10:00
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
2018-03-22 15:06:48 +11:00
*
* Copyright 2018 Danny Robson <danny@nerdcruft.net>
*/
#pragma once
2018-03-22 15:06:48 +11:00
#include "debug/assert.hpp"
2018-03-22 15:06:48 +11:00
#include <memory>
namespace cruft {
2018-03-27 16:15:54 +11:00
/// statically stores a single value of the named type.
///
/// this does not prevent the instantiation of the named type, but
/// instead defines a method to refer to a single instance across an
/// application.
2018-03-22 15:06:48 +11:00
template <typename SelfT>
class singleton {
private:
singleton () = default;
static SelfT *instance;
public:
static bool
is_valid (void) noexcept
{
return instance;
}
2018-03-27 16:15:54 +11:00
/// instantiates the one blessed value of this type.
///
/// `instantiate` must be called once and once only before any calls
/// to `get`. it is not threadsafe. there are some (unsafe)
/// assertions against multiple instantiations but they may not be
/// relied upon.
///
/// returns a unique_ptr to the value which the caller must store
/// until it will never be needed again.
2018-03-22 15:06:48 +11:00
template <typename ...Args>
static std::unique_ptr<SelfT>
instantiate [[nodiscard]] (Args &&...args)
{
CHECK (!instance);
auto cookie =std::make_unique<SelfT> (std::forward<Args> (args)...);
instance = cookie.get ();
return cookie;
}
2019-05-01 12:31:08 +10:00
/// Swap the stored object pointer for the provided one and return
/// the old value.
///
/// Useful for bypassing `instantiate` by initialising the pointer
/// to a pre-existing object.
///
/// The caller to swap must free any resources associated with the
/// prior value and arrange for the new object to be safely destructed
/// in the future.
static SelfT*
swap (SelfT *next)
{
return std::exchange (instance, next);
}
/// Returns a reference to the instantiated value.
2018-03-27 16:15:54 +11:00
///
/// `instantiate` must have already been called before `get` is called
/// otherwise the results are undefined.
2018-03-22 15:06:48 +11:00
static SelfT&
get (void)
{
2018-03-27 16:15:54 +11:00
CHECK (instance);
2018-03-22 15:06:48 +11:00
return *instance;
}
/// returns a pointer to the instantiated value if it exists, else we
/// return nullptr.
static SelfT*
maybe (void)
{
return instance;
}
2018-03-22 15:06:48 +11:00
};
};
template <typename SelfT>
SelfT*
cruft::singleton<SelfT>::instance;