Rework all exceptions

fintarin · Feb 19, 2024 · 00b4f65 · 00b4f65
1 parent 8b50283
commit 00b4f65
Show file tree

Hide file tree

Showing 55 changed files with 2,583 additions and 1,154 deletions.
diff --git a/include/fintamath/core/IArithmetic.hpp b/include/fintamath/core/IArithmetic.hpp
@@ -5,10 +5,13 @@
 #include <string>
 #include <utility>
 
+#include <fmt/core.h>
+
 #include "fintamath/core/CoreUtils.hpp"
 #include "fintamath/core/IMathObject.hpp"
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/core/Parser.hpp"
+#include "fintamath/exceptions/InvalidInputException.hpp"
 
 namespace fintamath {
 

diff --git a/include/fintamath/core/IArithmeticCRTP.hpp b/include/fintamath/core/IArithmeticCRTP.hpp
@@ -137,7 +137,13 @@ class IArithmeticCRTP_ : public IArithmetic {
       return cast<IArithmetic>(res->toMinimalObject());
     }
 
-    throw InvalidInputBinaryOperatorException(operStr, toString(), rhs.toString());
+    throw InvalidInputException(fmt::format(
+        R"(Invalid arguments of "{}" operator ({} "{}" and {} "{}" are unconvertible to each other))",
+        operStr,
+        this->getType().getName(),
+        this->toString(),
+        rhs.getType().getName(),
+        rhs.toString()));
   }
 
 private:

diff --git a/include/fintamath/core/IComparable.hpp b/include/fintamath/core/IComparable.hpp
@@ -6,6 +6,8 @@
 #include <string>
 #include <utility>
 
+#include <fmt/core.h>
+
 #include "fintamath/core/CoreUtils.hpp"
 #include "fintamath/core/IArithmetic.hpp"
 #include "fintamath/core/MathObjectType.hpp"

diff --git a/include/fintamath/core/IComparableCRTP.hpp b/include/fintamath/core/IComparableCRTP.hpp
@@ -34,7 +34,12 @@ class IComparableCRTP_ : public IComparable {
       return 0 <=> (rhs <=> *this);
     }
 
-    throw InvalidInputBinaryOperatorException("<=>", toString(), rhs.toString());
+    throw InvalidInputException(fmt::format(
+        R"(Invalid arguments of comparison operator ({} "{}" and {} "{}" are unconvertible to each other))",
+        this->getType().getName(),
+        this->toString(),
+        rhs.getType().getName(),
+        rhs.toString()));
   }
 
 private:

diff --git a/include/fintamath/exceptions/Exception.hpp b/include/fintamath/exceptions/Exception.hpp
@@ -1,14 +1,22 @@
 #pragma once
 
 #include <exception>
+#include <string>
+#include <string_view>
 
 namespace fintamath {
 
 class Exception : public std::exception {
 public:
+  explicit Exception(const std::string_view inMessage) : message(inMessage) {
+  }
+
   const char *what() const noexcept override {
-    return "Something went wrong...";
+    return message.data();
   }
+
+private:
+  std::string message;
 };
 
 }
diff --git a/include/fintamath/exceptions/InvalidInputException.hpp b/include/fintamath/exceptions/InvalidInputException.hpp
@@ -2,53 +2,29 @@
 
 #include <cstdint>
 #include <string>
