EXT C++ Library - single

The ext::single wraps a type in a singleton-like style to provide an access to a global instance of the type from anywhere in a program. Yet, like in a singletons, the instance of the type is created only when required.

---

Details:

The oprator -> is used to access the instance of the type. It is not important if the ext::single is local, global or has a dynamic storage, it always points to one common instance of T.

Interface:

template <typename T, template <typename> class P = ext::single_destroyable_policy>
class ext::single {
    public:
        inline T * operator -> ();
};

template <typename T> class ext::single_destroyable_policy;
template <typename T> class ext::single_nondestroyed_policy;


• typename T
  T is the underlying (wrapped) type.
• template <typename> class P
  P is one of the policy classes available for ext::single.
  
  • ext::single_destroyable_policy (default) policy uses lib::atexit to destroy the instance when no longer needed, yet can be revived when needed during destruction.
  • ext::single_nondestroyed_policy causes that no destruction occurs at all and the result is undefined. In most cases the operating system reclaims all resources when the program terminates.
• ext::single::operator -> ();
  References the global object of type T. If the object does not exists at the time of the call, it is created (or re-created) using operator new before returning.

Examples:

#include <ext/c++>

// ...

// somewhere in project:
ext::single <app::log> () -> printf (/* ... */);

// ...


Remarks

Note that the construction and destruction of the wrapped type are not thread-safe. The user may need to implement own operator new and operator delete to ensure thread-safety if required.

---

[index]