Factory.h

Go to the documentation of this file.

// Factory.h
#pragma once
#include <json.hpp>
#include <map>
#include <memory>
#include <typeindex>
 
namespace EngineCore {
    class Serializable; // Forward declaration
 
    // Forward declare Registrar as a template
    template<typename T>
    struct Registrar;
 
    class Factory {
    public:
        using CreateFunction = std::function<std::unique_ptr<Serializable>()>;
        using JsonFactory = std::function<nlohmann::json()>;
 
        static void registerType(const std::string& typeName, CreateFunction creator, JsonFactory jsonFactory) {
            getCreators()[typeName] = creator;
            getJsonFactories()[typeName] = jsonFactory;
        }
 
        // Templated create function
        template<typename T = Serializable>
        static std::unique_ptr<T> create(const std::string& typeName) {
            static_assert(std::is_base_of<Serializable, T>::value, "T must be derived from Serializable");
 
            auto it = getCreators().find(typeName);
            if (it != getCreators().end()) {
                // Create a unique_ptr to Serializable
                std::unique_ptr<Serializable> basePtr = it->second();
                if constexpr (std::is_same_v<T, Serializable>) {
                    // If T is Serializable, return as is
                    return std::unique_ptr<T>(basePtr.release());
                } else {
                    // Attempt to dynamic_cast to T
                    T* derivedPtr = dynamic_cast<T*>(basePtr.get());
                    if (derivedPtr) {
                        // Release ownership from basePtr and assign to derivedPtr
                        basePtr.release();
                        return std::unique_ptr<T>(derivedPtr);
                    } else {
                        // Casting failed
                        return nullptr;
                    }
                }
            }
            return nullptr;
        }
 
        static nlohmann::json createJson(const std::string& typeName) {
            auto it = getJsonFactories().find(typeName);
            if (it != getJsonFactories().end()) {
                return it->second();
            }
            return nlohmann::json();
        }
 
        static const std::vector<std::string>& getRegisteredTypes() {
            return getTypesList();
        }
 
    private:
        // Static accessor methods for the containers
        static std::map<std::string, CreateFunction>& getCreators() {
            static std::map<std::string, CreateFunction> creators;
            return creators;
        }
 
        static std::map<std::string, JsonFactory>& getJsonFactories() {
            static std::map<std::string, JsonFactory> jsonFactories;
            return jsonFactories;
        }
 
        static std::vector<std::string>& getTypesList() {
            static std::vector<std::string> registeredTypes;
            return registeredTypes;
        }
 
        // Static method to add type to registered types list
        static void addRegisteredType(const std::string& typeName) {
            getTypesList().push_back(typeName);
        }
 
        template<typename T>
        friend class Registrar;
    };
 
    // Helper template to get demangled type name
    template<typename T>
    std::string getTypeName() {
        return typeid(T).name();
    }
}