-#include <vector>
+#include <string_view>
 
 #include "fintamath/exceptions/Exception.hpp"
 
 namespace fintamath {
 
 class InvalidInputException : public Exception {
 public:
-  InvalidInputException() = default;
-
-  explicit InvalidInputException(const std::string &input) {
-    content += ": " + input;
-  }
-
-  const char *what() const noexcept override {
-    return content.c_str();
+  explicit InvalidInputException(const std::string_view inMessage) : Exception(inMessage) {
   }
-
-protected:
-  std::string content = "Invalid input";
 };
 
 class InvalidInputFunctionException final : public InvalidInputException {
 public:
-  explicit InvalidInputFunctionException(const std::string &func, const std::vector<std::string> &argVect) {
-    content += ": " + func + "(";
-
-    if (!argVect.empty()) {
-      for (const auto &arg : argVect) {
-        content += arg + ',';
-      }
-
-      content.pop_back();
-    }
-
-    content += ")";
-  }
-
-  const char *what() const noexcept override {
-    return content.c_str();
+  explicit InvalidInputFunctionException(const std::string &func, const std::vector<std::string> &)
+      : InvalidInputException(func) {
   }
 };
 
 class InvalidInputBinaryOperatorException final : public InvalidInputException {
 public:
-  explicit InvalidInputBinaryOperatorException(const std::string &oper, const std::string &lhs, const std::string &rhs) {
-    content += ": (" + lhs + ")" + oper + "(" + rhs + ")";
+  explicit InvalidInputBinaryOperatorException(const std::string &oper, const std::string &, const std::string &)
+      : InvalidInputException(oper) {
   }
 };
 
@@ -60,15 +36,8 @@ class InvalidInputUnaryOperatorException final : public InvalidInputException {
   };
 
 public:
-  explicit InvalidInputUnaryOperatorException(const std::string &oper, const std::string &rhs, const Type type) {
-    switch (type) {
-      case Type::Prefix:
-        content += ": " + oper + "(" + rhs + ")";
-        break;
-      case Type::Postfix:
-        content += ": (" + rhs + ")" + oper;
-        break;
-    }
+  explicit InvalidInputUnaryOperatorException(const std::string &oper, const std::string &, const Type)
+      : InvalidInputException(oper) {
   }
 };
 

diff --git a/include/fintamath/exceptions/UndefinedException.hpp b/include/fintamath/exceptions/UndefinedException.hpp
@@ -2,53 +2,29 @@
 
 #include <cstdint>
 #include <string>
-#include <vector>
+#include <string_view>
 
 #include "fintamath/exceptions/Exception.hpp"
 
 namespace fintamath {
 
 class UndefinedException : public Exception {
 public:
-  UndefinedException() = default;
-
-  explicit UndefinedException(const std::string &input) {
-    content += ": " + input;
-  }
-
-  const char *what() const noexcept override {
-    return content.c_str();
+  explicit UndefinedException(const std::string_view inMessage) : Exception(inMessage) {
   }
-
-protected:
-  std::string content = "Undefined";
 };
 
 class UndefinedFunctionException final : public UndefinedException {
 public:
-  explicit UndefinedFunctionException(const std::string &func, const std::vector<std::string> &argVect) {
-    content += ": " + func + "(";
-
-    if (!argVect.empty()) {
-      for (const auto &arg : argVect) {
-        content += arg + ',';
-      }
-
-      content.pop_back();
-    }
-
-    content += ")";
-  }
-
-  const char *what() const noexcept override {
-    return content.c_str();
+  explicit UndefinedFunctionException(const std::string &func, const std::vector<std::string> &)
+      : UndefinedException(func) {
   }
 };
 
 class UndefinedBinaryOperatorException final : public UndefinedException {
 public:
-  explicit UndefinedBinaryOperatorException(const std::string &oper, const std::string &lhs, const std::string &rhs) {
-    content += ": (" + lhs + ")" + oper + "(" + rhs + ")";
+  explicit UndefinedBinaryOperatorException(const std::string &oper, const std::string &, const std::string &)
+      : UndefinedException(oper) {
   }
 };
 
@@ -60,15 +36,8 @@ class UndefinedUnaryOperatorException final : public UndefinedException {
   };
 
 public:
-  explicit UndefinedUnaryOperatorException(const std::string &oper, const std::string &rhs, const Type type) {
-    switch (type) {
-      case Type::Prefix:
-        content += ": " + oper + "(" + rhs + ")";
-        break;
-      case Type::Postfix:
-        content += ": (" + rhs + ")" + oper;
-        break;
-    }
+  explicit UndefinedUnaryOperatorException(const std::string &oper, const std::string &, const Type)
+      : UndefinedException(oper) {
   }
 };
 

diff --git a/include/fintamath/expressions/IExpression.hpp b/include/fintamath/expressions/IExpression.hpp
@@ -6,6 +6,8 @@
 #include <utility>
 #include <vector>
 
+#include <fmt/core.h>
+
 #include "fintamath/core/IArithmetic.hpp"
 #include "fintamath/core/IMathObject.hpp"
 #include "fintamath/core/MathObjectType.hpp"

diff --git a/include/fintamath/expressions/IExpressionCRTP.hpp b/include/fintamath/expressions/IExpressionCRTP.hpp
@@ -34,24 +34,24 @@ class IExpressionCRTP_ : public IExpressionBaseCRTP<Derived> {
   }
 
 protected:
-  Derived &add(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("+", this->toString(), rhs.toString());
+  Derived &add(const Derived &) override {
+    throw InvalidInputException(fmt::format("Arithmetic operations are not permitted for {}", this->getType().getName()));
   }
 
-  Derived &substract(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("-", this->toString(), rhs.toString());
+  Derived &substract(const Derived &) override {
+    throw InvalidInputException(fmt::format("Arithmetic operations are not permitted for {}", this->getType().getName()));
   }
 
-  Derived &multiply(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("*", this->toString(), rhs.toString());
+  Derived &multiply(const Derived &) override {
+    throw InvalidInputException(fmt::format("Arithmetic operations are not permitted for {}", this->getType().getName()));
   }
 
-  Derived &divide(const Derived &rhs) override {
-    throw InvalidInputBinaryOperatorException("/", this->toString(), rhs.toString());
+  Derived &divide(const Derived &) override {
+    throw InvalidInputException(fmt::format("Arithmetic operations are not permitted for {}", this->getType().getName()));
   }
 
   Derived &negate() override {
-    throw InvalidInputUnaryOperatorException("-", this->toString(), InvalidInputUnaryOperatorException::Type::Prefix);
+    throw InvalidInputException(fmt::format("Arithmetic operations are not permitted for {}", this->getType().getName()));
   }
 
 private:

diff --git a/include/fintamath/literals/Boolean.hpp b/include/fintamath/literals/Boolean.hpp
@@ -11,9 +11,9 @@ class Boolean final : public ILiteralCRTP<Boolean> {
 public:
   Boolean();
 
-  explicit Boolean(const std::string &str);
+  explicit Boolean(std::string_view inVal);
 
-  Boolean(bool val);
+  Boolean(bool inVal);
 
   std::string toString() const override;
 
@@ -24,7 +24,7 @@ class Boolean final : public ILiteralCRTP<Boolean> {
   }
 
 private:
-  std::string name;
+  std::string_view val;
 };
 
 }
diff --git a/include/fintamath/literals/Variable.hpp b/include/fintamath/literals/Variable.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <string_view>
 
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/literals/ILiteral.hpp"
@@ -10,9 +11,9 @@ namespace fintamath {
 
 class Variable final : public ILiteralCRTP<Variable> {
 public:
-  explicit Variable(std::string inName);
+  explicit Variable(std::string_view inName);
 
-  explicit Variable(std::string inName, Integer inIndex);
+  explicit Variable(std::string_view inName, Integer inIndex);
 
   std::string toString() const override;
 

diff --git a/include/fintamath/numbers/IInteger.hpp b/include/fintamath/numbers/IInteger.hpp
@@ -4,6 +4,8 @@
 #include <memory>
 #include <string>
 
+#include <fmt/core.h>
+
 #include "fintamath/core/CoreUtils.hpp"
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/core/Parser.hpp"

diff --git a/include/fintamath/numbers/IIntegerCRTP.hpp b/include/fintamath/numbers/IIntegerCRTP.hpp
@@ -209,7 +209,13 @@ class IIntegerCRTP_ : public IInteger {
       return cast<IInteger>(res->toMinimalObject());
     }
 
-    throw InvalidInputBinaryOperatorException(operStr, toString(), rhs.toString());
+    throw InvalidInputException(fmt::format(
+        R"(Invalid arguments of "{}" operator ({} "{}" and {} "{}" are unconvertible to each other))",
+        operStr,
+        this->getType().getName(),
+        this->toString(),
+        rhs.getType().getName(),
+        rhs.toString()));
   }
 
 private:

diff --git a/include/fintamath/numbers/Integer.hpp b/include/fintamath/numbers/Integer.hpp
@@ -6,6 +6,7 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <string_view>
 
 #include <boost/container_hash/hash.hpp>
 #include <boost/multiprecision/fwd.hpp>
@@ -26,7 +27,7 @@ class Integer final : public IIntegerCRTP<Integer> {
 
   Integer(Backend inBackend);
 
-  explicit Integer(std::string str);
+  explicit Integer(std::string_view str);
 
   explicit Integer(std::integral auto val) : backend(val) {
   }

diff --git a/include/fintamath/numbers/Rational.hpp b/include/fintamath/numbers/Rational.hpp
@@ -20,7 +20,7 @@ class Rational final : public INumberCRTP<Rational> {
 public:
   Rational() = default;
 
-  explicit Rational(const std::string &str);
+  explicit Rational(std::string_view str);
 
   explicit Rational(Integer inNumer, Integer inDenom);
 

diff --git a/include/fintamath/numbers/Real.hpp b/include/fintamath/numbers/Real.hpp
@@ -5,14 +5,14 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <string_view>
 
 #include <boost/container_hash/hash.hpp>
 #include <boost/multiprecision/fwd.hpp>
 #include <boost/multiprecision/mpfr.hpp>
 
 #include "fintamath/core/IArithmetic.hpp"
 #include "fintamath/core/IComparable.hpp"
-#include "fintamath/core/IMathObject.hpp"
 #include "fintamath/core/MathObjectType.hpp"
 #include "fintamath/numbers/INumber.hpp"
 #include "fintamath/numbers/Integer.hpp"
@@ -42,7 +42,7 @@ class Real final : public INumberCRTP<Real> {
 
   Real(Backend inBackend);
 
-  explicit Real(std::string str);
+  explicit Real(std::string_view str);
 
   Real(const Rational &val);