DependencyManager.h

Go to the documentation of this file.

/* Copyright (c) 2024 Skyward Experimental Rocketry
 * Author: Davide Mor
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include <diagnostic/PrintLogger.h>
 
#include <map>
#include <numeric>
#include <ostream>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <vector>
 
namespace Boardcore
{
 
int32_t getNextDependencyId();
 
template <typename T>
int32_t getDependencyId()
{
    static int32_t ID = getNextDependencyId();
    return ID;
}
 
class DependencyInjector;
class DependencyManager;
 
class Injectable
{
public:
    virtual ~Injectable() = default;
 
    virtual void inject(DependencyInjector& injector) {}
};
 
class DependencyManager
{
    friend class DependencyInjector;
 
private:
    struct ModuleInfo
    {
        std::string name;  //< Name of the type.
        void* raw;  
        Injectable* injectable;  
        std::vector<int32_t> deps;  
    };
 
public:
    DependencyManager() {}
 
    template <typename T, typename = std::enable_if_t<
                              std::is_base_of<Injectable, T>::value>>
    [[nodiscard]] bool insert(T* dependency)
    {
        return insertImpl(
            getDependencyId<T>(), reinterpret_cast<void*>(dependency),
            static_cast<Injectable*>(dependency), typeid(T).name());
    }
 
    void graphviz(std::ostream& os);
 
    [[nodiscard]] bool inject();
 
private:
    [[nodiscard]] bool insertImpl(int32_t id, void* raw, Injectable* injectable,
                                  const char* name);
 
    void* getImpl(int32_t id);
 
    Boardcore::PrintLogger logger =
        Boardcore::Logging::getLogger("DependencyManager");
 
    bool load_success = true;
    // Maps from interface type name to ModuleInfo
    std::map<int32_t, ModuleInfo> modules;
};
 
class DependencyInjector
{
    friend class DependencyManager;
 
private:
    DependencyInjector(DependencyManager& manager,
                       DependencyManager::ModuleInfo& info)
        : manager(manager), info(info)
    {
    }
 
public:
    template <typename T>
    T* get()
    {
        return reinterpret_cast<T*>(getImpl(getDependencyId<T>()));
    }
 
private:
    void* getImpl(int32_t id);
 
    Boardcore::PrintLogger logger =
        Boardcore::Logging::getLogger("DependencyManager");
 
    DependencyManager& manager;
    DependencyManager::ModuleInfo& info;
};
 
namespace DependencyManagerDetails
{
 
// Storage implementation
template <typename... Types>
struct Storage
{
    // No-op, base case
    void inject(DependencyInjector& injector) {}
 
    // No-op, dummy get (this should never be reached)
    template <typename T>
    T* get()
    {
        return nullptr;
    }
};
 
template <typename Type, typename... Types>
struct Storage<Type, Types...> : public Storage<Types...>
{
    using Super = Storage<Types...>;
 
    // Recursive implementation
    Type* item = nullptr;
 
    void inject(DependencyInjector& injector)
    {
        item = injector.get<Type>();
        // Call parent function
        Super::inject(injector);
    }
 
    template <typename T>
    typename std::enable_if_t<std::is_same<T, Type>::value, T*> get()
    {
        return item;
    }
 
    template <typename T>
    typename std::enable_if_t<!std::is_same<T, Type>::value, T*> get()
    {
        return Super::template get<T>();
    }
};
 
// Find type in list implementation
template <typename T, typename... Types>
struct Contains : std::false_type
{
};
 
template <typename T, typename Type, typename... Types>
struct Contains<T, Type, Types...>
    : std::integral_constant<bool, std::is_same<T, Type>::value ||
                                       Contains<T, Types...>::value>
{
};
 
}  // namespace DependencyManagerDetails
 
template <typename T>
struct InjectableBase
{
};
 
template <typename... Types>
class InjectableWithDeps : public Injectable
{
protected:
    using Super = InjectableWithDeps<Types...>;
 
public:
    virtual void inject(DependencyInjector& injector) override
    {
        storage.inject(injector);
    }
 
    template <typename T,
              typename = std::enable_if_t<
                  DependencyManagerDetails::Contains<T, Types...>::value>>
    T* getModule()
    {
        return storage.template get<T>();
    }
 
private:
    DependencyManagerDetails::Storage<Types...> storage;
};
 
template <typename Base, typename... Types>
class InjectableWithDeps<InjectableBase<Base>, Types...> : public Base
{
protected:
    using Super = InjectableWithDeps<InjectableBase<Base>, Types...>;
 
public:
    using InjectableSuper = Base;
    using Base::Base;  
 
    static_assert(std::is_base_of<Injectable, Base>::value,
                  "Base must be Injectable");
 
    virtual void inject(DependencyInjector& injector) override
    {
        Base::inject(injector);
        storage.inject(injector);
    }
 
    template <typename T,
              typename = std::enable_if_t<
                  DependencyManagerDetails::Contains<T, Types...>::value>>
    T* getModule()
    {
        return storage.template get<T>();
    }
 
private:
    DependencyManagerDetails::Storage<Types...> storage;
};
 
}  // namespace Boardcore