Use relative includes.

hazby2002 · Dec 29, 2023 · b79b55c · b79b55c
1 parent b3e42ff
commit b79b55c
Show file tree

Hide file tree

Showing 2 changed files with 65 additions and 43 deletions.
diff --git a/include/rfl/Result.hpp b/include/rfl/Result.hpp
@@ -10,7 +10,7 @@
 #include <variant>
 #include <vector>
 
-#include "rfl/internal/to_std_array.hpp"
+#include "internal/to_std_array.hpp"
 
 namespace rfl {
 
@@ -37,7 +37,8 @@ struct Nothing {};
 template <class T>
 class Result {
   static_assert(!std::is_same<T, Error>(), "The result type cannot be Error.");
-  using ValueType = std::conditional_t<std::is_array_v<T>, internal::to_std_array_t<T>, T>;
+  using ValueType =
+      std::conditional_t<std::is_array_v<T>, internal::to_std_array_t<T>, T>;
 
  public:
   Result(const ValueType& _val) : value_or_err_(_val) {}
@@ -52,18 +53,23 @@ class Result {
 
   Result(const Result<T>& _other) = default;
 
-  template <class U, typename std::enable_if<std::is_convertible_v<U, ValueType>,
-                                             bool>::type = true>
+  template <class U,
+            typename std::enable_if<std::is_convertible_v<U, ValueType>,
+                                    bool>::type = true>
   Result(Result<U>&& _other)
       : value_or_err_(std::forward<Result<U>>(_other)
-                      .transform([](U&& _u) { return ValueType(std::forward<U>(_u)); })
-                      .value_or_err_) {}
-
-  template <class U, typename std::enable_if<std::is_convertible_v<U, ValueType>,
-                                             bool>::type = true>
+                          .transform([](U&& _u) {
+                            return ValueType(std::forward<U>(_u));
+                          })
+                          .value_or_err_) {}
+
+  template <class U,
+            typename std::enable_if<std::is_convertible_v<U, ValueType>,
+                                    bool>::type = true>
   Result(const Result<U>& _other)
       : value_or_err_(
-            _other.transform([](const U& _u) { return ValueType(_u); }).value_or_err_) {}
+            _other.transform([](const U& _u) { return ValueType(_u); })
+                .value_or_err_) {}
 
   ~Result() = default;
 
@@ -90,8 +96,9 @@ class Result {
       }
     };
 
-    return std::visit(handle_variant,
-                      std::forward<std::variant<ValueType, Error>>(value_or_err_));
+    return std::visit(
+        handle_variant,
+        std::forward<std::variant<ValueType, Error>>(value_or_err_));
   }
 
   /// Monadic operation - F must be a function of type ValueType -> Result<U>.
