Merge branch 'release/v0.2.3'

Author: StefanoLusardiTC

README.md

@@ -75,10 +75,11 @@ Check the [Examples](sdk/examples/src/) folder for an in-depth showcase of all t
 
 ## Getting Started
 
-This project uses git submodules so it is required to clone it using the *--recursive* flag in order to retrive the required submodules.
+This project uses git submodules so it is required to clone it using the *--recurse-submodules* flag in order to retrive the required submodules.
 
 ```bash
-git clone https://github.com/TeiaCare/TeiaCareSDK.git --recursive
+git clone --recurse-submodules https://github.com/TeiaCare/TeiaCareSDK.git
+git submodule update --init
 ```
 
 ### Create Development Environment

VERSION

@@ -1 +1 @@
-0.2.1
+0.2.3

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/include/teiacare/sdk/datetime/date.hpp

@@ -97,6 +97,16 @@ class date
     {
     }
 
+    /*!
+     * \brief Copy Constructor. Copy a tc::sdk::date instance to another one.
+     */
+    constexpr date(const date&) noexcept = default;
+
+    /*!
+     * \brief Move Constructor. Copy a tc::sdk::date instance to another one.
+     */
+    constexpr date(date&&) noexcept = default;
+
     /*!
      * \brief Assignment operator. Assign a tc::sdk::date instance to another one.
      */
@@ -171,24 +181,11 @@ class date
     }
 
     /*!
-     * \brief Equality operator.
-     * \param other the date to compare against.
-     * \return true if the two date objects are the same.
-     */
-    constexpr inline bool operator==(const date& other) const noexcept
-    {
-        return _ymd == other._ymd;
-    }
-
-    /*!
-     * \brief Inequality operator.
+     * \brief Spaceship operator.
      * \param other the date to compare against.
-     * \return true if the two date objects are the different.
+     * \return std::strong_ordering comparing two date objects.
      */
-    constexpr inline bool operator!=(const date& other) const noexcept
-    {
-        return !operator==(other);
-    }
+    constexpr auto operator<=>(const date& other) const noexcept = default;
 
     /*!
      * \brief Adds a time delta to the current date.
@@ -210,26 +207,6 @@ class date
         return tc::sdk::date{std::chrono::sys_days(_ymd) - delta.total_nanoseconds()};
     }
 
-    /*!
-     * \brief Checks if the current date is less than another date.
-     * \param other The date to compare against.
-     * \return true if the current date is less, false otherwise.
-     */
-    constexpr inline bool operator<(const date& other) const noexcept
-    {
-        return _ymd < other._ymd;
-    }
-
-    /*!
-     * \brief Checks if the current date is greater than another date.
-     * \param other The date to compare against.
-     * \return true if the current date is greater, false otherwise.
-     */
-    constexpr inline bool operator>(const date& other) const noexcept
-    {
-        return _ymd > other._ymd;
-    }
-
     /*!
      * \brief Calculates the time difference between two dates.
      * \param other The date to subtract from the current date.