Rework condition merging

[poefilter.git] / source / condition.cpp

diff --git a/source/condition.cpp b/source/condition.cpp
index be5a29f4d11df67cf5785a5938514574701d48b4..42e9ee8f3f1360829d2b518d9d22e99a569f0a69 100644 (file)
--- a/source/condition.cpp
+++ b/source/condition.cpp
@@ -21,6 +21,76 @@ void CompoundCondition::add(Condition *cond)
        conditions.push_back(cond);
 }
 
+const Condition *CompoundCondition::get(unsigned i) const
+{
+       if(i>=conditions.size())
+               throw out_of_range("CompoundCondition::get");
+       return conditions[i];
+}
+
+Condition *CompoundCondition::flatten() const
+{
+       if(conditions.empty())
+               return 0;
+       else if(conditions.size()==1)
+               return conditions.front()->clone();
+
+       bool merge = true;
+       for(vector<Condition *>::const_iterator i=conditions.begin(); (merge && ++i!=conditions.end()); )
+               merge = conditions.front()->can_merge(**i, *this);
+
+       if(merge)
+               return conditions.front()->merge(conditions, *this);
+       else
+       {
+               Condition *result = 0;
+               for(vector<Condition *>::const_iterator i=conditions.begin(); i!=conditions.end(); ++i)
+               {
+                       Condition *sub = (*i)->flatten();
+                       if(!result)
+                               result = sub;
+                       else
+                               result = dispatch_flatten(result, sub);
+               }
+
+               return result;
+       }
+}
+
+Condition *CompoundCondition::dispatch_flatten(Condition *cond1, Condition *cond2) const
+{
+       OrCondition *or1 = dynamic_cast<OrCondition *>(cond1);
+       AndCondition *and1 = dynamic_cast<AndCondition *>(cond1);
+       OrCondition *or2 = dynamic_cast<OrCondition *>(cond2);
+       AndCondition *and2 = dynamic_cast<AndCondition *>(cond2);
+       if(or1 || or2)
+       {
+               if(or1 && or2)
+                       return flatten(or1, or2);
+               else if(or1 && and2)
+                       return flatten(or1, and2);
+               else if(or2 && and1)
+                       return flatten(or2, and1);
+               else if(or1)
+                       return flatten(or1, cond2);
+               else if(or2)
+                       return flatten(or2, cond1);
+       }
+       else if(and1 || and2)
+       {
+               if(and1 && and2)
+                       return flatten(and1, and2);
+               else if(and1)
+                       return flatten(and1, cond2);
+               else if(and2)
+                       return flatten(and2, cond1);
+       }
+       else
+               return flatten(cond1, cond2);
+
+       throw logic_error("CompoundCondition::dispatch_flatten");
+}
+
 
 AndCondition *AndCondition::clone() const
 {
@@ -29,6 +99,57 @@ AndCondition *AndCondition::clone() const
        return result;
 }
 
+Condition *AndCondition::flatten(Condition *cond1, Condition *cond2) const
+{
+       AndCondition *result = new AndCondition;
+       result->add(cond1);
+       result->add(cond2);
+       return result;
+}
+
+Condition *AndCondition::flatten(AndCondition *cond1, Condition *cond2) const
+{
+       cond1->add(cond2);
+       return cond1;
+}
+
+Condition *AndCondition::flatten(AndCondition *cond1, AndCondition *cond2) const
+{
+       unsigned count2 = cond2->count();
+       for(unsigned i=0; i<count2; ++i)
+               cond1->add(cond2->get(i)->clone());
+       delete cond2;
+       return cond1;
+}
+
+Condition *AndCondition::flatten(OrCondition *cond1, Condition *cond2) const
+{
+       OrCondition *result = new OrCondition;
+       unsigned count = cond1->count();
+       for(unsigned i=0; i<count; ++i)
+               result->add(dispatch_flatten(cond1->get(i)->clone(), (i+1<count ? cond2->clone() : cond2)));
+       delete cond1;
+       return result;
+}
+
+Condition *AndCondition::flatten(OrCondition *cond1, AndCondition *cond2) const
+{
+       return flatten(cond1, static_cast<Condition *>(cond2));
+}
+
+Condition *AndCondition::flatten(OrCondition *cond1, OrCondition *cond2) const
+{
+       unsigned count1 = cond1->count();
+       unsigned count2 = cond2->count();
+       OrCondition *result = new OrCondition;
+       for(unsigned i=0; i<count1; ++i)
+               for(unsigned j=0; j<count2; ++j)
+                       result->add(dispatch_flatten(cond1->get(i)->clone(), cond2->get(j)->clone()));
+       delete cond1;
+       delete cond2;
+       return result;
+}
+
 void AndCondition::add_lines(list<FilterStatement> &st) const
 {
        for(vector<Condition *>::const_iterator i=conditions.begin(); i!=conditions.end(); ++i)
@@ -43,25 +164,54 @@ OrCondition *OrCondition::clone() const
        return result;
 }
 
-void OrCondition::add_lines(list<FilterStatement> &st) const
+Condition *OrCondition::flatten(Condition *cond1, Condition *cond2) const
 {
-       bool merge = conditions.size()>1;
-       for(vector<Condition *>::const_iterator i=conditions.begin(); (merge && ++i!=conditions.end()); )
-               merge = conditions.front()->can_merge(**i, *this);
+       OrCondition *result = new OrCondition;
+       result->add(cond1);
+       result->add(cond2);
+       return result;
+}
 
-       if(merge)
-               conditions.front()->add_merged_lines(conditions, *this, st);
-       else
+Condition *OrCondition::flatten(AndCondition *cond1, Condition *cond2) const
+{
+       return flatten(static_cast<Condition *>(cond1), cond2);
+}
+
+Condition *OrCondition::flatten(AndCondition *cond1, AndCondition *cond2) const
+{
+       return flatten(static_cast<Condition *>(cond1), static_cast<Condition *>(cond2));
+}
+
+Condition *OrCondition::flatten(OrCondition *cond1, Condition *cond2) const
+{
+       cond1->add(cond2);
+       return cond1;
+}
+
+Condition *OrCondition::flatten(OrCondition *cond1, AndCondition *cond2) const
+{
+       return flatten(cond1, static_cast<Condition *>(cond2));
+}
+
+Condition *OrCondition::flatten(OrCondition *cond1, OrCondition *cond2) const
+{
+       unsigned count2 = cond2->count();
+       for(unsigned i=0; i<count2; ++i)
+               cond1->add(cond2->get(i)->clone());
+       delete cond2;
+       return cond1;
+}
+
+void OrCondition::add_lines(list<FilterStatement> &st) const
+{
+       list<FilterStatement> result;
+       for(vector<Condition *>::const_iterator i=conditions.begin(); i!=conditions.end(); ++i)
        {
-               list<FilterStatement> result;
-               for(vector<Condition *>::const_iterator i=conditions.begin(); i!=conditions.end(); ++i)
-               {
-                       list<FilterStatement> sub_result = st;
-                       (*i)->add_lines(sub_result);
-                       result.splice(result.end(), sub_result);
-               }
-               swap(result, st);
+               list<FilterStatement> sub_result = st;
+               (*i)->add_lines(sub_result);
+               result.splice(result.end(), sub_result);
        }
+       swap(result, st);
 }