Started using Result to replace std::string.

Author: ZCG-coder

.idea/editor.xml

@@ -46,7 +46,7 @@ namespace steppable::__internals::numUtils
      * @param[in] base The base of the root.
      * @return A result object containing the largest root factor of the number.
      */
-    ResultBool getRootFactor(const std::string& _number, const std::string& base = "2");
+    ResultBool<std::string> getRootFactor(const std::string& _number, const std::string& base = "2");
 
     /**
      * @brief Get the greatest root number less than or equal to the given number.
@@ -73,5 +73,5 @@ namespace steppable::__internals::numUtils
      * @return StatusBool::CALCULATED_SIMPLIFIED_YES if the number is a root number,
      * StatusBool::CALCULATED_SIMPLIFIED_NO otherwise.
      */
-    ResultBool isRoot(const std::string& _number, const std::string& base);
+    ResultBool<std::string> isRoot(const std::string& _number, const std::string& base);
 } // namespace steppable::__internals::numUtils

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <string>
+
+#include "util.hpp"
+
+using namespace std::literals;
+using namespace steppable::__internals::utils;
+
+namespace steppable
+{
+    template<typename BaseT, StringLiteral BaseTName>
+    class Data
+    {
+        BaseT value;
+
+    public:
+        std::string getDataType() { return BaseTName.value; }
+
+        Data(const BaseT object) : value(object) {} // NOLINT(*-explicit-constructor)
+        Data() : value() {}
+
+        Data& operator=(const BaseT& object)
+        {
+            value = object;
+            return *this;
+        }
+    };
+
+    enum class _Weekday : std::uint8_t
+    {
+        Sunday = 0,
+        Monday = 1,
+        Tuesday = 2,
+        Wednesday = 3,
+        Thursday = 4,
+        Friday = 5,
+        Saturday = 6,
+    };
+
+    using Weekday = Data<_Weekday, StringLiteral{"Weekday"}>;
+} // namespace steppable

include/factors.hpp

@@ -22,10 +22,16 @@
 
 #pragma once
 
+#include <output.hpp>
+#include <platform.hpp>
 #include <string>
+#include <util.hpp>
 #include <utility>
 #include <vector>
 
+using namespace std::literals;
+using namespace steppable::__internals::utils;
+
 /**
  * @namespace steppable::types
  * @brief The namespace containing types used in the steppable calculator.
@@ -35,7 +41,7 @@ namespace steppable::types
     /**
      * @brief The status of the calculation.
      */
-    enum class Status
+    enum class Status : std::uint8_t
     {
         CALCULATED_SIMPLIFIED,
         CALCULATED_UNSIMPLIFIED,
@@ -45,7 +51,7 @@ namespace steppable::types
     /**
      * @brief The status of a boolean calculation.
      */
-    enum class StatusBool
+    enum class StatusBool : std::uint8_t
     {
         CALCULATED_SIMPLIFIED_YES,
         CALCULATED_SIMPLIFIED_NO,
@@ -60,18 +66,21 @@ namespace steppable::types
      *
      * @tparam StatusType The type of the status of the calculation.
      */
-    template<typename StatusType>
+    template<typename StatusType, typename ResultT, StringLiteral ResultTName>
     class ResultBase
     {
-    private:
         /// @brief Whether the calculation is done.
         StatusType done;
 
         /// @brief The inputs to the calculation.
         std::vector<std::string> inputs;
 
         /// @brief The output of the calculation.
-        std::string out;
+        std::vector<std::string> outputs;
+
+        /// @brief The result of the calculation
+        /// @attention This is different from `inputs`, as it stores only the result of the operation.
+        ResultT result;
 
     public:
         ResultBase() = delete;
@@ -81,26 +90,42 @@ namespace steppable::types
          *
          * @param[in] _inputs The inputs to the calculation.
          * @param[in] _out The output of the calculation.
+         * @param result The result of the calculation.
          * @param[in] _done A flag indicating how the calculation is done.
          */
-        ResultBase(const std::vector<std::string>& _inputs, std::string _out, StatusType _done) :
-            done(_done), inputs(_inputs), out(std::move(_out))
+        ResultBase(const std::vector<std::string>& _inputs,
+                   std::vector<std::string> _out,
+                   ResultT result,
+                   StatusType _done) :
+            done(_done), inputs(_inputs), outputs(std::move(_out)), result(result)
         {
         }
 
         /// @brief Gets how the calculation is done.
         StatusType getStatus() const { return done; }
 
+        ResultT getResult() const { return result; }
+
         /// @brief Gets the output of the calculation.
-        std::string getOutput() const { return out; }
+        [[nodiscard("Output should be used")]] std::string getOutput(size_t idx = 0) const
+        {
+            if (idx >= outputs.size())
+            {
+                output::error("getOutput"s, "Output index out of range"s);
+                programSafeExit(1);
+            }
+            return outputs[idx];
+        }
 
         /// @brief Gets the inputs to the calculation.
-        std::vector<std::string> getInputs() const { return inputs; }
+        [[nodiscard("Inputs should be used")]] std::vector<std::string> getInputs() const { return inputs; }
     };
 
     /// @brief An alias for a result of a calculation. This represents a calculation with a `Status` status.
-    using Result = ResultBase<Status>;
+    template<typename ResultT>
+    using Result = ResultBase<Status, ResultT, StringLiteral{ "str" }>;
 
     /// @brief An alias for a result of a boolean calculation.
-    using ResultBool = ResultBase<StatusBool>;
+    template<typename ResultT>
+    using ResultBool = ResultBase<StatusBool, ResultT, StringLiteral{ "bool" }>;
 } // namespace steppable::types

include/types/data.hpp

@@ -213,6 +213,28 @@ namespace steppable::__internals::utils
             programSafeExit(1);
         }
     }
