The singleton::Class is a base, template class, that allows its extension to behave following the design pattern with same name.
A singleton::Class will have at most one active instance at a time, and this instance will be destroyed when all references to it are released: this is achieved through a specific pointer, the singleton::InstanceReference, whose constructions and destructions will keep an up-to-date reference count of the single instance: when the count reaches zero, the instance is destroyed.
Derived classes of singleton::Class should keep their constructors private, just letting the singleton::Class::getInstance methods access it to ensure that the instance is correctly managed just by singleton::InstanceReference(s).
This is a different kind of singleton: as for singleton::Class, we will have just a single active instance of the class at a time, and we will obtain a reference (in the C++ meaning of the word) just through the singleton::Persisten::getInstance method: the difference is that none will ever deallocate this instance during the program life cycle. Deallocation will be performed at application shutdown during by the static deallocation C++ handler, since instances are kept into class-level (class-static) Ptr::Scoped, whose de-constructors will be called at that time.
So beware of dependencies between Persistent(s), since static deallocation order is unpredictable.