𝗦𝘁𝗼𝗿𝗶𝗻𝗴 𝗔𝗻𝘆 𝗢𝗯𝗷𝗲𝗰𝘁 𝗶𝗻 𝗮 𝗖𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝚟𝚘𝚒𝚍* 𝗼𝗿 𝗛𝗶𝗲𝗿𝗮𝗿𝗰𝗵𝗶𝗲𝘀

SingletonContainer.cpp

/*
 If you're looking to store any type of object in a container without using 𝚟𝚘𝚒𝚍* 
 or creating a new hierarchy, 𝚜𝚝𝚍::𝚊𝚗𝚢 might be a good choice. 
 It can store any type, but retrieving the stored value requires caution, 
 as you need to know the type to use 𝚜𝚝𝚍::𝚊𝚗𝚢_𝚌𝚊𝚜𝚝 effectively.
 One useful application for this approach is an object storage class that maintains 
 a list of singletons. This class, 𝚂𝚒𝚗𝚐𝚕𝚎𝚝𝚘𝚗𝚂𝚝𝚘𝚛𝚊𝚐𝚎, 
 offers a 𝚐𝚎𝚝 method that either returns an existing object or creates
 a new one if it doesn’t exist. Internally, 
 𝚂𝚒𝚗𝚐𝚕𝚎𝚝𝚘𝚗𝚂𝚝𝚘𝚛𝚊𝚐𝚎 uses a hash map with 𝚜𝚝𝚍::𝚝𝚢𝚙𝚎_𝚒𝚗𝚍𝚎𝚡 as the key and 𝚜𝚝𝚍::𝚊𝚗𝚢 as the value.
 Check the code below for more details.  
 The example below depicts a SingletonStorage that is created upon the first request for an object. 
 Note that stored objects should have a copy constructor. 
 However, if a noexcept move constructor is present, it will be used to move the created value into the 𝑠𝑡𝑑::𝑎𝑛𝑦.
*/
#include <iostream>
#include <unordered_map>
#include <any>
#include <typeindex>
#include <memory>
#include <stdexcept>
#include <mutex>

class SingletonStorage {
public:
    // Template method to get or create an instance of the specified type
    template <typename T>
    T& get() {
        std::type_index typeIndex(typeid(T));

        // Check if the object already exists
        auto it = storage.find(typeIndex);
        if (it != storage.end()) {
            // Retrieve and cast the stored object
            return std::any_cast<T&>(it->second);
        }

        // Create a new instance if not found
        // noexcept move constructor will be used, but type should be copieable
        auto insert = storage.emplace(typeIndex, std::make_any<T>());

        // Return a reference
        return std::any_cast<T&>(insert.first->second);
    }

    // Delete copy and assignment operators to ensure singleton behavior
    SingletonStorage(const SingletonStorage&) = delete;
    SingletonStorage& operator=(const SingletonStorage&) = delete;

    static SingletonStorage& instance() {
        static SingletonStorage instance;
        return instance;
    }

private:
    SingletonStorage() = default;

    std::unordered_map<std::type_index, std::any> storage;  // Map of type-indexed singletons
};

// Example classes to be managed by SingletonStorage
class MyClass1 {
public:
    void display() const {
        std::cout << "MyClass1 instance\n";
    }
};

class MyClass2 {
public:
    void show() const {
        std::cout << "MyClass2 instance\n";
    }
};

int main() {
    // Retrieve and use instances of MyClass1 and MyClass2 from SingletonStorage
    auto& obj1 = SingletonStorage::instance().get<MyClass1>();
    auto& obj2 = SingletonStorage::instance().get<MyClass2>();

    obj1.display();  // Output: MyClass1 instance
    obj2.show();     // Output: MyClass2 instance

    // Retrieve the same instances again to verify singleton behavior
    auto& sameObj1 = SingletonStorage::instance().get<MyClass1>();
    auto& sameObj2 = SingletonStorage::instance().get<MyClass2>();

    // The same instances are used, so no new output
    sameObj1.display();  // Output: MyClass1 instance
    sameObj2.show();     // Output: MyClass2 instance

    return 0;
}