[search] Identity checks for hotels filter.

map/framework.cpp

@@ -1361,6 +1361,9 @@ bool Framework::QueryMayBeSkipped(SearchIntent const & intent, search::SearchPar
   if (lastParams.IsValidPosition() != params.IsValidPosition())
     return false;
 
+  if (!search::hotels_filter::Rule::IsIdentical(lastParams.m_hotelsFilter, params.m_hotelsFilter))
+    return false;
+
   return true;
 }
 

search/hotels_filter.cpp

@@ -42,6 +42,23 @@ void Description::FromFeature(FeatureType & ft)
   }
 }
 
+// Rule --------------------------------------------------------------------------------------------
+// static
+bool Rule::IsIdentical(shared_ptr<Rule> const & lhs, shared_ptr<Rule> const & rhs)
+{
+  if (lhs && !rhs)
+    return false;
+  if (!lhs && rhs)
+    return false;
+
+  if (lhs && rhs && !lhs->IdenticalTo(*rhs))
+    return false;
+
+  return true;
+}
+
+string DebugPrint(Rule const & rule) { return rule.ToString(); }
+
 // HotelsFilter::ScopedFilter ----------------------------------------------------------------------
 HotelsFilter::ScopedFilter::ScopedFilter(MwmSet::MwmId const & mwmId,
                                          Descriptions const & descriptions, shared_ptr<Rule> rule)

search/hotels_filter.hpp

@@ -68,12 +68,18 @@ struct Description
 struct Rule
 {
   virtual ~Rule() = default;
+
+  static bool IsIdentical(shared_ptr<Rule> const & lhs, shared_ptr<Rule> const & rhs);
+
   virtual bool Matches(Description const & d) const = 0;
+  virtual bool IdenticalTo(Rule const & rhs) const = 0;
   virtual string ToString() const = 0;
 };
 
+string DebugPrint(Rule const & rule);
+
 template <typename Field>
-struct EqRule : public Rule
+struct EqRule final : public Rule
 {
   using Value = typename Field::Value;
 
@@ -85,6 +91,12 @@ struct EqRule : public Rule
     return Field::Eq(Field::Select(d), m_value);
   }
 
+  bool IdenticalTo(Rule const & rhs) const override
+  {
+    auto const * r = dynamic_cast<EqRule const *>(&rhs);
+    return r && Field::Eq(r->m_value, m_value);
+  }
+
   string ToString() const override
   {
     ostringstream os;
@@ -96,7 +108,7 @@ struct EqRule : public Rule
 };
 
 template <typename Field>
-struct LtRule : public Rule
+struct LtRule final : public Rule
 {
   using Value = typename Field::Value;
 
@@ -108,6 +120,12 @@ struct LtRule : public Rule
     return Field::Lt(Field::Select(d), m_value);
   }
 
+  bool IdenticalTo(Rule const & rhs) const override
+  {
+    auto const * r = dynamic_cast<LtRule const *>(&rhs);
+    return r && Field::Eq(r->m_value, m_value);
+  }
+
   string ToString() const override
   {
     ostringstream os;
@@ -119,7 +137,37 @@ struct LtRule : public Rule
 };
 
 template <typename Field>
-struct GtRule : public Rule
+struct LeRule final : public Rule
+{
+  using Value = typename Field::Value;
+
+  LeRule(Value value) : m_value(value) {}
+
+  // Rule overrides:
+  bool Matches(Description const & d) const override
+  {
+    auto const value = Field::Select(d);
+    return Field::Lt(value, m_value) || Field::Eq(value, m_value);
+  }
+
+  bool IdenticalTo(Rule const & rhs) const override
+  {
+    auto const * r = dynamic_cast<LeRule const *>(&rhs);
+    return r && Field::Eq(r->m_value, m_value);
+  }
+
+  string ToString() const override
+  {
+    ostringstream os;
+    os << "[ " << Field::Name() << " <= " << m_value << " ]";
+    return os.str();
+  }
+
+  Value const m_value;
+};
+
+template <typename Field>
+struct GtRule final : public Rule
 {
   using Value = typename Field::Value;
 
@@ -131,6 +179,12 @@ struct GtRule : public Rule
     return Field::Gt(Field::Select(d), m_value);
   }
 
+  bool IdenticalTo(Rule const & rhs) const override
+  {
+    auto const * r = dynamic_cast<GtRule const *>(&rhs);
+    return r && Field::Eq(r->m_value, m_value);
+  }
+
   string ToString() const override
   {
     ostringstream os;
@@ -141,7 +195,37 @@ struct GtRule : public Rule
   Value const m_value;
 };
 
