Parameterizable.h

Go to the documentation of this file.

/* -------------------------------------------------------------------------
 *  A repertory of multi primitive-to-primitive (MP2P) ICP algorithms in C++
 * Copyright (C) 2018-2024 Jose Luis Blanco, University of Almeria
 * See LICENSE for license information.
 * ------------------------------------------------------------------------- */
 
#pragma once
 
#include <mrpt/expr/CRuntimeCompiledExpression.h>
 
#include <cstdint>
#include <optional>
#include <set>
#include <string>
#include <variant>
#include <vector>
 
namespace mp2p_icp
{
namespace internal
{
struct InfoPerParam
{
    std::string expression;
    std::optional<mrpt::expr::CRuntimeCompiledExpression>    compiled;
    std::variant<std::monostate, double*, float*, uint32_t*> target;
    bool is_constant        = false;
    bool has_been_evaluated = false;
};
}  // namespace internal
 
class ParameterSource;
class Parameterizable;
 
class ParameterSource
{
   public:
    ParameterSource() = default;
 
    void attach(Parameterizable& obj);
 
    void updateVariable(const std::string& variable, double value)
    {
        variables_[variable] = value;
    }
 
    void updateVariables(
        const std::vector<std::pair<std::string, double>>& nameValuePairs)
    {
        for (const auto& [name, value] : nameValuePairs)
            updateVariable(name, value);
    }
 
    void realize();
 
    std::string printVariableValues() const;
 
    auto getVariableValues() const -> std::map<std::string, double>
    {
        return variables_;
    }
 
   private:
    // Attached clients.
    std::map<std::string, double>     variables_;
    std::set<internal::InfoPerParam*> attachedDeclParameters_;
};
 
class Parameterizable
{
    friend class ParameterSource;
 
   public:
    virtual void attachToParameterSource(ParameterSource& source)
    {
        source.attach(*this);
    }
 
    auto&       declaredParameters() { return declParameters_; }
    const auto& declaredParameters() const { return declParameters_; }
 
    ParameterSource*       attachedSource() { return attachedSource_; }
    const ParameterSource* attachedSource() const { return attachedSource_; }
 
    void checkAllParametersAreRealized() const;
 
    void unrealizeParameters();
 
   protected:
    void parseAndDeclareParameter(const std::string& value, double& target);
 
    void parseAndDeclareParameter(const std::string& value, float& target);
    void parseAndDeclareParameter(const std::string& value, uint32_t& target);
 
   private:
    std::vector<internal::InfoPerParam> declParameters_;
    ParameterSource*                    attachedSource_ = nullptr;
 
    template <typename T>
    void parseAndDeclareParameter_impl(const std::string& value, T& target);
};
 
template <typename T>
inline void AttachToParameterSource(
    std::vector<std::shared_ptr<T>>& setObjects, ParameterSource& source)
{
    for (auto& objPtr : setObjects)
    {
        auto o = std::dynamic_pointer_cast<Parameterizable>(objPtr);
        if (!o) continue;
        o->attachToParameterSource(source);
    }
}
 
inline void AttachToParameterSource(Parameterizable& o, ParameterSource& source)
{
    o.attachToParameterSource(source);
}
 
#define DECLARE_PARAMETER_IN_OPT(__yaml, __variable, __object)        \
    __object.mp2p_icp::Parameterizable::parseAndDeclareParameter(     \
        __yaml.getOrDefault(#__variable, std::to_string(__variable)), \
        __variable);
 
#define DECLARE_PARAMETER_OPT(__yaml, __variable) \
    DECLARE_PARAMETER_IN_OPT(__yaml, __variable, (*this))
 
#define DECLARE_PARAMETER_IN_REQ(__yaml, __variable, __object)            \
    if (!__yaml.has(#__variable))                                         \
        throw std::invalid_argument(mrpt::format(                         \
            "Required parameter `%s` not an existing key in dictionary.", \
            #__variable));                                                \
    __object.mp2p_icp::Parameterizable::parseAndDeclareParameter(         \
        __yaml[#__variable].as<std::string>(), __variable);
 
#define DECLARE_PARAMETER_REQ(__yaml, __variable) \
    DECLARE_PARAMETER_IN_REQ(__yaml, __variable, (*this))
 
}  // namespace mp2p_icp