cli11: added free functions that allow to write one option in more than one parameter

Author: AlaiaL

include/srsran/support/cli11_utils.h

@@ -15,7 +15,99 @@
 
 namespace srsran {
 
-/// \brief Parse string into optional type.
+/// \brief Adds a subcommand to the given application using the given subcommand name and description.
+///
+/// If the subcommand already exists in the application, returns a pointer to it.
+///
+/// \param app Application where the subcommand will be created.
+/// \param name Subcommand name.
+/// \param desc Human readable description of the subcommand.
+/// \return A pointer to the subcommand added to the application.
+CLI::App* add_subcommand(CLI::App& app, const std::string& name, const std::string& desc)
+{
+  CLI::App* subcommand = app.get_subcommand(name);
+  if (subcommand) {
+    return subcommand;
+  }
+
+  return app.add_subcommand(name, desc)->configurable();
+}
+
+/// \brief Adds an option to the given application.
+///
+/// This function adds an option to the given application using the given parameters. If the option is already present
+/// in the application, it is removed and a new option is added that will call the callback of the deleted callback and
+/// the conversion of the result for the given parameter. By doing this, it allows to add multiple parameters for one
+/// option, so one option will be present in the configuration but the result will be written in all the parameters
+/// registered for that option.
+///
+/// \param app Application where the option will be created.
+/// \param option_name Option name.
+/// \param param Parameter where the option value will be stored after parsing.
+/// \param desc Human readable description of the option.
+/// \return A pointer to the option added to the application.
+template <typename T>
+CLI::Option* add_option(CLI::App& app, const std::string& option_name, T& param, const std::string& desc)
+{
+  auto opt = app.get_option_no_throw(option_name);
+  if (!opt) {
+    return app.add_option(option_name, param, desc);
+  }
+
+  // Option was found. Get the callback and create new option.
+  auto callbck = opt->get_callback();
+  app.remove_option(opt);
+
+  return app
+      .add_option(
+          option_name,
+          [&param, callback = std::move(callbck)](const CLI::results_t& res) {
+            callback(res);
+            return CLI::detail::lexical_conversion<T, T>(res, param);
+          },
+          desc)
+      ->run_callback_for_default();
+}
+
+/// \brief Adds an option function to the given application.
+///
+/// This function adds an option function to the given application using the given parameters. If the option is already
+/// present in the application, it is removed and a new option is added that will contain the given function and deleted
+/// callback as function. By doing this, it allows to add multiple parameters for one option, so one option will be
+/// present in the configuration and the all the functions registered for that option will be called.
+///
+/// \param app Application where the option will be created.
+/// \param option_name Option name.
+/// \param func Function to execute during parsing.
+/// \param desc Human readable description of the option.
+/// \return A pointer to the option added to the application.
+template <typename T>
+CLI::Option* add_option_function(CLI::App&                            app,
+                                 const std::string&                   option_name,
+                                 const std::function<void(const T&)>& func,
+                                 const std::string&                   desc)
+{
+  auto opt = app.get_option_no_throw(option_name);
+  if (!opt) {
+    return app.add_option_function<T>(option_name, func, desc);
+  }
+
+  // Option was found. Get the callback and create new option.
+  auto callbck = opt->get_callback();
+  app.remove_option(opt);
+
+  return app
+      .add_option_function<T>(
+          option_name,
+          [func, callback = std::move(callbck)](const std::string& value) {
+            func(value);
+            callback({value});
+          },
+          desc)
+      ->run_callback_for_default();
+}
+
+/// Parse string into optional type.
 template <typename T>
 bool lexical_cast(const std::string& in, srsran::optional<T>& output)
 {
@@ -29,25 +121,26 @@ bool lexical_cast(const std::string& in, srsran::optional<T>& output)
   return true;
 }
 
-/// \brief Parsing an integer with additional option "auto" into an optional of an enum type.
+/// Parsing an integer with additional option "auto" into an optional of an enum type.
 template <typename Param>
 void add_auto_enum_option(CLI::App&          app,
                           const std::string& option_name,
                           optional<Param>&   param,
                           const std::string& desc)
 {
-  app.add_option_function<std::string>(
-         option_name,
-         [&param](const std::string& in) -> void {
-           if (in.empty() or in == "auto") {
-             return;
-           }
-           std::stringstream             ss(in);
-           std::underlying_type_t<Param> val;
-           ss >> val;
-           param = (Param)val;
-         },
-         desc)
+  add_option_function<std::string>(
+      app,
+      option_name,
+      [&param](const std::string& in) -> void {
+        if (in.empty() or in == "auto") {
+          return;
+        }
+        std::stringstream             ss(in);
+        std::underlying_type_t<Param> val;
+        ss >> val;
+        param = (Param)val;
+      },
+      desc)
       ->check([](const std::string& in_str) -> std::string {
         if (in_str == "auto" or in_str.empty()) {
           return "";
@@ -59,4 +152,4 @@ void add_auto_enum_option(CLI::App&          app,
       ->default_str("auto");
 }
 
-} // namespace srsran
+} // namespace srsran