-struct AndRule : public Rule
+template <typename Field>
+struct GeRule final : public Rule
+{
+  using Value = typename Field::Value;
+
+  GeRule(Value value) : m_value(value) {}
+
+  // Rule overrides:
+  bool Matches(Description const & d) const override
+  {
+    auto const value = Field::Select(d);
+    return Field::Gt(value, m_value) || Field::Eq(value, m_value);
+  }
+
+  bool IdenticalTo(Rule const & rhs) const override
+  {
+    auto const * r = dynamic_cast<GeRule const *>(&rhs);
+    return r && Field::Eq(r->m_value, m_value);
+  }
+
+  string ToString() const override
+  {
+    ostringstream os;
+    os << "[ " << Field::Name() << " >= " << m_value << " ]";
+    return os.str();
+  }
+
+  Value const m_value;
+};
+
+struct AndRule final : public Rule
 {
   AndRule(shared_ptr<Rule> lhs, shared_ptr<Rule> rhs) : m_lhs(move(lhs)), m_rhs(move(rhs)) {}
 
@@ -156,6 +240,12 @@ struct AndRule : public Rule
     return matches;
   }
 
+  bool IdenticalTo(Rule const & rhs) const override
+  {
+    auto const * r = dynamic_cast<AndRule const *>(&rhs);
+    return r && IsIdentical(m_lhs, r->m_lhs) && IsIdentical(m_rhs, r->m_rhs);
+  }
+
   string ToString() const override
   {
     ostringstream os;
@@ -171,7 +261,7 @@ struct AndRule : public Rule
   shared_ptr<Rule> m_rhs;
 };
 
-struct OrRule : public Rule
+struct OrRule final : public Rule
 {
   OrRule(shared_ptr<Rule> lhs, shared_ptr<Rule> rhs) : m_lhs(move(lhs)), m_rhs(move(rhs)) {}
 
@@ -186,6 +276,12 @@ struct OrRule : public Rule
     return matches;
   }
 
+  bool IdenticalTo(Rule const & rhs) const override
+  {
+    auto const * r = dynamic_cast<OrRule const *>(&rhs);
+    return r && IsIdentical(m_lhs, r->m_lhs) && IsIdentical(m_rhs, r->m_rhs);
+  }
+
   string ToString() const override
   {
     ostringstream os;
@@ -213,12 +309,24 @@ shared_ptr<Rule> Lt(typename Field::Value value)
   return make_shared<LtRule<Field>>(value);
 }
 
+template <typename Field>
+shared_ptr<Rule> Le(typename Field::Value value)
+{
+  return make_shared<LeRule<Field>>(value);
+}
+
 template <typename Field>
 inline shared_ptr<Rule> Gt(typename Field::Value value)
 {
   return make_shared<GtRule<Field>>(value);
 }
 
+template <typename Field>
+shared_ptr<Rule> Ge(typename Field::Value value)
+{
+  return make_shared<GeRule<Field>>(value);
+}
+
 inline shared_ptr<Rule> And(shared_ptr<Rule> lhs, shared_ptr<Rule> rhs)
 {
   return make_shared<AndRule>(lhs, rhs);
@@ -229,18 +337,6 @@ inline shared_ptr<Rule> Or(shared_ptr<Rule> lhs, shared_ptr<Rule> rhs)
   return make_shared<OrRule>(lhs, rhs);
 }
 
-template <typename Field>
-shared_ptr<Rule> Le(typename Field::Value value)
-{
-  return Or(Lt<Field>(value), Eq<Field>(value));
-}
-
-template <typename Field>
-shared_ptr<Rule> Ge(typename Field::Value value)
-{
-  return Or(Gt<Field>(value), Eq<Field>(value));
-}
-
 class HotelsFilter
 {
 public:

search/search_tests/hotels_filter_test.cpp

@@ -0,0 +1,35 @@
+#include "testing/testing.hpp"
+
+#include "search/hotels_filter.hpp"
+
+using namespace search::hotels_filter;
+
+namespace
+{
+UNIT_TEST(HotelsFilter_Identity)
+{
+  {
+    auto const first = And(Or(Eq<Rating>(5.0), Lt<PriceRate>(2)), Ge<Rating>(4.0));
+    auto const second = And(Or(Eq<Rating>(5.0), Lt<PriceRate>(2)), Ge<Rating>(4.0));
+    TEST(first.get(), ());
+    TEST(second.get(), ());
+    TEST(first->IdenticalTo(*second), (*first, *second));
+  }
+
+  {
+    auto const first = And(Gt<Rating>(5.0), Lt<PriceRate>(5));
+    auto const second = And(Lt<PriceRate>(5), Gt<Rating>(5.0));
+    TEST(first.get(), ());
+    TEST(second.get(), ());
+    TEST(!first->IdenticalTo(*second), (*first, *second));
+  }
+
+  {
+    auto const first = Ge<Rating>(1);
+    auto const second = Or(Gt<Rating>(1), Eq<Rating>(1));
+    TEST(first.get(), ());
+    TEST(second.get(), ());
+    TEST(!first->IdenticalTo(*second), (*first, *second));
+  }
+}
+}  // namespace

search/search_tests/search_tests.pro

@@ -19,6 +19,7 @@ macx-*: LIBS *= "-framework IOKit"
 SOURCES += \
     ../../testing/testingmain.cpp \
     algos_tests.cpp \
+    hotels_filter_test.cpp \
     house_detector_tests.cpp \
     house_numbers_matcher_test.cpp \
     interval_set_test.cpp \