Misc

.clang-format

@@ -0,0 +1,5 @@
+NamespaceIndentation: All
+PointerAlignment: Left
+IndentWidth: 4
+ColumnLimit: 120
+BasedOnStyle: Google

.clang-tidy

@@ -0,0 +1,109 @@
+Checks:
+  abseil-*,
+  altera-*,
+  android-*,
+  bugprone-*,
+  cert-*,
+  clang-*analyzer-*,
+  concurrency-*,
+  cppcoreguidelines-*,
+  darwin-*,
+  fuchsia-*,
+  google-*,
+  hicpp-*,
+  linuxkernel-*,
+  llvm-*,
+  misc-*,
+  modernize-*,
+  mpi-*,
+  objc-*,
+  openmp-*,
+  performance-*,
+  portability-*,
+  readability-*,
+  zircon-*,
+  -boost-*,
+  -llvmlibc-*,
+  -altera-unroll-loops,
+  -hicpp-vararg,
+  -hicpp-signed-bitwise,
+  -hicpp-no-array-decay,
+  -hicpp-explicit-conversions,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -google-readability-todo,
+  -google-explicit-constructor,
+  -google-build-using-namespace,
+  -fuchsia-overloaded-operator,
+  -fuchsia-statically-constructed-objects,
+  -fuchsia-default-arguments-declarations,
+  -fuchsia-default-arguments-calls,
+  -modernize-use-trailing-return-type,
+  -readability-identifier-length,
+  -readability-magic-numbers,
+  -altera-struct-pack-align,
+  -misc-non-private-member-variables-in-classes,
+  -misc-use-anonymous-namespace,
+  -misc-use-internal-linkage,
+  -concurrency-mt-unsafe,
+  -cert-env33-c,
+  -cert-err58-cpp,
+  -bugprone-easily-swappable-parameters,
+
+  # -abseil-cleanup-ctad
+  # -abseil-duration-addition
+  # -abseil-duration-comparison
+  # -abseil-duration-conversion-cast
+  # -abseil-duration-division
+  # -abseil-duration-factory-float
+  # -abseil-duration-factory-scale
+  # -abseil-duration-subtraction
+  # -abseil-duration-unnecessary-conversion
+  # -abseil-faster-strsplit-delimiter
+  # -abseil-no-internal-dependencies
+  # -abseil-no-namespace
+  # -abseil-redundant-strcat-calls
+  # -abseil-str-cat-append
+  # -abseil-string-find-startswith
+  # -abseil-string-find-str-contains
+  # -abseil-time-comparison
+  # -abseil-time-subtraction
+  # -abseil-upgrade-duration-conversions
+  # -altera-id-dependent-backward-branch
+  # -altera-struct-pack-align
+  # -altera-unroll-loops
+  # -bugprone-easily-swappable-parameters
+  # -cppcoreguidelines-avoid-c-arrays
+  # -cppcoreguidelines-avoid-magic-numbers
+  # -cppcoreguidelines-avoid-non-const-global-variables
+  # -cppcoreguidelines-pro-bounds-array-to-pointer-decay
+  # -cppcoreguidelines-pro-bounds-constant-array-index
+  # -cppcoreguidelines-pro-bounds-pointer-arithmetic
+  # -cppcoreguidelines-special-member-functions
+  # -fuchsia-default-arguments-calls
+  # -fuchsia-default-arguments-declarations
+  # -fuchsia-overloaded-operator
+  # -fuchsia-trailing-return
+  # -google-default-arguments
+  # -google-explicit-constructor
+  # -google-global-names-in-headers
+  # -google-objc-function-naming
+  # -google-objc-global-variable-declaration
+  # -google-runtime-int
+  # -hicpp-avoid-c-arrays
+  # -hicpp-explicit-conversions
+  # -hicpp-no-array-decay
+  # -hicpp-special-member-functions
+  # -llvmlibc-callee-namespace
+  # -llvmlibc-implementation-in-namespace
+  # -llvmlibc-restrict-system-libc-headers
+  # -modernize-avoid-c-arrays
+  # -modernize-use-nodiscard
+  # -modernize-use-trailing-return-type
+  # -readability-identifier-length
+  # -readability-isolate-declaration
+  # -readability-magic-numbers

include/Arg.hpp

@@ -1,15 +1,15 @@
 #pragma once
 
-#include "Macros.hpp"
-
-#include <ostream>
 #include <iostream>
 #include <optional>
+#include <ostream>
 #include <string>
 
