Complete implementation of get_ranges for recurse to cover corner case.

Author: drolbr

src/overpass_api/data/collect_members.cc

@@ -314,91 +314,6 @@ std::vector< Uint31_Index > relation_relation_member_indices
 }
 
 
-template< typename Relation_Skeleton >
-std::set< std::pair< Uint32_Index, Uint32_Index > > relation_node_member_indices
-    (const Statement* stmt, Resource_Manager& rman,
-     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_begin,
-     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_end)
-{
-  std::vector< uint32 > parents;
-  
-  for (typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator
-      it = rels_begin; it != rels_end; ++it)
-  {
-    if ((it->first.val() & 0x80000000) && ((it->first.val() & 0x3) == 0))
-    {
-      // Treat relations with really large indices: get the node indexes from the segement indexes
-      for (typename std::vector< Relation_Skeleton >::const_iterator it2 = it->second.begin();
-          it2 != it->second.end(); ++it2)
-      {
-	for (std::vector< Uint31_Index >::const_iterator it3 = it2->node_idxs.begin();
-	    it3 != it2->node_idxs.end(); ++it3)
-	  parents.push_back(it3->val());
-      }
-    }
-    else
-      parents.push_back(it->first.val());
-  }    
-  if (stmt)
-    rman.health_check(*stmt);
-  
-  return collect_node_req(stmt, rman, std::vector< Node::Id_Type >(), parents);
-}
-
-
-template< typename Relation_Skeleton >
-std::set< std::pair< Uint32_Index, Uint32_Index > > relation_node_member_indices
-    (const Statement* stmt, Resource_Manager& rman,
-     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_begin,
-     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_end,
-     typename std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator
-         attic_rels_begin,
-     typename std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator
-         attic_rels_end)
-{
-  std::vector< uint32 > parents;
-  
-  for (typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator
-      it = rels_begin; it != rels_end; ++it)
-  {
-    if ((it->first.val() & 0x80000000) && ((it->first.val() & 0x3) == 0))
-    {
-      // Treat relations with really large indices: get the node indexes from the segement indexes
-      for (typename std::vector< Relation_Skeleton >::const_iterator it2 = it->second.begin();
-          it2 != it->second.end(); ++it2)
-      {
-        for (std::vector< Uint31_Index >::const_iterator it3 = it2->node_idxs.begin();
-            it3 != it2->node_idxs.end(); ++it3)
-          parents.push_back(it3->val());
-      }
-    }
-    else
-      parents.push_back(it->first.val());
-  }    
-  for (typename std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator
-      it = attic_rels_begin; it != attic_rels_end; ++it)
-  {
-    if ((it->first.val() & 0x80000000) && ((it->first.val() & 0x3) == 0))
-    {
-      // Treat relations with really large indices: get the node indexes from the segement indexes
-      for (typename std::vector< Attic< Relation_Skeleton > >::const_iterator it2 = it->second.begin();
-          it2 != it->second.end(); ++it2)
-      {
-        for (std::vector< Uint31_Index >::const_iterator it3 = it2->node_idxs.begin();
-            it3 != it2->node_idxs.end(); ++it3)
-          parents.push_back(it3->val());
-      }
-    }
-    else
-      parents.push_back(it->first.val());
-  }    
-  if (stmt)
-    rman.health_check(*stmt);
-  
-  return collect_node_req(stmt, rman, std::vector< Node::Id_Type >(), parents);
-}
-
-
 std::set< std::pair< Uint32_Index, Uint32_Index > > way_nd_indices
     (const Statement* stmt, Resource_Manager& rman,
      std::map< Uint31_Index, std::vector< Way_Skeleton > >::const_iterator ways_begin,

src/overpass_api/data/collect_members.h

@@ -852,4 +852,122 @@ std::vector< Uint31_Index > relation_way_member_indices
 }
 
 
