ModuleManager.hpp

Go to the documentation of this file.

/* Copyright (c) 2022 Skyward Experimental Rocketry
 * Authors: Matteo Pignataro, 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 <Singleton.h>
#include <assert.h>
#include <stdint.h>
#include <utils/Debug.h>
 
#include <array>
#include <atomic>
 
namespace Boardcore
{
class Module
{
public:
    virtual ~Module() = default;
};
 
class ModuleManager : public Singleton<ModuleManager>
{
    friend class Singleton<ModuleManager>;
 
public:
    ModuleManager() {}
 
    ~ModuleManager()
    {
        // Delete all the modules to avoid memory leaks
        for (size_t i = 0; i < MODULES_NUMBER; i++)
        {
            // It is okay to have nullptr in delete
            delete modules[i];
        }
    }
 
    template <typename T>
    [[nodiscard]] bool insert(T *element)
    {
        // Verify that T is a subclass of module
        static_assert(std::is_base_of<Module, T>(),
                      "Class must be subclass of Module");
        static_assert((std::is_same<Module, T>() == false),
                      "Class must be subclass of Module and not Module itself");
 
        if (!insertionAcceptance)
        {
            assert(false &&
                   "Cannot insert any other module after first get() call");
            return false;
        }
 
        // Take the module type id
        size_t id = getId<T>();
 
        // This is the case in which the last slot is being occupied, so a
        // failure is returned
        if (id == MODULES_NUMBER)
        {
            return false;
        }
 
        // The module is added if only a module of the same subclass hasn't
        // already been added
        if (modules[id] == nullptr)
        {
            modules[id] = element;
            return true;
        }
        return false;
    }
 
    template <class T>
    T *get()
    {
        // Verify that T is a subclass of module but not actually a strict
        // Module
        static_assert(std::is_base_of<Module, T>(),
                      "Class must be subclass of Module");
        static_assert((std::is_same<Module, T>() == false),
                      "Class must be subclass of Module and not Module itself");
 
        // Inhibit further insertions
        insertionAcceptance = false;
 
        // Retrieve the module type id
        size_t id = getId<T>();
 
        // If the module is actually present, returns it by downcasting the
        // object. It can be done because at every type, a unique id is assigned
        if (modules[id] != nullptr)
        {
            return dynamic_cast<T *>(modules[id]);
        }
 
        // Fail if the module hasn't been added before
        assert(false && "Get of a non previously inserted module");
        return nullptr;
    }
 
private:
    static constexpr size_t MODULES_NUMBER = 256;
 
    std::array<Module *, MODULES_NUMBER> modules = {nullptr};
 
    std::atomic<bool> insertionAcceptance{true};
 
    size_t getNextId()
    {
        // Static variable, initialized only the first time
        static size_t currentId = 0;
 
        if (currentId == MODULES_NUMBER)
        {
            return MODULES_NUMBER;
        }
        currentId++;
        return currentId;
    }
 
    template <typename T>
    size_t getId()
    {
        // This thing works because a new static variable newId is created for
        // every type T and the initial assignment is "called" only when the
        // static variable is created
        static size_t newId = getNextId();
        return newId;
    }
};
}  // namespace Boardcore