Strengthened support for argument parser on std::filesystem::path

Author: StefanoLusardiTC

README.md

@@ -79,6 +79,7 @@ This project uses git submodules so it is required to clone it using the *--recu
 
 ```bash
 git clone --recurse-submodules https://github.com/TeiaCare/TeiaCareSDK.git
+git submodule update --init
 ```
 
 ### Create Development Environment

sdk/examples/src/example_argparse.cpp

@@ -46,54 +46,69 @@ std::string to_string(const std::vector<T>& v)
 
 int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
 {
-    tc::sdk::argument_parser parser("SDK argparse example", "v1.0.0", "This is the program description");
+    tc::sdk::argument_parser parser("example_argparse", "v1.0.0", "This is the program description of SDK argparse example");
 
     std::string output_file;
-    parser.add_positional("output_file", output_file, "The output file");
+    // parser.add_positional("output_file", output_file, "The output file");
 
     std::string input_file;
-    parser.add_positional("input_file", input_file, "The input file");
+    // parser.add_positional("input_file", input_file, "The input file");
+
+    int simple_option;
+    parser.add_option("simple_option", simple_option);
+
+    bool simple_flag;
+    parser.add_flag("simple_flag", simple_flag);
 
     int iterations;
-    parser.add_option("iterations", "i", iterations, 10, "Iterations count", false, "TC_ITERATIONS");
+    parser.add_option("iterations", 'i', iterations, 10, "Iterations count", false, "TC_ITERATIONS");
 
     float threshold;
-    parser.add_option("threshold", "t", threshold, 0.5f, "Threshold");
+    parser.add_option("threshold", 't', threshold, 0.5f, "Threshold");
 
     std::vector<int> the_list;
-    parser.add_option("list", "l", the_list, std::vector<int>{1, 2, 3}, "List");
+    parser.add_option("list", 'l', the_list, std::vector<int>{1, 2, 3}, "List");
 
     bool verbose;
-    parser.add_flag("verbose", "x", verbose, "Enable verbose output", "TC_VERBOSE");
+    parser.add_flag("verbose", 'x', verbose, "Enable verbose output", "TC_VERBOSE");
 
     std::string str_opt;
-    parser.add_option(std::make_unique<tc::sdk::optional_argument<std::string>>("str_opt", "s", str_opt, "default_value", "Threshold"));
+    parser.add_option(std::make_unique<tc::sdk::optional_argument<std::string>>("str_opt", 's', str_opt, "default_value", "Threshold"));
 
     bool flag;
-    auto flag_arg = std::make_unique<tc::sdk::flag_argument>("flag", "f", flag, "Some random flag", "TC_FLAG");
+    auto flag_arg = std::make_unique<tc::sdk::flag_argument>("flag", 'f', flag, "Some random flag", "TC_FLAG");
     parser.add_flag(std::move(flag_arg));
 
     double double_opt;
-    auto double_arg = std::make_unique<tc::sdk::optional_argument<double>>("double", "d", double_opt, 5.6798, "Double argument", true);
-    double_arg->set_validator([](const double& value) {
-        return value > 10.0;
+    // auto double_arg = std::make_unique<tc::sdk::optional_argument<double>>("double", 'd', double_opt, 5.6798, "Double argument", true);
+    // double_arg->set_validator([](const double& value) {
+    //     return value > 10.0;
+    // });
+    // parser.add_option(std::move(double_arg));
+
+    std::filesystem::path unix_path{"some/path/to/file.txt"};
+    auto unix_path_arg = std::make_unique<tc::sdk::optional_argument<std::filesystem::path>>("unix_path", unix_path, unix_path, "Path to file");
+    unix_path_arg->set_validator([](const std::filesystem::path& p) {
+        return std::filesystem::exists(p);
     });
-    parser.add_option(std::move(double_arg));
+    parser.add_option(std::move(unix_path_arg));
 
-    std::filesystem::path file_path{"some/path/to/file.txt"};
-    auto path_arg = std::make_unique<tc::sdk::optional_argument<std::filesystem::path>>("file_path", "p", file_path, file_path, "Path to file");
-    path_arg->set_validator([](const std::filesystem::path& p) {
+    std::filesystem::path windows_path{"C:\\TeiaCare\\Dummy Directory\\log.txt"};
+    auto windows_path_arg = std::make_unique<tc::sdk::optional_argument<std::filesystem::path>>("win_path", windows_path, windows_path, "Path to file");
+    windows_path_arg->set_validator([](const std::filesystem::path& p) {
         return std::filesystem::exists(p);
     });
-    parser.add_option(std::move(path_arg));
+    parser.add_option(std::move(windows_path_arg));
 
     switch (parser.parse(argc, argv))
     {
     case tc::sdk::parse_result::success:
         break;
     case tc::sdk::parse_result::quit:
+        spdlog::info("Quit");
         return EXIT_SUCCESS;
     case tc::sdk::parse_result::error:
+        spdlog::error("Error");
         return EXIT_SUCCESS; // Normally here you will return EXIT_FAILURE, but we avoid failure since CI runs without any command line arguments.
     }
 
@@ -102,14 +117,17 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
 
     spdlog::info("Input file: {}", input_file);
     spdlog::info("Output file: {}", output_file);
+    spdlog::info("Simple Option: {}", simple_option);
+    spdlog::info("Simple Flag: {}", (simple_flag ? "true" : "false"));
     spdlog::info("Iterations: {}", iterations);
     spdlog::info("Threshold: {}", threshold);
     spdlog::info("Verbose: {}", (verbose ? "true" : "false"));
     spdlog::info("Str Opt: {}", str_opt);
     spdlog::info("Double Opt: ", double_opt);
     spdlog::info("Flag: {}", (flag ? "true" : "false"));
     spdlog::info("List: {}", to_string(the_list));
-    spdlog::info("Path: {}", file_path.string());
+    spdlog::info("Unix Path: {}", unix_path.string());
+    spdlog::info("Windows Path: {}", windows_path.string());
 
     return EXIT_SUCCESS;
 }

sdk/include/teiacare/sdk/argparse/argument_base.hpp

@@ -19,6 +19,7 @@
 #include <string>
 #include <type_traits>
 #include <vector>
+#include <filesystem>
 
 namespace tc::sdk
 {
@@ -238,14 +239,30 @@ class argument_base
         return values;
     }
 
-    // Generic implementation (for every type different from int, float, double, std::string and std::vector)
+    // Specialization for std::filesystem::path
+    template <typename T>
+    typename std::enable_if_t<std::is_same_v<T, std::filesystem::path>, T>
+    convert(const std::string& str) const
+    {
+        try
+        {
+            return std::filesystem::path(str);
+        }
+        catch (...)
+        {
+            throw std::runtime_error("Conversion error: " + _name_long + "=" + str);
+        }
+    }
+
+    // Generic implementation (for every type different from int, float, double, std::string, std::vector and std::filesystem::path)
     template <typename T>
     typename std::enable_if_t<
         !std::is_same_v<T, int> &&
             !std::is_same_v<T, float> &&
             !std::is_same_v<T, double> &&
             !std::is_same_v<T, std::string> &&
             !std::is_same_v<T, const char*> &&
+            !std::is_same_v<T, std::filesystem::path> &&
             !tc::sdk::is_vector<T>::value,
         T>
     convert(const std::string& str) const

sdk/include/teiacare/sdk/argparse/argument_parser.hpp

@@ -80,7 +80,7 @@ class argument_parser
     /*!
      * \brief Adds a positional argument to the parser.
      * \tparam T Type of the argument.
-     * \param name Name of the positional argument.
+     * \param name Name of the positional argument. Any string without spaces is accepted.
      * \param var Variable to store the parsed value.
      * \param description Description of the argument (optional).
      */
@@ -104,20 +104,38 @@ class argument_parser
     /*!
      * \brief Adds an optional argument to the parser.
      * \tparam T Type of the argument.
-     * \param name_long Long name of the argument (e.g., "--option").
-     * \param name_short Short name of the argument (e.g., "-o").
+     * \param name_long Long name of the argument. Any string without spaces is accepted. The double dashes must be omitted (e.g., "option" will result in "--option").
+     * \param name_short Short name of the argument. Single character. The dash must be omitted. (e.g., 'o' will result in '-o').
      * \param var Variable to store the parsed value.
      * \param default_value Default value for the argument.
      * \param description Description of the argument (optional).
      * \param required Whether the argument is required (default=false).
      * \param env_var Environment variable to use for the argument (optional).
      */
     template <typename T>
-    void add_option(const std::string& name_long, const std::string& name_short, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "")
+    // void add_option(const std::string& name_long, const std::string& name_short, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "")
+    void add_option(const std::string& name_long, const char name_short, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "")
     {
         add_option(std::make_unique<tc::sdk::optional_argument<T>>(name_long, name_short, var, default_value, description, required, env_var));
     }
 
+    /*!
+     * \brief Adds an optional argument to the parser.
+     * \tparam T Type of the argument.
+     * \param name_long Long name of the argument. Any string without spaces is accepted. The double dashes must be omitted (e.g., "option" will result in "--option").
+     * \param var Variable to store the parsed value.
+     * \param default_value Default value for the argument.
+     * \param description Description of the argument (optional).
+     * \param required Whether the argument is required (default=false).
+     * \param env_var Environment variable to use for the argument (optional).
+     */
+    template <typename T>
+    // void add_option(const std::string& name_long, const std::string& name_short, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "")
+    void add_option(const std::string& name_long, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "")
+    {
+        add_option(std::make_unique<tc::sdk::optional_argument<T>>(name_long, var, default_value, description, required, env_var));
+    }
+
     /*!
      * \brief Adds an optional argument using a unique pointer.
      * \tparam T Type of the argument.
@@ -131,17 +149,29 @@ class argument_parser
 
     /*!
      * \brief Adds a flag argument to the parser.
-     * \param name_long Long name of the flag (e.g., "--flag").
-     * \param name_short Short name of the flag (e.g., "-f").
+     * \param name_long Long name of the flag (e.g., "flag" will result in "--flag").
+     * \param name_short Short name of the flag (e.g., 'f', will result in '-f').
      * \param var Boolean variable to store the flag state.
      * \param description Description of the flag (optional).
      * \param env_var Environment variable to use for the flag (optional).
      */
-    void add_flag(const std::string& name_long, const std::string& name_short, bool& var, const std::string& description = "", const std::string& env_var = "")
+    void add_flag(const std::string& name_long, const char name_short, bool& var, const std::string& description = "", const std::string& env_var = "")
     {
         add_flag(std::make_unique<tc::sdk::flag_argument>(name_long, name_short, var, description, env_var));
     }
 
+    /*!
+     * \brief Adds a flag argument to the parser.
+     * \param name_long Long name of the flag (e.g., "flag" will result in "--flag").
+     * \param var Boolean variable to store the flag state.
+     * \param description Description of the flag (optional).
+     * \param env_var Environment variable to use for the flag (optional).
+     */
+    void add_flag(const std::string& name_long, bool& var, const std::string& description = "", const std::string& env_var = "")
+    {
+        add_flag(std::make_unique<tc::sdk::flag_argument>(name_long, var, description, env_var));
+    }
+
     /*!
      * \brief Adds a flag argument using a unique pointer.
      * \param flag_arg Unique pointer to the flag argument object.

sdk/include/teiacare/sdk/argparse/flag_argument.hpp

@@ -28,14 +28,27 @@ class flag_argument : public argument_base
 public:
     /*!
      * \brief Constructs a flag argument.
-     * \param name_long Long name of the argument (e.g., "--flag").
-     * \param name_short Short name of the argument (e.g., "-f").
+     * \param name_long Long name of the argument (e.g., "flag").
+     * \param name_short Short name of the argument (e.g., "f").
      * \param var Reference to the boolean variable that will be set.
      * \param description Description of the argument (optional).
      * \param env_var Name of the environment variable to parse (optional).
      */
-    explicit flag_argument(const std::string& name_long, const std::string& name_short, bool& var, const std::string& description = "", const std::string& env_var = "") noexcept
-        : argument_base(name_long, name_short, description, false, env_var)
+    explicit flag_argument(const std::string& name_long, char name_short, bool& var, const std::string& description = "", const std::string& env_var = "") noexcept
+        : argument_base(name_long, std::string(1, name_short), description, false, env_var)
+        , _var{var}
+    {
+    }
+
+    /*!
+     * \brief Constructs a flag argument.
+     * \param name_long Long name of the argument (e.g., "flag").
+     * \param var Reference to the boolean variable that will be set.
+     * \param description Description of the argument (optional).
+     * \param env_var Name of the environment variable to parse (optional).
+     */
+    explicit flag_argument(const std::string& name_long, bool& var, const std::string& description = "", const std::string& env_var = "") noexcept
+        : argument_base(name_long, std::string(), description, false, env_var)
         , _var{var}
     {
     }

sdk/include/teiacare/sdk/argparse/optional_argument.hpp

@@ -32,16 +32,32 @@ class optional_argument : public argument_base
 public:
     /*!
      * \brief Constructs an optional argument.
-     * \param name_long Long name of the argument (e.g., "--option").
-     * \param name_short Short name of the argument (e.g., "-o").
+     * \param name_long Long name of the argument (e.g., "option").
+     * \param name_short Short name of the argument (e.g., "o").
      * \param var Reference to the variable that will hold the parsed value.
      * \param default_value Default value for the argument.
      * \param description Description of the argument (optional).
      * \param required Indicates if the argument is required (default=false).
      * \param env_var Name of the environment variable to parse (optional).
      */
-    explicit optional_argument(const std::string& name_long, const std::string& name_short, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "") noexcept
-        : argument_base(name_long, name_short, description, required, env_var)
+    explicit optional_argument(const std::string& name_long, const char name_short, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "") noexcept
+        : argument_base(name_long, std::string(1, name_short), description, required, env_var)
+        , _var{var}
+    {
+        _var = default_value;
+    }
+
+    /*!
+     * \brief Constructs an optional argument.
+     * \param name_long Long name of the argument (e.g., "option").
+     * \param var Reference to the variable that will hold the parsed value.
+     * \param default_value Default value for the argument.
+     * \param description Description of the argument (optional).
+     * \param required Indicates if the argument is required (default=false).
+     * \param env_var Name of the environment variable to parse (optional).
+     */
+    explicit optional_argument(const std::string& name_long, T& var, const T& default_value = T(), const std::string& description = "", bool required = false, const std::string& env_var = "") noexcept
+        : argument_base(name_long, std::string(), description, required, env_var)
         , _var{var}
     {
         _var = default_value;

sdk/include/teiacare/sdk/argparse/positional_argument.hpp

@@ -35,7 +35,7 @@ class positional_argument : public argument_base
      * \param description Description of the argument (optional).
      */
     explicit positional_argument(const std::string& name, T& var, const std::string& description = "") noexcept
-        : argument_base(name, "", description, true)
+        : argument_base(name, std::string(), description, true)
         , _var(var)
     {
         _var = T();

sdk/src/argparse/argument_parser.cpp

@@ -28,8 +28,8 @@ argument_parser::argument_parser(const std::string& program_name, const std::str
     , _program_version{program_version}
     , _program_description{program_description}
 {
-    add_flag("help", "h", _help_flag, "Display this help message");
-    add_flag("version", "v", _version_flag, "Display program version");
+    add_flag("help", 'h', _help_flag, "Display this help message");
+    add_flag("version", 'v', _version_flag, "Display program version");
 }
 
 parse_result argument_parser::parse(int argc, char* argv[]) const
@@ -202,7 +202,15 @@ void argument_parser::print_arguments() const
     for (const auto& opt : _optionals)
     {
         std::cout << pad;
-        std::cout << std::setw(item_width) << "-" + opt->get_name_short() + ", --" + opt->get_name_long();
+        if(opt->get_name_short().empty())
+        {
+            std::cout << std::setw(item_width) << "--" + opt->get_name_long();
+        }
+        else
+        {
+            std::cout << std::setw(item_width) << "-" + opt->get_name_short() + ", --" + opt->get_name_long();
+        }
+
         std::cout << std::setw(item_width) << opt->get_description();
         if (const auto env = opt->get_env(); !env.empty())
         {
@@ -214,7 +222,15 @@ void argument_parser::print_arguments() const
     for (const auto& flag : _flags)
     {
         std::cout << pad;
-        std::cout << std::setw(item_width) << "-" + flag->get_name_short() + ", --" + flag->get_name_long();
+        if(flag->get_name_short().empty())
+        {
+            std::cout << std::setw(item_width) << "--" + flag->get_name_long();
+        }
+        else
+        {
+            std::cout << std::setw(item_width) << "-" + flag->get_name_short() + ", --" + flag->get_name_long();
+        }
+
         std::cout << std::setw(item_width) << flag->get_description();
         if (const auto env = flag->get_env(); !env.empty())
         {

sdk/tests/src/test_argparse_argument_base.cpp

@@ -254,4 +254,36 @@ TEST_F(test_argparse_argument_base, convert_vector_double)
     EXPECT_THROW(arg.convert_wrapper("1,a,b,c,d,e"), std::runtime_error);
 }
 
+TEST_F(test_argparse_argument_base, convert_filesystem_path_unix)
+{
+    using Type = std::filesystem::path;
+    argument<Type> arg("name_long");
+
+    EXPECT_EQ(Type{}, arg.convert_wrapper(""));
+
+    const auto non_spaced_path = std::filesystem::path("/home/TeiaCare/DummyDirectory/log.txt");
+    EXPECT_EQ(arg.convert_wrapper("/home/TeiaCare/DummyDirectory/log.txt"), non_spaced_path);
+    
+    const auto spaced_path = std::filesystem::path("/home/TeiaCare/Dummy Directory/log.txt");
+    EXPECT_EQ(arg.convert_wrapper("/home/TeiaCare/Dummy Directory/log.txt"), spaced_path);
+}
+
+TEST_F(test_argparse_argument_base, convert_filesystem_path_windows)
+{
+    using Type = std::filesystem::path;
+    argument<Type> arg("name_long");
+
+    EXPECT_EQ(Type{}, arg.convert_wrapper(""));
+
+    const auto non_spaced_path = std::filesystem::path("C:\\TeiaCare\\DummyDirectory\\log.txt");
+    EXPECT_EQ(arg.convert_wrapper(R"(C:\\TeiaCare\\DummyDirectory\\log.txt)"), non_spaced_path);
+    EXPECT_EQ(arg.convert_wrapper(R"(C:\TeiaCare\DummyDirectory\log.txt)"), non_spaced_path);
+    EXPECT_EQ(arg.convert_wrapper(R"(C:/TeiaCare/DummyDirectory/log.txt)"), non_spaced_path);
+    
+    const auto spaced_path = std::filesystem::path("C:\\TeiaCare\\Dummy Directory\\log.txt");
+    EXPECT_EQ(arg.convert_wrapper(R"(C:\\TeiaCare\\Dummy Directory\\log.txt)"), spaced_path);
+    EXPECT_EQ(arg.convert_wrapper(R"(C:\TeiaCare\Dummy Directory\log.txt)"), spaced_path);
+    EXPECT_EQ(arg.convert_wrapper(R"(C:/TeiaCare/Dummy Directory/log.txt)"), spaced_path);
+}
+
 }