+std::vector< Uint31_Index > relation_relation_member_indices
+    (const Statement& stmt, Resource_Manager& rman,
+     std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_begin,
+     std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_end);
+
+
+std::vector< Uint31_Index > relation_relation_member_indices
+    (const Statement& stmt, Resource_Manager& rman,
+     std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_begin,
+     std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_end,
+     std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator attic_rels_begin,
+     std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator attic_rels_end);
+
+
+std::set< std::pair< Uint32_Index, Uint32_Index > > collect_node_req
+    (const Statement* stmt, Resource_Manager& rman,
+     const std::vector< Node::Id_Type >& map_ids, const std::vector< uint32 >& parents);
+    
+    
+template< typename Relation_Skeleton >
+std::set< std::pair< Uint32_Index, Uint32_Index > > relation_node_member_indices
+    (const Statement* stmt, Resource_Manager& rman,
+     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_begin,
+     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_end)
+{
+  std::vector< uint32 > parents;
+  
+  for (typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator
+      it = rels_begin; it != rels_end; ++it)
+  {
+    if ((it->first.val() & 0x80000000) && ((it->first.val() & 0x3) == 0))
+    {
+      // Treat relations with really large indices: get the node indexes from the segement indexes
+      for (typename std::vector< Relation_Skeleton >::const_iterator it2 = it->second.begin();
+          it2 != it->second.end(); ++it2)
+      {
+	for (std::vector< Uint31_Index >::const_iterator it3 = it2->node_idxs.begin();
+	    it3 != it2->node_idxs.end(); ++it3)
+	  parents.push_back(it3->val());
+      }
+    }
+    else
+      parents.push_back(it->first.val());
+  }    
+  if (stmt)
+    rman.health_check(*stmt);
+  
+  return collect_node_req(stmt, rman, std::vector< Node::Id_Type >(), parents);
+}
+
+
+template< typename Relation_Skeleton >
+std::set< std::pair< Uint32_Index, Uint32_Index > > relation_node_member_indices
+    (const Statement* stmt, Resource_Manager& rman,
+     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_begin,
+     typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator rels_end,
+     typename std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator
+         attic_rels_begin,
+     typename std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator
+         attic_rels_end)
+{
+  std::vector< uint32 > parents;
+  
+  for (typename std::map< Uint31_Index, std::vector< Relation_Skeleton > >::const_iterator
+      it = rels_begin; it != rels_end; ++it)
+  {
+    if ((it->first.val() & 0x80000000) && ((it->first.val() & 0x3) == 0))
+    {
+      // Treat relations with really large indices: get the node indexes from the segement indexes
+      for (typename std::vector< Relation_Skeleton >::const_iterator it2 = it->second.begin();
+          it2 != it->second.end(); ++it2)
+      {
+        for (std::vector< Uint31_Index >::const_iterator it3 = it2->node_idxs.begin();
+            it3 != it2->node_idxs.end(); ++it3)
+          parents.push_back(it3->val());
+      }
+    }
+    else
+      parents.push_back(it->first.val());
+  }    
+  for (typename std::map< Uint31_Index, std::vector< Attic< Relation_Skeleton > > >::const_iterator
+      it = attic_rels_begin; it != attic_rels_end; ++it)
+  {
+    if ((it->first.val() & 0x80000000) && ((it->first.val() & 0x3) == 0))
+    {
+      // Treat relations with really large indices: get the node indexes from the segement indexes
+      for (typename std::vector< Attic< Relation_Skeleton > >::const_iterator it2 = it->second.begin();
+          it2 != it->second.end(); ++it2)
+      {
+        for (std::vector< Uint31_Index >::const_iterator it3 = it2->node_idxs.begin();
+            it3 != it2->node_idxs.end(); ++it3)
+          parents.push_back(it3->val());
+      }
+    }
+    else
+      parents.push_back(it->first.val());
+  }    
+  if (stmt)
+    rman.health_check(*stmt);
+  
+  return collect_node_req(stmt, rman, std::vector< Node::Id_Type >(), parents);
+}
+
+
+std::set< std::pair< Uint32_Index, Uint32_Index > > way_nd_indices
+    (const Statement* stmt, Resource_Manager& rman,
+     std::map< Uint31_Index, std::vector< Way_Skeleton > >::const_iterator ways_begin,
+     std::map< Uint31_Index, std::vector< Way_Skeleton > >::const_iterator ways_end);
+
+
+std::set< std::pair< Uint32_Index, Uint32_Index > > way_nd_indices
+    (const Statement* stmt, Resource_Manager& rman,
+     std::map< Uint31_Index, std::vector< Way_Skeleton > >::const_iterator ways_begin,
+     std::map< Uint31_Index, std::vector< Way_Skeleton > >::const_iterator ways_end,
+     std::map< Uint31_Index, std::vector< Attic< Way_Skeleton > > >::const_iterator attic_ways_begin,
+     std::map< Uint31_Index, std::vector< Attic< Way_Skeleton > > >::const_iterator attic_ways_end);
+
+
 #endif

src/overpass_api/statements/recurse.cc

@@ -1158,8 +1158,7 @@ class Recurse_Constraint : public Query_Constraint
     virtual bool get_ranges
         (Resource_Manager& rman, set< pair< Uint31_Index, Uint31_Index > >& ranges);
     virtual bool get_ranges
-        (Resource_Manager& rman, set< pair< Uint32_Index, Uint32_Index > >& ranges)
-      { return false; }
+        (Resource_Manager& rman, set< pair< Uint32_Index, Uint32_Index > >& ranges);
 
     bool delivers_data(Resource_Manager& rman) { return true; }
 
@@ -1181,6 +1180,67 @@ class Recurse_Constraint : public Query_Constraint
 };
 
 