@@ -115,8 +122,8 @@ class Result {
   /// Results types can be iterated over, which even make it possible to use
   /// them within a std::range.
   ValueType* begin() noexcept {
-    const auto get_ptr =
-        [this]<class ValueOrError>(const ValueOrError& _value_or_err) -> ValueType* {
+    const auto get_ptr = [this]<class ValueOrError>(
+                             const ValueOrError& _value_or_err) -> ValueType* {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return &_value_or_err;
       } else {
@@ -130,7 +137,8 @@ class Result {
   /// them within a std::range.
   const ValueType* begin() const noexcept {
     const auto get_ptr =
-        [this]<class ValueOrError>(const ValueOrError& _value_or_err) -> const ValueType* {
+        [this]<class ValueOrError>(
+            const ValueOrError& _value_or_err) -> const ValueType* {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return &_value_or_err;
       } else {
@@ -143,8 +151,8 @@ class Result {
   /// Results types can be iterated over, which even make it possible to use
   /// them within a std::range.
   ValueType* end() noexcept {
-    const auto get_ptr =
-        [this]<class ValueOrError>(const ValueOrError& _value_or_err) -> ValueType* {
+    const auto get_ptr = [this]<class ValueOrError>(
+                             const ValueOrError& _value_or_err) -> ValueType* {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return &_value_or_err + 1;
       } else {
@@ -158,7 +166,8 @@ class Result {
   /// them within a std::range.
   const ValueType* end() const noexcept {
     const auto get_ptr =
-        []<class ValueOrError>(const ValueOrError& _value_or_err) -> const ValueType* {
+        []<class ValueOrError>(
+            const ValueOrError& _value_or_err) -> const ValueType* {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return &_value_or_err + 1;
       } else {
@@ -172,7 +181,8 @@ class Result {
   /// or std::nullopt otherwise.
   std::optional<Error> error() const noexcept {
     const auto get_err =
-        []<class ValueOrError>(const ValueOrError& _value_or_err) -> std::optional<Error> {
+        []<class ValueOrError>(
+            const ValueOrError& _value_or_err) -> std::optional<Error> {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return std::nullopt;
       } else {
@@ -193,7 +203,9 @@ class Result {
 
   /// Allows read access to the underlying value. Careful: Will result in
   /// undefined behavior, if the result contains an error.
-  const ValueType& operator*() const { return *std::get_if<ValueType>(&value_or_err_); }
+  const ValueType& operator*() const {
+    return *std::get_if<ValueType>(&value_or_err_);
+  }
 
   /// Assigns the underlying object.
   Result& operator=(const Result& _other) = default;
@@ -205,36 +217,40 @@ class Result {
   friend class Result;
 
   /// Assigns the underlying object.
-  template <class U, typename std::enable_if<std::is_convertible_v<U, ValueType>,
-                                             bool>::type = true>
+  template <class U,
+            typename std::enable_if<std::is_convertible_v<U, ValueType>,
+                                    bool>::type = true>
   auto& operator=(const Result<U>& _other) {
     const auto to_t = [](const U& _u) -> ValueType { return _u; };
     value_or_err_ = _other.transform(to_t).value_or_err_;
     return *this;
   }
 
-  /// Expects a function that takes of type Error -> Result<ValueType> and returns
-  /// Result<ValueType>.
+  /// Expects a function that takes of type Error -> Result<ValueType> and
+  /// returns Result<ValueType>.
   template <class F>
   Result<ValueType> or_else(const F& _f) {
     const auto handle_variant =
-        [&]<class ValueOrError>(ValueOrError&& _value_or_err) -> Result<ValueType> {
+        [&]<class ValueOrError>(
+            ValueOrError&& _value_or_err) -> Result<ValueType> {
       if constexpr (std::is_same<std::remove_cvref_t<ValueOrError>, Error>()) {
         return _f(std::forward<Error>(_value_or_err));
       } else {
         return std::forward<ValueType>(_value_or_err);
       }
     };
-    return std::visit(handle_variant,
-                      std::forward<std::variant<ValueType, Error>>(value_or_err_));
+    return std::visit(
+        handle_variant,
+        std::forward<std::variant<ValueType, Error>>(value_or_err_));
   }
 
-  /// Expects a function that takes of type Error -> Result<ValueType> and returns
-  /// Result<ValueType>.
+  /// Expects a function that takes of type Error -> Result<ValueType> and
+  /// returns Result<ValueType>.
   template <class F>
   Result<ValueType> or_else(const F& _f) const {
     const auto handle_variant =
-        [&_f]<class ValueOrError>(const ValueOrError& _value_or_err) -> Result<ValueType> {
+        [&_f]<class ValueOrError>(
+            const ValueOrError& _value_or_err) -> Result<ValueType> {
       if constexpr (std::is_same<ValueOrError, Error>()) {
         return _f(_value_or_err);
       } else {
@@ -258,16 +274,18 @@ class Result {
     using U = typename std::invoke_result<F, ValueType>::type;
 
     const auto handle_variant =
-        [&]<class ValueOrError>(ValueOrError&& _value_or_err) -> rfl::Result<U> {
+        [&]<class ValueOrError>(
+            ValueOrError&& _value_or_err) -> rfl::Result<U> {
       if constexpr (!std::is_same<std::remove_cvref_t<ValueOrError>, Error>()) {
         return _f(std::forward<ValueOrError>(_value_or_err));
       } else {
         return std::forward<ValueOrError>(_value_or_err);
       }
     };
 
-    return std::visit(handle_variant,
-                      std::forward<std::variant<ValueType, Error>>(value_or_err_));
+    return std::visit(
+        handle_variant,
+        std::forward<std::variant<ValueType, Error>>(value_or_err_));
   }
 
   /// Functor operation - F must be a function of type ValueType -> U.
@@ -277,7 +295,8 @@ class Result {
     using U = typename std::invoke_result<F, ValueType>::type;
 
     const auto handle_variant =
-        [&]<class ValueOrError>(const ValueOrError& _value_or_err) -> rfl::Result<U> {
+        [&]<class ValueOrError>(
+            const ValueOrError& _value_or_err) -> rfl::Result<U> {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return _f(_value_or_err);
       } else {
@@ -291,7 +310,8 @@ class Result {
   /// Returns the value if the result does not contain an error, throws an
   /// exceptions if not. Similar to .unwrap() in Rust.
   ValueType value() {
-    const auto handle_variant = [&]<class ValueOrError>(ValueOrError& _value_or_err) -> ValueType {
+    const auto handle_variant =
+        [&]<class ValueOrError>(ValueOrError& _value_or_err) -> ValueType {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return std::forward<ValueType>(_value_or_err);
       } else {
@@ -305,7 +325,8 @@ class Result {
   /// exceptions if not. Similar to .unwrap() in Rust.
   const ValueType& value() const {
     const auto handle_variant =
-        [&]<class ValueOrError>(const ValueOrError& _value_or_err) -> const ValueType& {
+        [&]<class ValueOrError>(
+            const ValueOrError& _value_or_err) -> const ValueType& {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return _value_or_err;
       } else {
@@ -317,7 +338,8 @@ class Result {
 
   /// Returns the value or a default.
   ValueType value_or(ValueType&& _default) noexcept {
-    const auto handle_variant = [&]<class ValueOrError>(ValueOrError&& _value_or_err) -> ValueType {
+    const auto handle_variant =
+        [&]<class ValueOrError>(ValueOrError&& _value_or_err) -> ValueType {
       using ValueTypeype = std::remove_cvref_t<ValueOrError>;
       if constexpr (!std::is_same<ValueTypeype, Error>()) {
         return std::forward<ValueType>(_value_or_err);
@@ -331,7 +353,8 @@ class Result {
   /// Returns the value or a default.
   ValueType value_or(const ValueType& _default) const noexcept {
     const auto handle_variant =
-        [&]<class ValueOrError>(const ValueOrError& _value_or_err) -> ValueType {
+        [&]<class ValueOrError>(
+            const ValueOrError& _value_or_err) -> ValueType {
       if constexpr (!std::is_same<ValueOrError, Error>()) {
         return _value_or_err;
       } else {

diff --git a/include/rfl/parsing/Parser_c_array.hpp b/include/rfl/parsing/Parser_c_array.hpp
@@ -3,10 +3,9 @@
 
 #include <type_traits>
 
-#include "rfl/Result.hpp"
-#include "rfl/parsing/Parser_base.hpp"
-#include "rfl/parsing/Parser_array.hpp"
-#include "rfl/internal/to_std_array.hpp"
+#include "../Result.hpp"
+#include "../internal/to_std_array.hpp"
+#include "Parser_array.hpp"
 
 namespace rfl {
 namespace parsing {
@@ -22,7 +21,7 @@ struct Parser<R, W, T[_size]> {
   using OutputVarType = typename W::OutputVarType;
 
   using CArray = T[_size];
-  using StdArray  = internal::to_std_array_t<T[_size]>;
+  using StdArray = internal::to_std_array_t<T[_size]>;
 
   static auto read(const R& _r, const InputVarType& _var) noexcept {
     return Parser<R, W, StdArray>::read(_r, _var);