Use shared pointers instead of raw

Author: AzizZayed

.github/workflows/cmake-ubuntu.yml

@@ -20,8 +20,8 @@ jobs:
     steps:
     - uses: actions/checkout@v3
 
-    - name: Install dependencies
-      run: | 
+    - name: Install Dependencies
+      run: |
         sudo apt-get update
         sudo apt-get install -y openssl libssl-dev libx11-dev xorg-dev
 

cas/include/cas/data/ExpressionParser.h

@@ -13,7 +13,7 @@ CAS_NAMESPACE
 class ExpressionParser {
 public:
     static ExpressionParser& getInstance();
-    Expression* parse(const std::string& expression, VarSet& variables);
+    ExprPtr parse(const std::string& expression, VarSet& variables);
 
     void setup(std::string& expr);
     bool isValidExpression(const std::string& expr);

cas/include/cas/data/ExpressionProperties.h

@@ -10,10 +10,11 @@
 
 CAS_NAMESPACE
 
+// TODO redesign so this is never copied
+
 class ExpressionProperties {
 public:
     ExpressionProperties(ExpressionType type, std::string name, std::string shortName);
-
     bool operator==(const ExpressionProperties& other) const;
 
     uint16_t getOrder() const;

cas/include/cas/data/VariableMap.h

@@ -12,6 +12,8 @@
 
 CAS_NAMESPACE
 
+// TODO redesign to store std::pairs so iterators can be references
+
 struct LetterMap {
     static const char LETTER_COUNT = 26;
     char letters = 0;

cas/include/cas/node/Abs.h

@@ -11,19 +11,23 @@ CAS_NAMESPACE
 
 class Abs : public BracketExpression {
 public:
-    explicit Abs(Expression* argument);
+    explicit Abs(ExprPtr argument);
 
     Abs() = delete;
 
     ~Abs() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    Abs* clone() override;
+    ExprPtr clone() override;
 
-    Expression* simplified() override;
+    ExprPtr simplified() override;
 
     std::string text() override;
+
+    static ExprPtr from(ExprPtr argument) {
+        return std::make_shared<Abs>(argument);
+    }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/BracketExpression.h

@@ -15,9 +15,9 @@ class BracketExpression : public UnaryExpression {
 
     ~BracketExpression() override = default;
 
-    bool _equals(Expression* other) override;
+    bool _equals(ExprPtr other) override;
 
-    Expression* derivative(char var) override;
+    ExprPtr derivative(char var) override;
 
     std::string latex() override;
 
@@ -28,7 +28,7 @@ class BracketExpression : public UnaryExpression {
     std::string explicitText() override;
 
 protected:
-    explicit BracketExpression(const ExpressionProperties& properties, Expression* argument,
+    explicit BracketExpression(const ExpressionProperties& properties, ExprPtr argument,
                                const wchar_t* openBracket, const wchar_t* closeBracket,
                                const char* openBracketLatex, const char* closeBracketLatex);
 

cas/include/cas/node/Cbrt.h

@@ -11,19 +11,21 @@ CAS_NAMESPACE
 
 class Cbrt : public Root {
 public:
-    explicit Cbrt(Expression* base);
+    explicit Cbrt(ExprPtr base);
     Cbrt() = delete;
     ~Cbrt() override = default;
 
     double evaluate(const VariableMap& variables) override;
-    Cbrt* clone() override;
-    Expression* _derivative(char variable) override;
-    Expression* simplified() override;
+    ExprPtr clone() override;
+    ExprPtr _derivative(char variable) override;
+    ExprPtr simplified() override;
 
     std::string latex() override;
     std::wstring stringify() override;
     std::string text() override;
     std::string explicitText() override;
+
+    static CbrtPtr from(ExprPtr base) { return std::make_shared<Cbrt>(base); }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Ceil.h

@@ -11,17 +11,21 @@ CAS_NAMESPACE
 
 class Ceil : public BracketExpression {
 public:
-    explicit Ceil(Expression* argument);
+    explicit Ceil(ExprPtr argument);
 
     Ceil() = delete;
 
     ~Ceil() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    Ceil* clone() override;
+    ExprPtr clone() override;
 
-    Expression* simplified() override;
+    ExprPtr simplified() override;
+
+    static ExprPtr from(ExprPtr argument) {
+        return std::make_shared<Ceil>(argument);
+    }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Const.h

@@ -1,6 +1,7 @@
 //
 // Created by Abd-El-Aziz Zayed on 2022-08-26.
 //
+
 #ifndef CAS_CONSTANT_H
 #define CAS_CONSTANT_H
 
@@ -9,23 +10,21 @@
 
 CAS_NAMESPACE
 
-class Const : public Expression {
+class Const : public Expr {
 public:
     explicit Const(double value);
-
-    explicit Const() : Const(0.0){};
-
+    Const() = delete;
     ~Const() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    bool _equals(Expression* expression) override;
+    bool _equals(ExprPtr expression) override;
 
-    Const* clone() override;
+    ExprPtr clone() override;
 
-    Const* _derivative(char var) override;
+    ExprPtr _derivative(char var) override;
 
-    Const* simplified() override;
+    ExprPtr simplified() override;
 
     std::string latex() override;
 
@@ -35,17 +34,18 @@ class Const : public Expression {
 
     double getValue() const { return value; }
 
-    static Const* PI() { return new Const{math::PI}; }
+    static ConstPtr PI() { return n(math::PI); }
 
-    static Const* E() { return new Const{math::E}; }
+    static ConstPtr E() { return n(math::E); }
 
-    static Const* PHI() { return new Const{math::PHI}; }
+    static ConstPtr PHI() { return n(math::PHI); }
 
-    static Const* zero() { return new Const; }
+    static ConstPtr zero() { return n(0.0); }
 
-    static Const* one() { return new Const{1.0}; }
+    static ConstPtr one() { return n(1.0); }
 
-    static Const* n(double value) { return new Const{value}; }
+    static ConstPtr n(double value) { return std::make_shared<Const>(value); }
+    static ConstPtr from(double value) { return n(value); }
 
     static bool floatingsEqual(double a, double b) {
         double max = std::max(1.0, std::max(std::fabs(a), std::fabs(b)));

cas/include/cas/node/Divide.h

@@ -10,23 +10,22 @@
 
 CAS_NAMESPACE
 
-class Divide : public Expression {
+class Divide : public Expr {
 public:
-    explicit Divide(Expression* dividend, Expression* divisor);
-
     Divide() = delete;
+    explicit Divide(ExprPtr dividend, ExprPtr divisor);
 
-    ~Divide() override;
+    ~Divide() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    bool _equals(Expression* expression) override;
+    bool _equals(ExprPtr expression) override;
 
-    Divide* clone() override;
+    ExprPtr clone() override;
 
-    Divide* _derivative(char var) override;
+    ExprPtr _derivative(char var) override;
 
-    Expression* simplified() override;
+    ExprPtr simplified() override;
 
     std::string latex() override;
 
@@ -36,12 +35,17 @@ class Divide : public Expression {
 
     std::string explicitText() override;
 
-    Expression* getDividend() const { return dividend; }
-    Expression* getDivisor() const { return divisor; }
+    static DividePtr from(ExprPtr dividend, ExprPtr divisor) { return std::make_shared<Divide>(dividend, divisor); }
+
+    ExprPtr getDividend() const { return dividend; }
+    ExprPtr getDivisor() const { return divisor; }
+
+private:
+    void setParents();
 
 private:
-    Expression* dividend;
-    Expression* divisor;
+    ExprPtr dividend;
+    ExprPtr divisor;
 };
 
 CAS_NAMESPACE_END