parameter.hpp

/**************************************************************************************************
 * Copyright (c) 2023-2025 NWSOFT                                                                 *
 *                                                                                                *
 * 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 "output.hpp"
#include "platform.hpp"
 
#include <algorithm>
#include <any>
#include <string>
#include <utility>
#include <vector>
 
using namespace std::literals;

namespace steppable::__internals::parameter
{
    struct ValuedParameter
    {
        std::string name; 
        std::any value; 
    };

    using ValueMap = std::vector<ValuedParameter>;

    struct Parameter // NOLINT(cppcoreguidelines-special-member-functions)
    {
        std::string name; 

        template<typename T>
        ValuedParameter operator=(T value) // NOLINT(cppcoreguidelines-c-copy-assignment-signature)
        {
            return { .name = name, .value = std::move(value) };
        }
 
        Parameter& operator=(const Parameter&) = delete;

        explicit Parameter(std::string name) : name(std::move(name)) {}
    };

    struct ParameterMap
    {
        ValueMap values; 

        ParameterMap(ValueMap values) : values(std::move(values)) {}

        void checkParameterOrder(const std::vector<std::string>& names);

        void checkParameterNameUnordered(const std::vector<std::string>& names);

        template<typename ValueT>
        ValueT getItem(const std::string& name)
        {
            ValuedParameter value;
            for (const auto& obj : values)
                if (obj.name == name)
                    value = obj;
            if (value.name == "")
            {
                output::error("ParameterMap::getItem"s, "Name {0} not found."s, { name });
                utils::programSafeExit(1);
            }
            return std::any_cast<ValueT>(value.value);
        }

        template<typename ValueT>
        ValueT getItem(const std::string& name, const ValueT& fallback)
        {
            ValuedParameter value;
            for (const auto& obj : values)
                if (obj.name == name)
                    value = obj;
            if (value.name == "")
                return fallback;
            return std::any_cast<ValueT>(value.value);
        }
    };

    inline Parameter operator""_p(const char* name, size_t /*unused*/) { return Parameter(name); }

    template<typename... Params>
    ParameterMap processParams(Params... params)
    {
        return { std::vector{ params... } };
    }
} // namespace steppable::__internals::parameter

#define PARAM_GET(map, type, name)                    \
    type name;                                        \
    do                                                \
    {                                                 \
        (name) = (map).template getItem<type>(#name); \
    } while (0)

#define PARAM_GET_FALLBACK(map, type, name, fallback)           \
    type name;                                                  \
    do                                                          \
    {                                                           \
        (name) = (map).template getItem<type>(#name, fallback); \
    } while (0)