+bool Recurse_Constraint::get_ranges(Resource_Manager& rman, set< pair< Uint32_Index, Uint32_Index > >& ranges)
+{
+  ranges.clear();
+  
+  map< string, Set >::const_iterator mit = rman.sets().find(stmt->get_input());
+  if (mit == rman.sets().end())
+  {
+    return true;
+  }
+
+  uint64 timestamp = rman.get_desired_timestamp();
+  if (timestamp == 0)
+    timestamp = NOW;
+  
+  if (timestamp == NOW)
+  {
+    if (stmt->get_type() == RECURSE_RELATION_NODE)
+    {
+      relation_node_member_indices< Relation_Skeleton >(
+          stmt, rman, mit->second.relations.begin(), mit->second.relations.end()).swap(ranges);
+      
+      return true;
+    }
+    else if (stmt->get_type() == RECURSE_WAY_NODE)
+    {
+      way_nd_indices(stmt, rman, mit->second.ways.begin(), mit->second.ways.end()).swap(ranges);
+      
+      return true;
+    }
+    else if (stmt->get_type() == RECURSE_DOWN)
+      return false;
+    else if (stmt->get_type() == RECURSE_DOWN_REL)
+      return false;
+  }
+  else
+  {
+    if (stmt->get_type() == RECURSE_RELATION_NODE)
+    {
+      relation_node_member_indices< Relation_Skeleton >(
+          stmt, rman, mit->second.relations.begin(), mit->second.relations.end(),
+          mit->second.attic_relations.begin(), mit->second.attic_relations.end()).swap(ranges);
+      
+      return true;
+    }
+    else if (stmt->get_type() == RECURSE_WAY_NODE)
+    {
+      way_nd_indices(stmt, rman, mit->second.ways.begin(), mit->second.ways.end(),
+          mit->second.attic_ways.begin(), mit->second.attic_ways.end()).swap(ranges);
+      
+      return true;
+    }
+    else if (stmt->get_type() == RECURSE_DOWN)
+      return false;
+    else if (stmt->get_type() == RECURSE_DOWN_REL)
+      return false;
+  }
+  
+  return false;
+}
+
+
 bool Recurse_Constraint::get_ranges(Resource_Manager& rman, set< pair< Uint31_Index, Uint31_Index > >& ranges)
 {
   ranges.clear();
@@ -1212,12 +1272,22 @@ bool Recurse_Constraint::get_ranges(Resource_Manager& rman, set< pair< Uint31_In
       return false;
     else if (stmt->get_type() == RECURSE_DOWN_REL)
       return false;
-    else if (stmt->get_type() == RECURSE_NODE_WAY)
-      return false;
-    else if (stmt->get_type() == RECURSE_NODE_RELATION)
-      return false;
+    else if (stmt->get_type() == RECURSE_NODE_WAY || stmt->get_type() == RECURSE_NODE_RELATION)
+    {
+      std::set< Uint31_Index > req = extract_parent_indices(mit->second.nodes);
+      for (std::set< Uint31_Index >::const_iterator it = req.begin(); it != req.end(); ++it)
+        ranges.insert(std::make_pair(*it, inc(*it)));
+      
+      return true;
+    }
     else if (stmt->get_type() == RECURSE_WAY_RELATION)
-      return false;
+    {
+      std::set< Uint31_Index > req = extract_parent_indices(mit->second.ways);
+      for (std::set< Uint31_Index >::const_iterator it = req.begin(); it != req.end(); ++it)
+        ranges.insert(std::make_pair(*it, inc(*it)));
+      
+      return true;
+    }
     else if (stmt->get_type() == RECURSE_RELATION_BACKWARDS)
       return false;
     else if (stmt->get_type() == RECURSE_UP)
@@ -1245,12 +1315,28 @@ bool Recurse_Constraint::get_ranges(Resource_Manager& rman, set< pair< Uint31_In
       return false;
     else if (stmt->get_type() == RECURSE_DOWN_REL)
       return false;
-    else if (stmt->get_type() == RECURSE_NODE_WAY)
-      return false;
-    else if (stmt->get_type() == RECURSE_NODE_RELATION)
-      return false;
+    else if (stmt->get_type() == RECURSE_NODE_WAY || stmt->get_type() == RECURSE_NODE_RELATION)
+    {
+      std::set< Uint31_Index > req = extract_parent_indices(mit->second.nodes);
+      for (std::set< Uint31_Index >::const_iterator it = req.begin(); it != req.end(); ++it)
+        ranges.insert(std::make_pair(*it, inc(*it)));
+      std::set< Uint31_Index > attic_req = extract_parent_indices(mit->second.attic_nodes);
+      for (std::set< Uint31_Index >::const_iterator it = attic_req.begin(); it != attic_req.end(); ++it)
+        ranges.insert(std::make_pair(*it, inc(*it)));
+      
+      return true;
+    }
     else if (stmt->get_type() == RECURSE_WAY_RELATION)
-      return false;
+    {
+      std::set< Uint31_Index > req = extract_parent_indices(mit->second.ways);
+      for (std::set< Uint31_Index >::const_iterator it = req.begin(); it != req.end(); ++it)
+        ranges.insert(std::make_pair(*it, inc(*it)));
+      std::set< Uint31_Index > attic_req = extract_parent_indices(mit->second.attic_ways);
+      for (std::set< Uint31_Index >::const_iterator it = attic_req.begin(); it != attic_req.end(); ++it)
+        ranges.insert(std::make_pair(*it, inc(*it)));
+      
+      return true;
+    }
     else if (stmt->get_type() == RECURSE_RELATION_BACKWARDS)
       return false;
     else if (stmt->get_type() == RECURSE_UP)