+
+    /**
+     * @brief String literal workaround for templates.
+     * @tparam N The length of the string
+     */
+    template<size_t N>
+    struct StringLiteral
+    {
+        /**
+         * @brief Initializes the wrapper class.
+         * @param str The string literal for the template.
+         */
+        constexpr StringLiteral(const char (&str)[N]) // NOLINT(*-pro-type-member-init, *-explicit-constructor)
+        { // NOLINT(*-avoid-c-arrays)
+            std::copy_n(str, N, value);
+        }
+
+        /**
+         * @brief The value of the wrapper class. Stores the string object.
+         */
+        char value[N]; // NOLINT(*-avoid-c-arrays)
+    };
 } // namespace steppable::__internals::utils
 
 /**
@@ -550,4 +572,18 @@ namespace steppable::__internals::stringUtils
      * @return A vector of strings containing the duplicates.
      */
     std::vector<std::string> duplicates(const std::vector<std::string>& vector);
+
+    template<typename ValueType>
+    std::string vectorToString(const std::vector<ValueType>& vector)
+    {
+        std::ostringstream out;
+        out << "[";
+        for (size_t i = 0; i < vector.size(); ++i)
+        {
+            out << vector[i];
+            if (i != vector.size() - 1)
+                out << ", ";
+        }
+        return out.str();
+    }
 } // namespace steppable::__internals::stringUtils

include/types/result.hpp

@@ -35,19 +35,25 @@
 
 #include <fn/calc.hpp>
 #include <iostream>
+#include <number.hpp>
 #include <string>
+#include <types/result.hpp>
 
 using namespace steppable::__internals::utils;
 using namespace steppable::__internals::calc;
 using namespace steppable::localization;
 
 namespace steppable::__internals::calc
 {
-    std::string abs(const std::string& _number, const int steps)
+    types::Result<Number> _abs(const std::string& _number)
     {
-        std::string number = static_cast<std::string>(_number);
-        return reportAbs(number, steps);
+        const auto result = reportAbs(_number, 0);
+        const std::vector outputs = { result, reportAbs(_number, 1), reportAbs(_number, 2) };
+        const std::vector inputs = { _number };
+        return { inputs, outputs, Number(result), types::Status::CALCULATED_UNSIMPLIFIED };
     }
+
+    std::string abs(const std::string& _number, const int steps) { return _abs(_number).getOutput(steps); }
 } // namespace steppable::__internals::calc
 
 #ifndef NO_MAIN

include/util.hpp

@@ -54,20 +54,22 @@ namespace steppable::__internals::numUtils
         return factors;
     }
 
-    ResultBool getRootFactor(const std::string& _number, const std::string& base)
+    ResultBool<std::string> getRootFactor(const std::string& _number, const std::string& base)
     {
         auto factors = getFactors(_number);
         // Reverse the factors
-        std::reverse(factors.begin(), factors.end());
+        std::ranges::reverse(factors);
         // Get the largest root factor
         for (const auto& factor : factors)
         {
             auto rootResult = isRoot(factor, base);
             if (rootResult.getStatus() == StatusBool::CALCULATED_SIMPLIFIED_YES)
-                return { { _number, base, rootResult.getOutput() }, factor, StatusBool::CALCULATED_SIMPLIFIED_YES };
+                return {
+                    { _number, base, rootResult.getOutput() }, { factor }, factor, StatusBool::CALCULATED_SIMPLIFIED_YES
+                };
         }
         // The number has no root factors
-        return { { _number, base }, "1", StatusBool::CALCULATED_SIMPLIFIED_YES };
+        return { { _number, base }, { "1" }, { "1" }, StatusBool::CALCULATED_SIMPLIFIED_YES };
     }
 
     std::string getGreatestRootNum(const std::string& _number, const std::string& base)
@@ -82,12 +84,12 @@ namespace steppable::__internals::numUtils
         return factors.size() == 2; // Only 1 and the number itself are factors ==> prime!
     }
 
-    ResultBool isRoot(const std::string& _number, const std::string& base)
+    ResultBool<std::string> isRoot(const std::string& _number, const std::string& base)
     {
         auto iRoot = rootIntPart(_number, base);
         auto rootNum = power(iRoot, base, 0);
         if (compare(rootNum, _number, 0) == "2")
-            return { { _number, base }, iRoot, StatusBool::CALCULATED_SIMPLIFIED_YES };
-        return { { _number, base }, "1", StatusBool::CALCULATED_SIMPLIFIED_NO };
+            return { { _number, base }, { iRoot }, { iRoot }, StatusBool::CALCULATED_SIMPLIFIED_YES };
+        return { { _number, base }, { "1" }, { "1" }, StatusBool::CALCULATED_SIMPLIFIED_NO };
     }
 } // namespace steppable::__internals::numUtils