Correctly merge icon and light beam appearances

[poefilter.git] / source / condition.cpp

diff --git a/source/condition.cpp b/source/condition.cpp
index 6d383eafb278bf6592b1bca5447e1506d56fb541..5978250243f6e51b6fb1ebadeadbbd401f5003bf 100644 (file)
--- a/source/condition.cpp
+++ b/source/condition.cpp
@@ -16,6 +16,18 @@ void CompoundCondition::clone_to(CompoundCondition &other) const
                other.add((*i)->clone());
 }
 
+bool CompoundCondition::sub_equals(const CompoundCondition &other) const
+{
+       if(other.count()!=conditions.size())
+               return false;
+
+       for(unsigned i=0; i<conditions.size(); ++i)
+               if(!conditions[i]->equals(other.get(i)))
+                       return false;
+
+       return true;
+}
+
 void CompoundCondition::add(Condition *cond)
 {
        if(!cond)
@@ -171,6 +183,12 @@ AndCondition *AndCondition::clone() const
        return result;
 }
 
+bool AndCondition::equals(const Condition &other) const
+{
+       const AndCondition *other_and = dynamic_cast<const AndCondition *>(&other);
+       return (other_and ? sub_equals(*other_and) : false);
+}
+
 Condition *AndCondition::flatten(Condition *cond1, Condition *cond2) const
 {
        if(cond1->can_merge(*cond2, *this))
@@ -198,7 +216,7 @@ Condition *AndCondition::flatten(OrCondition *cond1, Condition *cond2) const
        unsigned count = cond1->count();
        for(unsigned i=0; i<count; ++i)
                if(Condition *sub = dispatch_flatten(cond1->get(i).clone(), (i+1<count ? cond2->clone() : cond2)))
-                       result->add(sub);
+                       add_merged_to(sub, result, true);
        delete cond1;
 
        if(result->is_viable())
@@ -221,7 +239,7 @@ Condition *AndCondition::flatten(OrCondition *cond1, OrCondition *cond2) const
        for(unsigned i=0; i<count1; ++i)
                for(unsigned j=0; j<count2; ++j)
                        if(Condition *sub = dispatch_flatten(cond1->get(i).clone(), cond2->get(j).clone()))
-                               result->add(sub);
+                               add_merged_to(sub, result, true);
 
        delete cond1;
        delete cond2;
@@ -233,6 +251,82 @@ Condition *AndCondition::flatten(OrCondition *cond1, OrCondition *cond2) const
        return 0;
 }
 
+bool AndCondition::can_merge(const Condition &other, const CompoundCondition &parent) const
+{
+       const AndCondition *other_and = dynamic_cast<const AndCondition *>(&other);
+       if(!other_and || !dynamic_cast<const OrCondition *>(&parent))
+               return false;
+
+       return merge(*this, *other_and, parent, 0);
+}
+
+AndCondition *AndCondition::merge(const vector<const Condition *> &conds, const CompoundCondition &parent) const
+{
+       if(conds.size()!=2)
+               return 0;
+
+       const AndCondition *and1 = dynamic_cast<const AndCondition *>(conds[0]);
+       const AndCondition *and2 = dynamic_cast<const AndCondition *>(conds[1]);
+       if(!and1 || !and2 || !dynamic_cast<const OrCondition *>(&parent))
+               return 0;
+
+       AndCondition *result = 0;
+       merge(*and1, *and2, parent, &result);
+       return result;
+}
+
+bool AndCondition::merge(const AndCondition &cond1, const AndCondition &cond2, const CompoundCondition &parent, AndCondition **result)
+{
+       if(cond1.count()!=cond2.count())
+               return false;
+
+       int merge1 = -1;
+       vector<bool> used(cond1.count(), false);
+       for(unsigned i=0; i<cond1.count(); ++i)
+       {
+               int match = -1;
+               for(unsigned j=0; (match<0 && j<cond2.count()); ++j)
+                       if(!used[j] && cond1.get(i).equals(cond2.get(j)))
+                               match = j;
+
+               if(match>=0)
+                       used[match] = true;
+               else if(merge1<0)
+                       merge1 = i;
+               else
+                       return false;
+       }
+
+       if(merge1>=0)
+       {
+               vector<const Condition *> merge_conds(2, 0);
+               merge_conds[0] = &cond1.get(merge1);
+               for(unsigned i=0; (!merge_conds[1] && i<cond2.count()); ++i)
+                       if(!used[i])
+                               merge_conds[1] = &cond2.get(i);
+
+               if(!merge_conds[1] || !merge_conds[0]->can_merge(*merge_conds[1], parent))
+                       return false;
+
+               if(result)
+               {
+                       *result = new AndCondition;
+                       (*result)->add(merge_conds[0]->merge(merge_conds, parent));
+               }
+       }
+       else if(result)
+               *result = new AndCondition;
+
+       if(result)
+       {
+               for(unsigned i=0; i<cond2.count(); ++i)
+                       if(used[i])
+                               (*result)->add(cond2.get(i).clone());
+       }
+
+       return true;
+}
+
 bool AndCondition::is_viable() const
 {
        for(vector<Condition *>::const_iterator i=conditions.begin(); i!=conditions.end(); ++i)
@@ -255,6 +349,12 @@ OrCondition *OrCondition::clone() const
        return result;
 }
 
+bool OrCondition::equals(const Condition &other) const
+{
+       const OrCondition *other_or = dynamic_cast<const OrCondition *>(&other);
+       return (other_or ? sub_equals(*other_or) : false);
+}
+
 Condition *OrCondition::flatten(Condition *cond1, Condition *cond2) const
 {
        if(cond1->can_merge(*cond2, *this))
@@ -321,6 +421,23 @@ LinkedColorsCondition *LinkedColorsCondition::clone() const
        return new LinkedColorsCondition(colors);
 }
 
+bool LinkedColorsCondition::equals(const Condition &other) const
+{
+       const LinkedColorsCondition *other_linked = dynamic_cast<const LinkedColorsCondition *>(&other);
+       if(!other_linked)
+               return false;
+
+       for(unsigned i=0; i<7; ++i)
+       {
+               if(colors.colors[i]!=other_linked->colors.colors[i])
+                       return false;
+               if(!colors.colors[i])
+                       break;
+       }
+
+       return true;
+}
+
 void LinkedColorsCondition::add_lines(list<FilterStatement> &st) const
 {
        FilterStatement::add_line(st, format("SocketGroup %s", colors.colors));