Refactor configs

fintarin · Feb 1, 2024 · bf09998 · bf09998
1 parent 84afe8a
commit bf09998
Show file tree

Hide file tree

Showing 23 changed files with 572 additions and 546 deletions.
diff --git a/include/fintamath/config/Config.hpp b/include/fintamath/config/Config.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+namespace fintamath {
+
+struct Config final {
+  Config();
+};
+
+}
diff --git a/include/fintamath/core/Converter.hpp b/include/fintamath/core/Converter.hpp
@@ -12,6 +12,8 @@ class Converter final {
   template <std::derived_from<IMathObject> To, std::derived_from<IMathObject> From>
   using ConverterFunction = std::function<std::unique_ptr<IMathObject>(const To &to, const From &from)>;
 
+  using ConverterMultiMethod = MultiMethod<std::unique_ptr<IMathObject>(const IMathObject &, const IMathObject &)>;
+
 public:
   template <std::derived_from<IMathObject> To, std::derived_from<IMathObject> From>
   static void add(const ConverterFunction<To, From> &convertFunc) {
@@ -27,7 +29,10 @@ class Converter final {
   }
 
 private:
-  static MultiMethod<std::unique_ptr<IMathObject>(const IMathObject &, const IMathObject &)> &getConverter();
+  static ConverterMultiMethod &getConverter() {
+    static ConverterMultiMethod converter;
+    return converter;
+  }
 };
 
 template <std::derived_from<IMathObject> To, std::derived_from<IMathObject> From>

diff --git a/include/fintamath/core/IArithmetic.hpp b/include/fintamath/core/IArithmetic.hpp
@@ -62,14 +62,16 @@ class IArithmetic : public IMathObject {
   virtual std::unique_ptr<IArithmetic> negateAbstract() const = 0;
 
 private:
-  static ArithmeticParser &getParser();
+  static ArithmeticParser &getParser() {
+    static ArithmeticParser parser;
+    return parser;
+  }
 };
 
 template <typename Derived>
 class IArithmeticCRTP : public IArithmetic {
 #define I_ARITHMETIC_CRTP IArithmeticCRTP<Derived>
 #include "fintamath/core/IArithmeticCRTP.hpp"
-
 #undef I_ARITHMETIC_CRTP
 };
 

diff --git a/include/fintamath/core/IComparable.hpp b/include/fintamath/core/IComparable.hpp
@@ -29,7 +29,10 @@ class IComparable : public IArithmetic {
   virtual std::strong_ordering compareAbstract(const IComparable &rhs) const = 0;
 
 private:
-  static ComparableParser &getParser();
+  static ComparableParser &getParser() {
+    static ComparableParser parser;
+    return parser;
+  }
 };
 
 template <typename Derived>

diff --git a/include/fintamath/core/IMathObject.hpp b/include/fintamath/core/IMathObject.hpp
@@ -4,6 +4,7 @@
 #include <sstream>
 #include <string>
 
+#include "fintamath/config//Config.hpp"
 #include "fintamath/core/Converter.hpp"
 #include "fintamath/core/CoreUtils.hpp"
 #include "fintamath/core/Parser.hpp"
@@ -50,14 +51,16 @@ class IMathObject {
   virtual bool equalsAbstract(const IMathObject &rhs) const = 0;
 
 private:
-  static MathObjectParser &getParser();
+  static MathObjectParser &getParser() {
+    static MathObjectParser parser;
+    return parser;
+  }
 };
 
 template <typename Derived>
 class IMathObjectCRTP : public IMathObject {
 #define I_MATH_OBJECT_CRTP IMathObjectCRTP
 #include "fintamath/core/IMathObjectCRTP.hpp"
-
 #undef I_MATH_OBJECT_CRTP
 };
 
@@ -70,4 +73,6 @@ inline std::ostream &operator<<(std::ostream &out, const IMathObject &rhs) {
   return out << rhs.toString();
 }
 
+inline static const Config config;
+
 }
diff --git a/include/fintamath/core/Tokenizer.hpp b/include/fintamath/core/Tokenizer.hpp
@@ -25,7 +25,10 @@ class Tokenizer final {
 
   static bool isSpace(char ch);
 
-  static TokenVector &getRegisteredTokens();
+  static TokenVector &getRegisteredTokens() {
+    static TokenVector registeredTokens;
+    return registeredTokens;
+  }
 };
 
 }
