The first implementation of a builder class for complex interfaces

Signed-off-by: CursedRock17 <[email protected]>

Author: CursedRock17

rclcpp/include/rclcpp/parameter_descriptor_wrapper.hpp

@@ -0,0 +1,102 @@
+#ifndef RCLCPP__PARAMETER_DESCRIPTOR_WRAPPER_HPP_
+#define RCLCPP__PARAMETER_DESCRIPTOR_WRAPPER_HPP_
+
+// Standard library includes
+#include <functional>
+#include <utility>
+#include <memory>
+
+// Additional ROS libraries needed
+#include "node.hpp"
+#include "rcl_interfaces/msg/describe_parameters.hpp"
+#include "rclcpp/node.hpp"
+
+namespace rclcpp
+{
+
+// Implments ParameterDesription class with builder design pattern
+class ParameterDescription
+{
+public:
+    // List of classes the builder manages
+    class FloatingPointDescription;
+
+    // Two constructors in case certain methods don't need to declare_parameters with a Type T in the form of a template
+    ParameterDescription(std::string name, std::uint8_t type, std::string description, std::string additional_constraints, bool read_only. bool dynamic_typing) : m_name{name}, parameter_descriptor.type{type}, m_description{description}, m_additional_constraints{additional_constraints}, read_only{read_only}, dyanmic_typing{m_dyanmic_typing}{};
+
+private:
+    // The main descriptor object we're meant to adjust
+    rcl_interfaces::msg::ParameterDescriptor parameter_descriptor = {};
+
+    // Copies all the information in ParameterDescriptor.msg - https://github.com/ros2/rcl_interfaces/blob/rolling/rcl_interfaces/msg/ParameterDescriptor.msg
+    std::string m_name;
+    std::string m_description;
+
+    // Parameter Constraints
+    std::string m_additional_constraints;
+    bool m_read_only;
+    bool m_dynamic_typing;
+
+};
+
+class ParameterDescription::FloatingPointDescription
+{
+public:
+    // Our Main build methods which will construct the base class
+    ParameterDescription build() const;
+
+    //Builder Method - Mains
+    FloatingPointDescription& SetName(std::string name);
+    FloatingPointDescription& SetType(std::uint8_t type);
+    FloatingPointDescription& SetDescription(std::string description);
+    FloatingPointDescription& SetAdditionalConstraints(std::string constraints);
+    FloatingPointDescription& SetReadOnly(bool read_only);
+    FloatingPointDescription& SetDynamicTyping(bool dynamic_typing);
+
+    // Need the current node in order to begin the configuraiton state forit via the declare_parameter function which setups up the Node
+    template<typename ParameterType>
+    FloatingPointDescription& DeclareParameter<ParameterType>(ParameterType default_value, std::shared_ptr<rclcpp::Node> required_node)
+{
+    required_node->declare_parameter<ParameterType>(m_name, default_value, parameter_descriptor);
+    return *this;
+}
+    // Extended build methods specific to this class
+    FloatingPointDescription& SetMin(float min);
+    FloatingPointDescription& SetMax(float max);
+    FloatingPointDescription& SetStep(float step);
+
+    // Simplification Method - Outside of the base clss that the user should be able to set up easily, they should then be able to call a function which setups up the specifics for this class (The floating point parameter description)
+    // Here we will have a difference between generic types and templated types
+    FloatingPointDescription& SetFloatingPointDescription(float min, float max, float step);
+    // We will again need access to the current development node to declare its parameters
+    template<typename ParameterType>
+    FloatingPointDescription& SetFloatingPointDescription(std::string name, ParameterType default_value, float min, float max, float step)
+    {
+        parameter_descriptor.floating_point_range.resize(1);
+        parameter_descriptor.floating_point_range.at(0).from_value = min;
+        parameter_descriptor.floating_point_range.at(0).to_value = max;
+        parameter_descriptor.floating_point_range.at(0).step = step;
+
+        return *this;
+    }
+
+
+private:
+    rcl_interfaces::msg::ParameterDescriptor parameter_descriptor = {};
+    std::string m_name{""};
+    parameter_descriptor.type{rcl_interfaces::msg::ParameterType::PARAMETER_NOT_SET};
+    std::string m_description{""};
+
+    std::string m_additional_constraints{""};
+    bool m_read_only{false};
+    bool m_dynamic_typing{false};
+
+    // This is a floating point so we'll use floating points in the range
+    float m_min{0.0f};
+    float m_max{1.0f};
+    float m_step{0.0f};
+};
+
+} // namespace rclcpp
+
+#endif // headerguards for parameter_descriptor

rclcpp/src/rclcpp/parameter_descriptor_wrapper.cpp

@@ -0,0 +1,85 @@
+
+
+#include "../../include/rclcpp/parameter_descriptor_wrapper.hpp"
+
+namespace rclcpp {
+// We use initializer lists in order to promote safety in uninitialzied state
+ParameterDescription(std::string name, std::uint8 type, std::string description, std::string additional_constraints, bool read_only. bool dynamic_typing) : m_name{name}, parameter_descriptor.type{type}, m_description{description}, m_additional_constraints{additional_constraints}, read_only{read_only}, dyanmic_typing{m_dyanmic_typing}
+{}
+
+
+// ParameterDescription - FloatingPointDescription
+// First the build methods to connect to the base class in the builder
+ParameterDescription FloatingPointDescription::build() const
+{
+    return ParameterDescription(m_name, parameter_descriptor.type, m_description, m_additional_constraints, m_read_only, m_dynamic_typing)
+}
+
+// Builder methods which set up the original class
+// They all follow the same format of initing the value given within the base class, then returning this current class
+FloatingPointDescription& FloatingPointDescription::SetName(std::string name)
+{
+    m_name = name;
+    return *this;
+}
+
+FloatingPointDescription& FloatingPointDescription::SetType(std::uint8_t type)
+{
+    parameter_descriptor.type = type;
+    return *this;
+}
+
+FloatingPointDescription& FloatingPointDescription::SetDescription(std::string description)
+{
+    m_description = description;
+    return *this;
+}
+
+FloatingPointDescription& FloatingPointDescription::SetAdditionalConstraints(std::string constraints)
+{
+    m_additional_constraints = constraints;
+    return *this;
+}
+
+FloatingPointDescription& FloatingPointDescription::SetReadOnly(bool read_only)
+{
+    m_read_only = read_only;
+    return *this;
+}
+
+FloatingPointDescription& FloatingPointDescription::SetDynamicTyping(bool dynamic_typing)
+{
+    m_dynamic_typing = dynamic_typing;
+    return *this;
+}
+
+// These are the extension for this class that don't have access in the main class so we'll initialize here
+FloatingPointDescription& FloatingPointDescription::SetMin(float min)
+{
+    m_min = min;
+    return *this;
+}
+
+FloatingPointDescription& FloatingPointDescription::SetMax(float max)
+{
+    m_max = max;
+    return *this;
+}
+
+FloatingPointDescription& FloatingPointDescription::SetStep(float step)
+{
+    m_step = step;
+    return *this;
+}
+
+// Here is the Specific range function for this parameter description
+FloatingPointDescription& FloatingPointDescription::SetFloatingPointDescripion(float min, float max, float step)
+{
+        parameter_descriptor.floating_point_range.resize(1);
+        parameter_descriptor.floating_point_range.at(0).from_value = min;
+        parameter_descriptor.floating_point_range.at(0).to_value = max;
+        parameter_descriptor.floating_point_range.at(0).step = step;
+        return *this;
+}
+
+} // rclcpp namespace