+#include "Macros.hpp"
+
 class Arg {
-  public:
-    Arg(const std::string& name);
+   public:
+    Arg(std::string name);
 
     Arg& short_name(const std::string& short_name);
     Arg& long_name(const std::string& long_name);
@@ -24,7 +24,7 @@ class Arg {
     static void print_arg(std::ostream& os, const Arg& arg, int indent);
     friend std::ostream& operator<<(std::ostream& os, const Arg& arg);
 
-  private:
+   private:
     friend class ClapParser;
 
     std::string name_;
@@ -51,14 +51,14 @@ class Arg {
     DEFINE_GETTER_SETTER(auto_env, bool)
     DEFINE_GETTER_SETTER(default_value, std::string)
     DEFINE_GETTER_SETTER(value, std::optional<std::string>)
-    
+
     // ----| Checkers |----
     // has_env_
-    [[nodiscard]] inline bool has_env() const { return !this->env_name_.empty(); }
-    
+    [[nodiscard]] bool has_env() const { return !this->env_name_.empty(); }
+
     // has_default_
-    [[nodiscard]] inline bool has_default() const { return !this->default_value_.empty(); }
+    [[nodiscard]] bool has_default() const { return !this->default_value_.empty(); }
 
     // has_value_
-    [[nodiscard]] inline bool has_value() const { return this->value_.has_value(); }
+    [[nodiscard]] bool has_value() const { return this->value_.has_value(); }
 };

include/Macros.hpp

@@ -1,27 +1,29 @@
 #pragma once
 
-#define DEFINE_PARSABLE_BASIC_TYPE(TYPE) \
-template<> \
-struct Parse<TYPE> { \
-    static std::optional<TYPE> parse(std::string_view s) { \
-        TYPE value; \
-        auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value); \
-        if (ec == std::errc()) return value; \
-        return std::nullopt; \
-    } \
-};
+#define DEFINE_PARSABLE_BASIC_TYPE(TYPE)                                            \
+    template <>                                                                     \
+    struct Parse<TYPE> {                                                            \
+        static std::optional<TYPE> parse(std::string_view s) {                      \
+            TYPE value;                                                             \
+            auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value); \
+            if (ec == std::errc()) return value;                                    \
+            return std::nullopt;                                                    \
+        }                                                                           \
+    };
 
-#define DEFINE_PARSABLE_FLOAT_TYPE(TYPE, CONVERT_FN) \
-template<> \
-struct Parse<TYPE> { \
-    static std::optional<TYPE> parse(std::string_view s) { \
-        char* end = nullptr; \
-        TYPE value = CONVERT_FN(s.data(), &end); \
-        if (end == s.data() + s.size()) return value; \
-        return std::nullopt; \
-    } \
-};
+#define DEFINE_PARSABLE_FLOAT_TYPE(TYPE, CONVERT_FN)           \
+    template <>                                                \
+    struct Parse<TYPE> {                                       \
+        static std::optional<TYPE> parse(std::string_view s) { \
+            char* end = nullptr;                               \
+            TYPE value = CONVERT_FN(s.data(), &end);           \
+            if (end == s.data() + s.size()) {                  \
+                return value;                                  \
+            }                                                  \
+            return std::nullopt;                               \
+        }                                                      \
+    };
 
-#define DEFINE_GETTER_SETTER(NAME, TYPE)                                         \
-  [[nodiscard]] inline const TYPE& get__##NAME() const { return this->NAME##_; } \
-  inline void set__##NAME(const TYPE& NAME) { this->NAME##_ = NAME; }
+#define DEFINE_GETTER_SETTER(NAME, TYPE)                                           \
+    [[nodiscard]] inline const TYPE& get__##NAME() const { return this->NAME##_; } \
+    inline void set__##NAME(const TYPE& NAME) { this->NAME##_ = NAME; }

include/Parsables.hpp

@@ -1,20 +1,20 @@
 #pragma once
 
-#include "Macros.hpp"
-
 #include <charconv>
 #include <cstdint>
 #include <cstdlib>
 #include <optional>
 #include <string>
 #include <string_view>
 
-template<typename T>
+#include "Macros.hpp"
+
+template <typename T>
 struct Parse {
     static_assert(sizeof(T) == 0, "No Parse<T> specialization defined for this type");
 };
 
-template<typename T>
+template <typename T>
 concept Parseable = requires(std::string_view s) {
     { Parse<T>::parse(s) } -> std::convertible_to<std::optional<T>>;
 };
@@ -34,17 +34,15 @@ DEFINE_PARSABLE_FLOAT_TYPE(float, std::strtof)
 DEFINE_PARSABLE_FLOAT_TYPE(double, std::strtod)
 DEFINE_PARSABLE_FLOAT_TYPE(long double, std::strtold)
 
