Makes Rule a shared pointer

headers/modsecurity/rule.h

@@ -100,20 +100,6 @@ class Rule {
     bool containsTag(const std::string& name, Transaction *t);
     bool containsMsg(const std::string& name, Transaction *t);
 
-    int refCountDecreaseAndCheck() {
-        m_referenceCount--;
-        if (m_referenceCount == 0) {
-            delete this;
-            return 1;
-        }
-        return 0;
-    }
-
-
-    void refCountIncrease() {
-        m_referenceCount++;
-    }
-
     void executeTransformations(
         actions::Action *a,
         std::shared_ptr<std::string> newValue,
@@ -140,7 +126,7 @@ class Rule {
     int m_phase;
     modsecurity::variables::Variables *m_variables;
     operators::Operator *m_op;
-    Rule *m_chainedRuleChild;
+    std::unique_ptr<Rule> m_chainedRuleChild;
     Rule *m_chainedRuleParent;
     std::string m_fileName;
     std::string m_marker;
@@ -150,9 +136,9 @@ class Rule {
     std::vector<actions::Action *> m_actionsRuntimePre;
     std::vector<actions::SetVar *> m_actionsSetVar;
     std::vector<actions::Tag *> m_actionsTag;
+
  private:
     bool m_unconditional;
-    int m_referenceCount;
 };
 
 

headers/modsecurity/rules.h

@@ -23,8 +23,10 @@
 #include <string>
 #include <vector>
 #include <list>
+#include <memory>
 #endif
 
+#include "modsecurity/rule.h"
 
 #ifndef HEADERS_MODSECURITY_RULES_H_
 #define HEADERS_MODSECURITY_RULES_H_
@@ -32,10 +34,55 @@
 
 #ifdef __cplusplus
 namespace modsecurity {
-class Rule;
 
-class Rules : public std::vector<Rule *> {
+
+class Rules {
  public:
+    void dump() const {
+        for (int j = 0; j < m_rules.size(); j++) {
+            std::cout << "    Rule ID: " << std::to_string(m_rules.at(j)->m_ruleId);
+            std::cout << "--" << m_rules.at(j) << std::endl;
+        }
+    }
+
+    int append(Rules *from, const std::vector<int64_t> &ids, std::ostringstream *err) {
+         size_t j = 0;
+         for (; j < from->size(); j++) {
+            Rule *rule = from->at(j).get();
+             if (std::binary_search(ids.begin(), ids.end(), rule->m_ruleId)) {
+                 if (err != NULL) {
+                     *err << "Rule id: " << std::to_string(rule->m_ruleId) \
+                        << " is duplicated" << std::endl;
+                 }
+                 return -1;
+             }
+         }
+         m_rules.insert(m_rules.end(), from->m_rules.begin(), from->m_rules.end());
+         return j;
+    }
+
+    bool insert(std::shared_ptr<Rule> rule) {
+        return insert(rule, nullptr, nullptr);
+    }
+
+    bool insert(std::shared_ptr<Rule> rule, const std::vector<int64_t> *ids, std::ostringstream *err) {
+        if (ids != nullptr && std::binary_search(ids->begin(), ids->end(), rule->m_ruleId)) {
+            if (err != nullptr) {
+                *err << "Rule id: " << std::to_string(rule->m_ruleId) \
+                    << " is duplicated" << std::endl;
+            }
+            return false;
+        }
+
+        m_rules.push_back(rule);
+        return true;
+    }
+
+    size_t size() const { return m_rules.size(); }
+    std::shared_ptr<Rule> operator[](int index) const { return m_rules[index]; }
+    std::shared_ptr<Rule> at(int index) const { return m_rules[index]; }
+
+    std::vector<std::shared_ptr<Rule> > m_rules;
 };
 
 

headers/modsecurity/rules_set_phases.h

@@ -39,10 +39,9 @@ class Rule;
 /** @ingroup ModSecurity_CPP_API */
 class RulesSetPhases {
  public:
-
     ~RulesSetPhases();
 
-    bool insert(Rule *rule);
+    bool insert(std::shared_ptr<Rule> rule);
 
     int append(RulesSetPhases *from, std::ostringstream *err);
     void dump() const;