Separate monoidal part of strict layers

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Remove explicit unused Scaffeine dependency from projects [#3314](https://github.com/locationtech/geotrellis/pull/3314)
 - Remove an excessive close after the abort call in S3RangeReader [#3324](https://github.com/locationtech/geotrellis/pull/3324)
 - Fix sigmoidal contrast calculation [#3328](https://github.com/locationtech/geotrellis/pull/3328)
+- Separated monoidal component of `vectortile.StrictLayer` [#3330](https://github.com/locationtech/geotrellis/pull/3330)
 
 ## [3.5.1] - 2020-11-23
 

vectortile/src/main/scala/geotrellis/vectortile/Layer.scala

@@ -215,13 +215,40 @@ ${sortedMeta.map({ case (k,v) => s"            ${k}: ${v}"}).mkString("\n")}
   tileWidth: Int,
   version: Int,
   tileExtent: Extent,
-  points: Seq[MVTFeature[Point]],
-  multiPoints: Seq[MVTFeature[MultiPoint]],
-  lines: Seq[MVTFeature[LineString]],
-  multiLines: Seq[MVTFeature[MultiLineString]],
-  polygons: Seq[MVTFeature[Polygon]],
-  multiPolygons: Seq[MVTFeature[MultiPolygon]]
-) extends Layer
+  mvtFeatures: MVTFeatures
+) extends Layer {
+  def points = mvtFeatures.points
+  def multiPoints = mvtFeatures.multiPoints
+  def lines = mvtFeatures.lines
+  def multiLines = mvtFeatures.multiLines
+  def polygons = mvtFeatures.polygons
+  def multiPolygons = mvtFeatures.multiPolygons
+}
+
+object StrictLayer {
+  def apply(
+    name: String,
+    tileWidth: Int,
+    version: Int,
+    tileExtent: Extent,
+    points: Seq[MVTFeature[Point]],
+    multiPoints: Seq[MVTFeature[MultiPoint]],
+    lines: Seq[MVTFeature[LineString]],
+    multiLines: Seq[MVTFeature[MultiLineString]],
+    polygons: Seq[MVTFeature[Polygon]],
+    multiPolygons: Seq[MVTFeature[MultiPolygon]]
+  ): StrictLayer = StrictLayer(
+    name, tileWidth, version, tileExtent,
+    MVTFeatures(
+      points,
+      multiPoints,
+      lines,
+      multiLines,
+      polygons,
+      multiPolygons
+    )
+  )
+}
 
 /**
   * A [[Layer]] decoded from Protobuf data. All of its Features are decoded
@@ -374,12 +401,14 @@ ${sortedMeta.map({ case (k,v) => s"            ${k}: ${v}"}).mkString("\n")}
       tileWidth,
       version,
       tileExtent,
-      points,
-      multiPoints,
-      lines,
-      multiLines,
-      polygons,
-      multiPolygons
+      MVTFeatures(
+        points,
+        multiPoints,
+        lines,
+        multiLines,
+        polygons,
+        multiPolygons
+      )
     )
   }
 }

vectortile/src/main/scala/geotrellis/vectortile/MVTFeatures.scala

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2019 Azavea
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package geotrellis.vectortile
+
+import geotrellis.vector.{
+    Point,
+    MultiPoint,
+    LineString,
+    MultiLineString,
+    Polygon,
+    MultiPolygon
+}
+import cats.Monoid
+
+/** Container case class for collections of [[MVTFeature]]s
+  *
+  * This is separated for ease of use when reading geometries from
+  * places. With the `Monoid` instance for `MVTFeatures`, each geometry
+  * can be lifted into a seq in the relevant attribute, and then
+  * the separate `MVTFeatures` case classes can all be combined.
+  */
+final case class MVTFeatures(
+  /** Every Point Feature in this Layer. */
+  points: Seq[MVTFeature[Point]],
+  /** Every MultiPoint Feature in this Layer. */
+  multiPoints: Seq[MVTFeature[MultiPoint]],
+  /** Every Line Feature in this Layer. */
+  lines: Seq[MVTFeature[LineString]],
+  /** Every MultiLine Feature in this Layer. */
+  multiLines: Seq[MVTFeature[MultiLineString]],
+  /** Every Polygon Feature in this Layer. */
+  polygons: Seq[MVTFeature[Polygon]],
+  /** Every MultiPolygon Feature in this Layer. */
+  multiPolygons: Seq[MVTFeature[MultiPolygon]]
+)
+
+object MVTFeatures {
+  implicit val monoidMVTFeatures: Monoid[MVTFeatures] = new Monoid[MVTFeatures] {
+    def empty: MVTFeatures = MVTFeatures(Nil, Nil, Nil, Nil, Nil, Nil)
+
+    def combine(x: MVTFeatures, y: MVTFeatures): MVTFeatures = MVTFeatures(
+      x.points ++ y.points,
+      x.multiPoints ++ y.multiPoints,
+      x.lines ++ y.lines,
+      x.multiLines ++ y.multiLines,
+      x.polygons ++ y.polygons,
+      x.multiPolygons ++ y.multiPolygons
+    )
+  }
+}

vectortile/src/test/scala/geotrellis/vectortile/ProjectionSpec.scala

@@ -35,12 +35,14 @@ class ProjectionSpec extends AnyFunSpec {
         tileWidth = 128,
         version = 2,
         tileExtent = tileExtent,
-        points = Seq(f),
-        multiPoints = Seq.empty,
-        lines = Seq.empty,
-        multiLines = Seq.empty,
-        polygons = Seq.empty,
-        multiPolygons = Seq.empty
+        MVTFeatures(
+          points = Seq(f),
+          multiPoints = Seq.empty,
+          lines = Seq.empty,
+          multiLines = Seq.empty,
+          polygons = Seq.empty,
+          multiPolygons = Seq.empty
+        )
       )
 
       val vt = VectorTile(Map("test" -> layer), tileExtent)

vectortile/src/test/scala/geotrellis/vectortile/ProtobufTileSpec.scala

@@ -45,7 +45,7 @@ class ProtobufTileSpec extends AnyFunSpec with Matchers {
       val layerId = "x"
       val mvtFeature = MVTFeature(Some(1), Point(10, 10), Map.empty)
       val layer = StrictLayer(layerId, 4096, 2, tileExtent,
-                              Seq(mvtFeature), Seq(), Seq(), Seq(), Seq(), Seq())
+                              MVTFeatures(Seq(mvtFeature), Nil, Nil, Nil, Nil, Nil))
       val tile = VectorTile(Map(layerId -> layer), tileExtent)
       val tile2 = VectorTile.fromBytes(tile.toBytes, tileExtent)
       val tileId = tile.layers(layerId).points.head.id
@@ -62,7 +62,7 @@ class ProtobufTileSpec extends AnyFunSpec with Matchers {
         "population" -> VInt64(6)
       ))
       val layer = StrictLayer(layerId, 4096, 2, tileExtent,
-                              Seq(mvtFeature), Seq(), Seq(), Seq(), Seq(), Seq())
+                              MVTFeatures(Seq(mvtFeature), Nil, Nil, Nil, Nil, Nil))
       val tile = VectorTile(Map(layerId -> layer), tileExtent)
       val tile2 = VectorTile.fromBytes(tile.toBytes, tileExtent)
       val tileId = tile.layers(layerId).points.head.data.toList.foreach {