RegistryFrontend.h

Go to the documentation of this file.

/* Copyright (c) 2023 Skyward Experimental Rocketry
 * Author: Nicolò Caruso
 *
 * 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 <utils/Debug.h>
 
#include <cstdint>
#include <mutex>
#include <unordered_map>
#include <vector>
 
#include "RegistryBackend.h"
#include "RegistrySerializer.h"
#include "RegistryTypes.h"
 
namespace Boardcore
{
 
class RegistryFrontend
{
public:
    using EntryFunc = std::function<void(ConfigurationId, EntryStructsUnion&)>;
 
    RegistryFrontend(std::unique_ptr<RegistryBackend> backend =
                         std::make_unique<DummyBackend>());
 
    [[nodiscard]] RegistryError start();
 
    void arm();
 
    void disarm();
 
    void forEach(const EntryFunc& predicate);
 
    bool isEntryConfigured(const ConfigurationId configurationIndex);
 
    bool isEmpty();
 
    // TYPE UNSAFE INTERFACE METHODS
 
    template <typename T>
    RegistryError getUnsafe(const ConfigurationId configurationIndex,
                            T& outValue)
    {
        std::lock_guard<std::recursive_mutex> lock(mutexForRegistry);
        auto iterator = configuration.find(configurationIndex);
        if (iterator == configuration.end())
            return RegistryError::ENTRY_NOT_FOUND;
        if (!iterator->second.get(outValue))
            return RegistryError::INCORRECT_TYPE;
        return RegistryError::OK;
    }
    RegistryError getUnsafe(const ConfigurationId configurationIndex, {…}
 
    template <typename T>
    T getOrSetDefaultUnsafe(const ConfigurationId configurationIndex,
                            T defaultValue)
    {
        std::lock_guard<std::recursive_mutex> lock(mutexForRegistry);
        T returnValue;
        if (getUnsafe(configurationIndex, returnValue) == RegistryError::OK)
            return returnValue;
        if (setUnsafe(configurationIndex, defaultValue) != RegistryError::OK)
        {
            LOG_ERR(logger,
                    "Registry - Could not insert the default configuration");
        }
        return defaultValue;
    }
    T getOrSetDefaultUnsafe(const ConfigurationId configurationIndex, {…}
 
    template <typename T>
    RegistryError setUnsafe(ConfigurationId configurationIndex, T value)
    {
        std::lock_guard<std::recursive_mutex> lock(mutexForRegistry);
        /* In case that the configuration is in an armed state it cannot be
         * modified */
        if (isArmed)
            return RegistryError::ARMED;
        EntryStructsUnion entry = EntryStructsUnion::make(value);
        auto insert = configuration.insert({configurationIndex, entry});
        if (!insert.second)
            insert.first->second = entry;
        return RegistryError::OK;
    }
    RegistryError setUnsafe(ConfigurationId configurationIndex, T value) {…}
 
    // LOAD AND SAVE TO BACKEND
 
    RegistryError load();
 
    RegistryError save();
 
    void clear();
 
private:
    std::recursive_mutex mutexForRegistry;
    std::unordered_map<ConfigurationId, EntryStructsUnion> configuration;
    bool isArmed = false;
    std::vector<uint8_t> serializationVector;
    std::unique_ptr<RegistryBackend> backend;
    PrintLogger logger = Logging::getLogger("registry-frontend");
};
class RegistryFrontend {…};
 
}  // namespace Boardcore