fw_factory.hpp

 
#pragma once
 
#include <radio_tool/fw/fw.hpp>
#include <radio_tool/fw/tyt_fw.hpp>
#include <radio_tool/fw/tyt_fw_sgl.hpp>
#include <radio_tool/fw/cs_fw.hpp>
#include <radio_tool/fw/ailunce_fw.hpp>
#include <radio_tool/fw/yaesu_fw.hpp>
 
#include <string>
#include <memory>
#include <functional>
 
namespace radio_tool::fw
{
    class FirmwareSupportTest
    {
    public:
        FirmwareSupportTest(
            std::function<bool(const std::string &)> &&fnFile,
            std::function<bool(const std::string &)> &&fnRadio,
            std::function<std::unique_ptr<FirmwareSupport>()> &&fnCreate
        ) : SupportsFirmwareFile(fnFile), SupportsRadioModel(fnRadio), CreateHandler(fnCreate)
        {
 
        }
        const std::function<bool(const std::string &)> SupportsFirmwareFile;
 
        const std::function<bool(const std::string &)> SupportsRadioModel;
 
        const std::function<std::unique_ptr<FirmwareSupport>()> CreateHandler;
    };
 
    const std::vector<FirmwareSupportTest> AllFirmwareHandlers = {
        FirmwareSupportTest(TYTFW::SupportsFirmwareFile, TYTFW::SupportsRadioModel, TYTFW::Create),
        FirmwareSupportTest(CSFW::SupportsFirmwareFile, CSFW::SupportsRadioModel, CSFW::Create),
        FirmwareSupportTest(TYTSGLFW::SupportsFirmwareFile, TYTSGLFW::SupportsRadioModel, TYTSGLFW::Create),
        /* Below supports random files - no checks */
        FirmwareSupportTest(YaesuFW::SupportsFirmwareFile, YaesuFW::SupportsRadioModel, YaesuFW::Create),
        FirmwareSupportTest(AilunceFW::SupportsFirmwareFile, AilunceFW::SupportsRadioModel, AilunceFW::Create)
    };
 
    class FirmwareFactory
    {
    public:
        static auto GetFirmwareFileHandler(const std::string &file) -> std::unique_ptr<FirmwareSupport>
        {
            for (const auto &fn : AllFirmwareHandlers)
            {
                if (fn.SupportsFirmwareFile(file))
                {
                    return fn.CreateHandler();
                }
            }
            throw std::runtime_error("Firmware file not supported");
        }
 
        static auto GetFirmwareModelHandler(const std::string &model) -> std::unique_ptr<FirmwareSupport>
        {
            for (const auto &fn : AllFirmwareHandlers)
            {
                if (fn.SupportsRadioModel(model))
                {
                    return fn.CreateHandler();
                }
            }
            throw std::runtime_error("Firmware model not supported");
        }
    };
} // namespace radio_tool::fw