-template<>
+template <>
 struct Parse<std::string> {
-    static std::optional<std::string> parse(std::string_view s) {
-        return std::string(s.data());
-    }
+    static std::optional<std::string> parse(std::string_view s) { return std::string(s.data()); }
 };
 
-template<>
+template <>
 struct Parse<bool> {
     static std::optional<bool> parse(std::string_view s) {
-      auto as_int = Parse<int>::parse(s).value();
-      return as_int;
+        auto as_int = Parse<int>::parse(s).value();
+        return as_int;
     }
 };

include/Parser.hpp

@@ -1,32 +1,32 @@
 #pragma once
 
-#include "Arg.hpp"
-#include "utils.hpp"
-#include "Parsables.hpp"
-
-#include <optional>
 #include <cstdlib>
 #include <iostream>
 #include <optional>
 #include <string>
 #include <vector>
 
+#include "Arg.hpp"
+#include "Parsables.hpp"
+#include "utils.hpp"
+
 class ClapParser {
-  public:
+   public:
     void add_arg(const Arg& arg);
     void parse(const int& argc, char* argv[]);
     void print_help() const;
 
     template <typename T>
-    requires Parseable<T>
-    inline std::optional<T> get_one_as(const std::string& name) {
-        Arg* arg = ok_or(ClapParser::find_arg(*this, "--" + name), []{ return std::nullopt; });
+        requires Parseable<T>
+    std::optional<T> get_one_as(const std::string& name) {
+        Arg* arg = ok_or(ClapParser::find_arg(*this, "--" + name), [] { return std::nullopt; });
         return Parse<T>::parse(arg->get__value().value());
     }
 
     static void print_parser(std::ostream& os, const ClapParser& parser, int indent);
     friend std::ostream& operator<<(std::ostream& os, const ClapParser& parser);
-  private:
+
+   private:
     std::vector<Arg> args_;
     std::string program_name_;
 
@@ -35,7 +35,6 @@ class ClapParser {
     static bool is_long_option(const std::string& token);
     static bool is_short_option(const std::string& token);
     static std::optional<Arg*> find_arg(ClapParser& parser, const std::string& name);
-    std::vector<Arg> get_positional_args() const;
     void apply_defaults();
 
     void parse_cli_args(const std::vector<std::string>& args);

include/utils.hpp

@@ -8,44 +8,52 @@
 
 template <typename T, typename E>
 inline T ok_or(std::optional<T> opt, E&& err) {
-    if (!opt) std::forward<E>(err)();
+    if (!opt) {
+        std::forward<E>(err)();
+    }
     return *opt;
 }
 
 template <typename T>
 inline T ok_or_throw_str(std::optional<T> opt, const std::string& err) {
-    if (!opt) throw std::runtime_error(err);
+    if (!opt) {
+        throw std::runtime_error(err);
+    }
     return *opt;
 }
 
 template <typename T>
 inline T ptr_ok_or_throw_str(T pointer, const std::string& err) {
-    if (!pointer) throw std::runtime_error(err);
+    if (!pointer) {
+        throw std::runtime_error(err);
+    }
     return pointer;
 }
 
 template <typename P, typename E>
-inline E ptr_unwrap_or(P pointer, const E other) { 
-    if (!pointer) return other;
+inline E ptr_unwrap_or(P pointer, const E other) {
+    if (!pointer) {
+        return other;
+    }
 }
- 
+
 // variadic template function to concatenate any number of arguments
-template <typename... Args> inline std::string concat(Args&&... args) {
+template <typename... Args>
+inline std::string concat(Args&&... args) {
     std::ostringstream oss;
     (void)std::initializer_list<int>{
-        (oss << std::forward<Args>(args), 0)...}; // using initializer_list for fold-like behavior
+        (oss << std::forward<Args>(args), 0)...};  // using initializer_list for fold-like behavior
     return oss.str();
 }
 
-inline const std::string quote(const std::string& name) {
-    return '\'' + name + '\'';
-}
+inline std::string quote(const std::string& name) { return '\'' + name + '\''; }
 
 inline void print_indent(std::ostream& os, int indent_level) {
-    for (int i = 0; i < indent_level; ++i)
+    for (int i = 0; i < indent_level; ++i) {
         os << '\t';
+    }
 }
 
-inline void to_upper(std::string &s) {
+inline void to_upper(std::string& s) {
     std::ranges::transform(s, s.begin(), [](const unsigned char& c) { return std::toupper(c); });
 }