diff --git a/include/fintamath/expressions/Expression.hpp b/include/fintamath/expressions/Expression.hpp
@@ -121,9 +121,15 @@ class Expression final : public IExpressionCRTP<Expression> {
 
   friend std::unique_ptr<IMathObject> parseFintamath(const std::string &str);
 
-  static TermParser &getTermParser();
+  static TermParser &getTermParser() {
+    static TermParser parser;
+    return parser;
+  }
 
-  static ExpressionParser &getExpressionParser();
+  static ExpressionParser &getExpressionParser() {
+    static Parser<std::unique_ptr<IMathObject>, ArgumentPtrVector &&> maker;
+    return maker;
+  }
 
 private:
   mutable ArgumentPtr child;

diff --git a/include/fintamath/expressions/IExpression.hpp b/include/fintamath/expressions/IExpression.hpp
@@ -68,7 +68,10 @@ class IExpression : public IArithmetic {
   static ArgumentPtrVector convertToApproximatedNumbers(const ArgumentPtrVector &args);
 
 private:
-  static ExpressionParser &getParser();
+  static ExpressionParser &getParser() {
+    static ExpressionParser parser;
+    return parser;
+  }
 };
 
 template <typename Derived, bool isMultiFunction = false>

diff --git a/include/fintamath/functions/IFunction.hpp b/include/fintamath/functions/IFunction.hpp
@@ -79,11 +79,17 @@ class IFunction : public IMathObject {
   }
 
 private:
-  static FunctionOrderMap &getFunctionOrderMutableMap();
+  static FunctionOrderMap &getFunctionOrderMutableMap() {
+    static FunctionOrderMap orderMap;
+    return orderMap;
+  }
 
-  static FunctionParser &getParser();
+  static FunctionParser &getParser() {
+    static FunctionParser parser;
+    return parser;
+  }
 
-  static inline size_t maxFunctionOrder = 0;
+  inline static size_t maxFunctionOrder = 0;
 };
 
 template <typename Return, typename Derived, typename... Args>

diff --git a/include/fintamath/functions/IOperator.hpp b/include/fintamath/functions/IOperator.hpp
@@ -48,7 +48,10 @@ class IOperator : public IFunction {
   }
 
 private:
-  static OperatorParser &getParser();
+  static OperatorParser &getParser() {
+    static OperatorParser parser;
+    return parser;
+  }
 };
 
 template <typename Return, typename Derived, typename... Args>

diff --git a/include/fintamath/literals/ILiteral.hpp b/include/fintamath/literals/ILiteral.hpp
@@ -26,7 +26,10 @@ class ILiteral : public IMathObject {
   }
 
 private:
-  static LiteralParser &getParser();
+  static LiteralParser &getParser() {
+    static LiteralParser parser;
+    return parser;
+  }
 };
 
 template <typename Derived>

diff --git a/include/fintamath/literals/constants/IConstant.hpp b/include/fintamath/literals/constants/IConstant.hpp
@@ -31,14 +31,16 @@ class IConstant : public ILiteral {
   virtual std::unique_ptr<IMathObject> call() const = 0;
 
 private:
-  static ConstantParser &getParser();
+  static ConstantParser &getParser() {
+    static ConstantParser parser;
+    return parser;
+  }
 };
 
 template <typename Return, typename Derived>
 class IConstantCRTP : public IConstant {
 #define I_CONSTANT_CRTP IConstantCRTP<Return, Derived>
 #include "fintamath/literals/constants/IConstantCRTP.hpp"
-
 #undef I_CONSTANT_CRTP
 };
 

diff --git a/include/fintamath/numbers/IInteger.hpp b/include/fintamath/numbers/IInteger.hpp
@@ -89,7 +89,10 @@ class IInteger : public INumber {
   virtual IInteger &decreaseAbstract() = 0;
 
 private:
-  static IntegerParser &getParser();
+  static IntegerParser &getParser() {
+    static IntegerParser parser;
+    return parser;
+  }
 };
 
 template <typename Derived>

diff --git a/include/fintamath/numbers/INumber.hpp b/include/fintamath/numbers/INumber.hpp
@@ -35,7 +35,10 @@ class INumber : public IComparable {
   }
 
 private:
