Enable the prefetching of aggregated tiles (#1026)

Enable the user to prefetch a list of aggregated tiles.
When the tile does not exists, the prefetch algorithm scans the tree
to find the nearest parent.

Resolves: OLPEDGE-2245

Signed-off-by: Mykhailo Kuchma <[email protected]>

Author: mykhailo-kuchma

olp-cpp-sdk-dataservice-read/include/olp/dataservice/read/PrefetchTilesRequest.h

@@ -149,6 +149,36 @@ class DATASERVICE_READ_API PrefetchTilesRequest final {
     return *this;
   }
 
+  /**
+   * @brief Changes the prefetch behavior when prefetching a list of tiles.
+   *
+   * In case a tile does not exist, the prefetch algorithm searches for the
+   * nearest parent and prefetches it.
+   *
+   * @param data_aggregation_enabled The boolean parameter that enables or
+   * disables the aggregation.
+   *
+   * @note Experimental. API may change.
+   * 
+   * @return A reference to the updated `PrefetchTilesRequest` instance.
+   */
+  inline PrefetchTilesRequest& WithDataAggregationEnabled(
+      bool data_aggregation_enabled) {
+    data_aggregation_enabled_ = data_aggregation_enabled;
+    return *this;
+  }
+
+  /**
+   * @brief Gets the data aggregation flag.
+   *
+   * @note Experimental. API may change.
+   *
+   * @return The data aggregation flag as a boolean value.
+   */
+  inline bool GetDataAggregationEnabled() const {
+    return data_aggregation_enabled_;
+  }
+
   /**
    * @brief Creates a readable format for the request.
    *
@@ -160,9 +190,6 @@ class DATASERVICE_READ_API PrefetchTilesRequest final {
     std::stringstream out;
     out << layer_id << "[" << GetMinLevel() << "/" << GetMaxLevel() << "]"
         << "(" << GetTileKeys().size() << ")";
-    if (catalog_version_) {
-      out << "@" << catalog_version_.get();
-    }
     if (GetBillingTag()) {
       out << "$" << GetBillingTag().get();
     }
@@ -174,8 +201,8 @@ class DATASERVICE_READ_API PrefetchTilesRequest final {
   std::vector<geo::TileKey> tile_keys_;
   unsigned int min_level_{geo::TileKey::LevelCount};
   unsigned int max_level_{geo::TileKey::LevelCount};
-  boost::optional<int64_t> catalog_version_;
   boost::optional<std::string> billing_tag_;
+  bool data_aggregation_enabled_{false};
 };
 
 }  // namespace read

olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.cpp

@@ -270,8 +270,11 @@ client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
         };
 
         auto filter = [=](QueryResult tiles) mutable {
-          return repository.FilterSkippedTiles(
-              request, request_only_input_tiles, std::move(tiles));
+          if (request_only_input_tiles) {
+            return repository.FilterTilesByList(request, std::move(tiles));
+          } else {
+            return repository.FilterTilesByLevel(request, std::move(tiles));
+          }
         };
 
         auto billing_tag = request.GetBillingTag();

olp-cpp-sdk-dataservice-read/src/VolatileLayerClientImpl.cpp

@@ -230,8 +230,11 @@ client::CancellationToken VolatileLayerClientImpl::PrefetchTiles(
         };
 
         auto filter = [=](QueryResult tiles) mutable {
-          return repository.FilterSkippedTiles(
-              request, request_only_input_tiles, std::move(tiles));
+          if (request_only_input_tiles) {
+            return repository.FilterTilesByList(request, std::move(tiles));
+          } else {
+            return repository.FilterTilesByLevel(request, std::move(tiles));
+          }
         };
 
         auto billing_tag = request.GetBillingTag();

olp-cpp-sdk-dataservice-read/src/repositories/PrefetchTilesRepository.cpp

@@ -283,45 +283,89 @@ SubQuadsResponse PrefetchTilesRepository::GetVolatileSubQuads(
   return result;
 }
 
-SubQuadsResult PrefetchTilesRepository::FilterSkippedTiles(
-    const PrefetchTilesRequest& request, bool request_only_input_tiles,
-    SubQuadsResult sub_tiles) {
+SubQuadsResult PrefetchTilesRepository::FilterTilesByLevel(
+    const PrefetchTilesRequest& request, SubQuadsResult tiles) {
   const auto& tile_keys = request.GetTileKeys();
+
   auto skip_tile = [&](const geo::TileKey& tile_key) {
-    if (request_only_input_tiles) {
-      return std::find(tile_keys.begin(), tile_keys.end(), tile_key) ==
-             tile_keys.end();
-    } else if (tile_key.Level() < request.GetMinLevel() ||
-               tile_key.Level() > request.GetMaxLevel()) {
-      // tile outside min/max segment, skip this tile
+    if (tile_key.Level() < request.GetMinLevel()) {
+      return true;
+    }
+
+    if (tile_key.Level() > request.GetMaxLevel()) {
       return true;
-    } else {
-      // tile is not a parent or child for any of requested tiles, skip
-      // this tile
-      return std::find_if(tile_keys.begin(), tile_keys.end(),
-                          [&tile_key](const geo::TileKey& root_key) {
-                            return (root_key.IsParentOf(tile_key) ||
-                                    tile_key.IsParentOf(root_key) ||
-                                    root_key == tile_key);
-                          }) == tile_keys.end();
     }
+
+    return std::find_if(tile_keys.begin(), tile_keys.end(),
+                        [&tile_key](const geo::TileKey& root_key) {
+                          return (root_key.IsParentOf(tile_key) ||
+                                  tile_key.IsParentOf(root_key) ||
+                                  root_key == tile_key);
+                        }) == tile_keys.end();
   };
 
-  for (auto sub_quad_it = sub_tiles.begin(); sub_quad_it != sub_tiles.end();) {
+  for (auto sub_quad_it = tiles.begin(); sub_quad_it != tiles.end();) {
     if (skip_tile(sub_quad_it->first)) {
-      sub_quad_it = sub_tiles.erase(sub_quad_it);
+      sub_quad_it = tiles.erase(sub_quad_it);
     } else {
       ++sub_quad_it;
     }
   }
-  if (request_only_input_tiles) {
+
+  return tiles;
+}
+
+SubQuadsResult PrefetchTilesRepository::FilterTilesByList(
+    const PrefetchTilesRequest& request, SubQuadsResult tiles) {
+  const bool aggregation_enabled = request.GetDataAggregationEnabled();
+
+  const auto& tile_keys = request.GetTileKeys();
+
+  if (!aggregation_enabled) {
+    for (auto it = tiles.begin(); it != tiles.end();) {
+      if (std::find(tile_keys.begin(), tile_keys.end(), it->first) ==
+          tile_keys.end()) {
+        it = tiles.erase(it);
+      } else {
+        ++it;
+      }
+    }
+
     for (const auto& tile : tile_keys) {
-      if (sub_tiles.find(tile) == sub_tiles.end()) {
-        sub_tiles[tile] = "";
+      if (tiles.find(tile) == tiles.end()) {
+        tiles[tile] = "";
       }
     }
+
+  } else {
+    SubQuadsResult result;
+
+    auto append_tile = [&](const geo::TileKey& key) {
+      auto tile_it = tiles.find(key);
+      if (tile_it != tiles.end()) {
+        result[tile_it->first] = tile_it->second;
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    for (const auto& tile : tile_keys) {
+      auto aggregated_tile = tile;
+
+      while (aggregated_tile.IsValid() && !append_tile(aggregated_tile)) {
+        aggregated_tile = aggregated_tile.Parent();
+      }
+
+      if (!aggregated_tile.IsValid()) {
+        result[tile] = "";  // To generate Not Found error
+      }
+    }
+
+    tiles.swap(result);
   }
-  return sub_tiles;
+
+  return tiles;
 }
 
 }  // namespace repository

olp-cpp-sdk-dataservice-read/src/repositories/PrefetchTilesRepository.h

@@ -69,10 +69,34 @@ class PrefetchTilesRepository {
   RootTilesForRequest GetSlicedTiles(const std::vector<geo::TileKey>& tile_keys,
                                      std::uint32_t min, std::uint32_t max);
 
+  /**
+   * @brief Filters the input tiles according to the request.
+   *
+   * Removes tiles that do not belong to the minimum and maximum levels.
+   * Removes tiles that are not a child or a parent of the requested tiles.
+   * 
+   * @param request Your request.
+   * @param tiles The input tiles.
+   *
+   * @returns The modified tiles.
+   */
+  SubQuadsResult FilterTilesByLevel(const PrefetchTilesRequest& request,
+                                    SubQuadsResult tiles);
 
-  SubQuadsResult FilterSkippedTiles(const PrefetchTilesRequest& request,
-                                    bool request_only_input_tiles,
-                                    SubQuadsResult sub_tiles);
+  /**
+   * @brief Filters the input tiles according to the request.
+   *
+   * Removes tiles that are not requested.
+   * Adds tiles that are missing (to notify you that they are not found).
+   * If you requested aggregated tiles, `FilterTilesByList` scans for parents.
+   * 
+   * @param request Your request.
+   * @param tiles The input tiles.
+   *
+   * @returns The modified tiles.
+   */
+  SubQuadsResult FilterTilesByList(const PrefetchTilesRequest& request,
+                                   SubQuadsResult tiles);
 
   SubQuadsResponse GetVersionedSubQuads(geo::TileKey tile, int32_t depth,
                                         std::int64_t version,

tests/integration/olp-cpp-sdk-dataservice-read/VersionedLayerClientTest.cpp

@@ -1519,6 +1519,46 @@ TEST_F(DataserviceReadVersionedLayerClientTest,
   }
 }
 
+TEST_F(DataserviceReadVersionedLayerClientTest, PrefetchAggregatedTile) {
+  constexpr auto kLayerId = "hype-test-prefetch";
+
+  auto client = std::make_shared<read::VersionedLayerClient>(
+      kCatalog, kLayerId, boost::none, settings_);
+
+  {
+    SCOPED_TRACE("Prefetch aggregated tile");
+    const auto requested_tile = geo::TileKey::FromHereTile("23618365");
+
+    EXPECT_CALL(*network_mock_,
+                Send(IsGetRequest(URL_QUADKEYS_92259), _, _, _, _))
+        .WillOnce(ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK),
+                                     HTTP_RESPONSE_QUADKEYS_92259_ROOT_ONLY));
+
+    auto request = read::PrefetchTilesRequest()
+                       .WithTileKeys({requested_tile})
+                       .WithDataAggregationEnabled(true);
+
+    auto promise = std::make_shared<std::promise<PrefetchTilesResponse>>();
+    auto future = promise->get_future();
+    auto token = client->PrefetchTiles(
+        request, [promise](PrefetchTilesResponse response) {
+          promise->set_value(std::move(response));
+        });
+
+    ASSERT_NE(future.wait_for(kWaitTimeout), std::future_status::timeout);
+    PrefetchTilesResponse response = future.get();
+    ASSERT_TRUE(response.IsSuccessful()) << response.GetError().GetMessage();
+    ASSERT_FALSE(response.GetResult().empty());
+
+    const auto& result = response.GetResult();
+    ASSERT_EQ(result.size(), 1);
+
+    const auto& tile_response = result[0];
+    ASSERT_TRUE(tile_response->IsSuccessful());
+    ASSERT_TRUE(tile_response->tile_key_.IsParentOf(requested_tile));
+  }
+}
+
 TEST_F(DataserviceReadVersionedLayerClientTest, PrefetchTilesWrongLevels) {
   constexpr auto kLayerId = "hype-test-prefetch";