1 files changed, 58 insertions, 63 deletions
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index 80d6d6031d..4c5d08ee46 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -1,83 +1,78 @@
 #pragma once
 
-#include <mbgl/util/geometry.hpp>
+#include <mbgl/tile/tile.hpp>
+#include <mbgl/tile/tile_worker.hpp>
+#include <mbgl/text/placement_config.hpp>
+#include <mbgl/util/atomic.hpp>
 #include <mbgl/util/feature.hpp>
-#include <mbgl/util/chrono.hpp>
-#include <mbgl/util/ptr.hpp>
-#include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/optional.hpp>
-#include <mbgl/util/variant.hpp>
-#include <mbgl/util/constants.hpp>
-
-#include <cstdint>
-#include <string>
-#include <vector>
+
+#include <memory>
 #include <unordered_map>
-#include <functional>
 
 namespace mbgl {
 
-enum class FeatureType : uint8_t {
-    Unknown = 0,
-    Point = 1,
-    LineString = 2,
-    Polygon = 3
-};
-
-class CanonicalTileID;
+class AsyncRequest;
+class GeometryTileData;
+class FeatureIndex;
 
-// Normalized vector tile coordinates.
-// Each geometry coordinate represents a point in a bidimensional space,
-// varying from -V...0...+V, where V is the maximum extent applicable.
-using GeometryCoordinate = Point<int16_t>;
+namespace style {
+class Style;
+}
 
-class GeometryCoordinates : public std::vector<GeometryCoordinate> {
+class GeometryTile : public Tile {
 public:
-    using coordinate_type = int16_t;
-    using std::vector<GeometryCoordinate>::vector;
-};
+    GeometryTile(const OverscaledTileID&,
+                 std::string sourceID,
+                 style::Style&,
+                 const MapMode);
 
-class GeometryCollection : public std::vector<GeometryCoordinates> {
-public:
-    using coordinate_type = int16_t;
-    using std::vector<GeometryCoordinates>::vector;
-};
+    ~GeometryTile();
 
-class GeometryTileFeature : private util::noncopyable {
-public:
-    virtual ~GeometryTileFeature() = default;
-    virtual FeatureType getType() const = 0;
-    virtual optional<Value> getValue(const std::string& key) const = 0;
-    virtual Feature::property_map getProperties() const { return Feature::property_map(); }
-    virtual optional<uint64_t> getID() const { return {}; }
-    virtual GeometryCollection getGeometries() const = 0;
-};
+    void setError(std::exception_ptr err);
 
-class GeometryTileLayer : private util::noncopyable {
-public:
-    virtual ~GeometryTileLayer() = default;
-    virtual std::size_t featureCount() const = 0;
-    virtual util::ptr<const GeometryTileFeature> getFeature(std::size_t) const = 0;
-    virtual std::string getName() const = 0;
-};
+    void setData(std::unique_ptr<GeometryTileData>,
+                 optional<Timestamp> modified_,
+                 optional<Timestamp> expires_);
 
-class GeometryTile : private util::noncopyable {
-public:
-    virtual ~GeometryTile() = default;
-    virtual util::ptr<GeometryTileLayer> getLayer(const std::string&) const = 0;
-};
+    Bucket* getBucket(const style::Layer&) override;
+
+    bool parsePending() override;
+
+    void redoPlacement(PlacementConfig) override;
+
+    void queryRenderedFeatures(
+            std::unordered_map<std::string, std::vector<Feature>>& result,
+            const GeometryCoordinates& queryGeometry,
+            const TransformState&,
+            const optional<std::vector<std::string>>& layerIDs) override;
+
+    void cancel() override;
 
-// classifies an array of rings into polygons with outer rings and holes
-std::vector<GeometryCollection> classifyRings(const GeometryCollection&);
+private:
+    void redoPlacement();
 
-// Truncate polygon to the largest `maxHoles` inner rings by area.
-void limitHoles(GeometryCollection&, uint32_t maxHoles);
+    style::Style& style;
+    Worker& worker;
+    TileWorker tileWorker;
 
-// convert from GeometryTileFeature to Feature (eventually we should eliminate GeometryTileFeature)
-Feature convertFeature(const GeometryTileFeature&, const CanonicalTileID&);
+    std::unique_ptr<AsyncRequest> workRequest;
 
-// Fix up possibly-non-V2-compliant polygon geometry using angus clipper.
-// The result is guaranteed to have correctly wound, strictly simple rings.
-GeometryCollection fixupPolygons(const GeometryCollection&);
+    // Contains all the Bucket objects for the tile. Buckets are render
+    // objects and they get added by tile parsing operations.
+    std::unordered_map<std::string, std::unique_ptr<Bucket>> buckets;
+
+    std::unique_ptr<FeatureIndex> featureIndex;
+    std::unique_ptr<const GeometryTileData> data;
+
+    // Stores the placement configuration of the text that is currently placed on the screen.
+    PlacementConfig placedConfig;
+
+    // Stores the placement configuration of how the text should be placed. This isn't necessarily
+    // the one that is being displayed.
+    PlacementConfig targetConfig;
+
+    // Used to signal the worker that it should abandon parsing this tile as soon as possible.
+    util::Atomic<bool> obsolete { false };
+};
 
 } // namespace mbgl