-  static NumberParser &getParser();
+  static NumberParser &getParser() {
+    static NumberParser parser;
+    return parser;
+  }
 };
 
 inline std::unique_ptr<INumber> operator+(const INumber &lhs, const INumber &rhs) {

diff --git a/src/fintamath/config/Config.cpp b/src/fintamath/config/Config.cpp
@@ -0,0 +1,17 @@
+#include "fintamath/config/Config.hpp"
+
+#include "ParserConfig.hpp"
+#include "PrecisionConfig.hpp"
+#include "fintamath/config/ConverterConfig.hpp"
+#include "fintamath/config/ExpressionConfig.hpp"
+
+namespace fintamath {
+
+Config::Config() {
+  static const PrecisionConfig precisionConfig;
+  static const ParserConfig parserConfig;
+  static const ConverterConfig converterConfig;
+  static const ExpressionConfig expressionConfig;
+}
+
+}
diff --git a/src/fintamath/config/ConverterConfig.cpp b/src/fintamath/config/ConverterConfig.cpp
@@ -1,61 +1,47 @@
-#include "fintamath/core/Converter.hpp"
+#include "fintamath/config/ConverterConfig.hpp"
 
+#include "fintamath/core/Converter.hpp"
 #include "fintamath/numbers/Complex.hpp"
 #include "fintamath/numbers/Integer.hpp"
 #include "fintamath/numbers/Rational.hpp"
 #include "fintamath/numbers/Real.hpp"
 
 namespace fintamath {
 
-MultiMethod<std::unique_ptr<IMathObject>(const IMathObject &, const IMathObject &)> &Converter::getConverter() {
-  static MultiMethod<std::unique_ptr<IMathObject>(const IMathObject &, const IMathObject &)> converter;
-  return converter;
-}
-
+ConverterConfig::ConverterConfig() {
+  Converter::add<Integer, Integer>([](const Integer & /*type*/, const Integer &value) {
+    return Integer(value).clone();
+  });
+
+  Converter::add<Rational, Rational>([](const Rational & /*type*/, const Rational &value) {
+    return Rational(value).clone();
+  });
+  Converter::add<Rational, Integer>([](const Rational & /*type*/, const Integer &value) {
+    return Rational(value).clone();
+  });
+
+  Converter::add<Real, Real>([](const Real & /*type*/, const Real &value) {
+    return Real(value).clone();
+  });
+  Converter::add<Real, Integer>([](const Real & /*type*/, const Integer &value) {
+    return Real(value).clone();
+  });
+  Converter::add<Real, Rational>([](const Real & /*type*/, const Rational &value) {
+    return Real(value).clone();
+  });
+
+  Converter::add<Complex, Complex>([](const Complex & /*type*/, const Complex &value) {
+    return std::make_unique<Complex>(value);
+  });
+  Converter::add<Complex, Integer>([](const Complex & /*type*/, const Integer &value) {
+    return std::make_unique<Complex>(value);
+  });
+  Converter::add<Complex, Rational>([](const Complex & /*type*/, const Rational &value) {
+    return std::make_unique<Complex>(value);
+  });
+  Converter::add<Complex, Real>([](const Complex & /*type*/, const Real &value) {
+    return std::make_unique<Complex>(value);
+  });
 }
 
-using namespace fintamath;
-
-namespace {
-
-struct ConverterConfig final {
-  ConverterConfig() {
-    Converter::add<Integer, Integer>([](const Integer & /*type*/, const Integer &value) {
-      return Integer(value).clone();
-    });
-
-    Converter::add<Rational, Rational>([](const Rational & /*type*/, const Rational &value) {
-      return Rational(value).clone();
-    });
-    Converter::add<Rational, Integer>([](const Rational & /*type*/, const Integer &value) {
-      return Rational(value).clone();
-    });
-
-    Converter::add<Real, Real>([](const Real & /*type*/, const Real &value) {
-      return Real(value).clone();
-    });
-    Converter::add<Real, Integer>([](const Real & /*type*/, const Integer &value) {
-      return Real(value).clone();
-    });
-    Converter::add<Real, Rational>([](const Real & /*type*/, const Rational &value) {
-      return Real(value).clone();
-    });
-
-    Converter::add<Complex, Complex>([](const Complex & /*type*/, const Complex &value) {
-      return std::make_unique<Complex>(value);
-    });
-    Converter::add<Complex, Integer>([](const Complex & /*type*/, const Integer &value) {
-      return std::make_unique<Complex>(value);
-    });
-    Converter::add<Complex, Rational>([](const Complex & /*type*/, const Rational &value) {
-      return std::make_unique<Complex>(value);
-    });
-    Converter::add<Complex, Real>([](const Complex & /*type*/, const Real &value) {
-      return std::make_unique<Complex>(value);
-    });
-  }
-};
-
-const ConverterConfig config;
-
 }
diff --git a/src/fintamath/config/ConverterConfig.hpp b/src/fintamath/config/ConverterConfig.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+namespace fintamath {
+
+struct ConverterConfig final {
+  ConverterConfig();
+};
+
+}