unitConversion.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_UNIT_CONVERSION_HPP_
#define FCF_DEVMGR_COMMON_UNIT_CONVERSION_HPP_
 
 
#include <iostream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
#include <type_traits>
#include <unordered_map>
#include <variant>
 
#include <ifw/fnd/defs/iCommAdapter.hpp>
 
 
// Utility function to convert device values to SI units
 
namespace ifw::fcf::devmgr::common
{
    enum class QuantityKind
    {
        Length,
        Angle,
        Time,
        Empty,
    };
 
    struct SIValue
    {
        double value;
        QuantityKind kind;
    };
 
template<typename T>
struct is_std_vector : std::false_type {};
 
template<typename T, typename Alloc>
struct is_std_vector<std::vector<T, Alloc>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_std_vector_v = is_std_vector<std::decay_t<T>>::value;
 
// Convert an ifw-fnd Value (a std::variant) to a double. Throws on
// non-numeric variants (vectors, strings, monostate). Same semantics
// as the old core::protocol::base::Variant version — just a different
// concrete std::variant flavour.
inline double variant_to_double(const ifw::fnd::defs::Value& value)
{
    return std::visit(
        [](const auto& v) -> double
        {
            using T = std::decay_t<decltype(v)>;
 
            if constexpr (std::is_same_v<T, std::monostate>)
            {
                throw std::invalid_argument("Cannot convert empty variant to double");
            }
            else if constexpr (std::is_arithmetic_v<T>)
            {
                return static_cast<double>(v);
            }
            else if constexpr (is_std_vector_v<T>)
            {
                throw std::invalid_argument("Cannot convert vector variant to double");
            }
            else if constexpr (std::is_same_v<T, std::string>)
            {
                throw std::invalid_argument("Cannot convert string variant to double");
            }
            else
            {
                // PropertyMap and any other non-numeric alternative.
                throw std::invalid_argument(
                    "Cannot convert non-numeric variant alternative to double");
            }
        },
        value);
}
 
    struct UnitInfo
    {
        double factor;
        QuantityKind kind;
    };
 
    // lookup table for units
    inline const UnitInfo &lookup_unit(std::string_view unit)
    {
        static const std::unordered_map<std::string, UnitInfo> table = {
            // length -> SI base: meter
 
            {"", {1.0, QuantityKind::Empty}},
            {"UNKNOWN", {1.0, QuantityKind::Empty}},
            {"m", {1.0, QuantityKind::Length}},
            {"mm", {1e-3, QuantityKind::Length}},
            {"cm", {1e-2, QuantityKind::Length}},
            {"dm", {1e-1, QuantityKind::Length}},
            {"um", {1e-6, QuantityKind::Length}},
            {"nm", {1e-9, QuantityKind::Length}},
            {"km", {1e3, QuantityKind::Length}},
 
            // angle -> SI base: radian
            {"rad", {1.0, QuantityKind::Angle}},
            {"mrad", {1e-3, QuantityKind::Angle}},
            {"urad", {1e-6, QuantityKind::Angle}},
            {"deg", {3.14159265358979323846 / 180.0, QuantityKind::Angle}},
            {"degrees", {3.14159265358979323846 / 180.0, QuantityKind::Angle}},
            {"Degree", {3.14159265358979323846 / 180.0, QuantityKind::Angle}},
            {"°", {3.14159265358979323846 / 180.0, QuantityKind::Angle}},
            {"arcmin", {3.14159265358979323846 / 10800.0, QuantityKind::Angle}},
            {"arcsec", {3.14159265358979323846 / 648000.0, QuantityKind::Angle}},
 
            // time -> SI base: second
            {"s", {1.0, QuantityKind::Time}},
            {"ms", {1e-3, QuantityKind::Time}},
            {"us", {1e-6, QuantityKind::Time}},
            {"ns", {1e-9, QuantityKind::Time}},
            {"min", {60.0, QuantityKind::Time}},
            {"h", {3600.0, QuantityKind::Time}}};
 
        auto it = table.find(std::string(unit));
        if (it == table.end())
        {
            throw std::runtime_error("Unknown unit: " + std::string(unit));
        }
        return it->second;
    }
 
    // Function to convert value to a SI value
    SIValue to_si(const ifw::fnd::defs::Value &value, std::string_view unit);
 
    const char *kind_to_string(QuantityKind kind);
 
    const char *si_unit_name(QuantityKind kind);
 
} // namespace 
 
#endif  // FCF_DEVMGR_COMMON_UNIT_CONVERSION_HPP_