You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@baremaps.apache.org by bc...@apache.org on 2024/06/24 23:01:11 UTC
(incubator-baremaps) 01/05: Add support for flatgeobuf
This is an automated email from the ASF dual-hosted git repository.
bchapuis pushed a commit to branch flatgeobuf
in repository https://gitbox.apache.org/repos/asf/incubator-baremaps.git
commit 1f71d24e5c16a4a65bf532d5873ac28a8f09806d
Author: Bertil Chapuis <bc...@gmail.com>
AuthorDate: Mon Jun 17 13:36:37 2024 +0200
Add support for flatgeobuf
---
baremaps-core/pom.xml | 4 +
baremaps-flatgeobuf/pom.xml | 29 ++
.../baremaps/flatgeobuf/BoundedInputStream.java | 74 ++++
.../org/apache/baremaps/flatgeobuf/BufferUtil.java | 133 +++++++
.../org/apache/baremaps/flatgeobuf/Constants.java | 37 ++
.../baremaps/flatgeobuf/FeatureMetaIterator.java | 85 ++++
.../org/apache/baremaps/flatgeobuf/FlatGeoBuf.java | 231 +++++++++++
.../baremaps/flatgeobuf/FlatGeoBufReader.java | 131 ++++++
.../baremaps/flatgeobuf/FlatGeoBufWriter.java | 160 ++++++++
.../baremaps/flatgeobuf/GeometryConversions.java | 353 ++++++++++++++++
.../baremaps/flatgeobuf/GeometryOffsets.java | 30 ++
.../org/apache/baremaps/flatgeobuf/NodeItem.java | 82 ++++
.../apache/baremaps/flatgeobuf/PackedRTree.java | 443 +++++++++++++++++++++
.../baremaps/flatgeobuf/generated/Column.java | 233 +++++++++++
.../baremaps/flatgeobuf/generated/ColumnType.java | 46 +++
.../apache/baremaps/flatgeobuf/generated/Crs.java | 185 +++++++++
.../baremaps/flatgeobuf/generated/Feature.java | 188 +++++++++
.../baremaps/flatgeobuf/generated/Geometry.java | 397 ++++++++++++++++++
.../flatgeobuf/generated/GeometryType.java | 51 +++
.../baremaps/flatgeobuf/generated/Header.java | 340 ++++++++++++++++
.../src/main/resources/fbs/feature.fbs | 22 +
.../src/main/resources/fbs/header.fbs | 84 ++++
.../apache/baremaps/flatgeobuf/BufferUtilTest.java | 127 ++++++
.../apache/baremaps/flatgeobuf/FlatGeoBufTest.java | 76 ++++
baremaps-testing/pom.xml | 6 +
pom.xml | 5 +-
scripts/generate-flatgeobuf.sh | 6 +
27 files changed, 3554 insertions(+), 4 deletions(-)
diff --git a/baremaps-core/pom.xml b/baremaps-core/pom.xml
index 28fc6af3..b5c39796 100644
--- a/baremaps-core/pom.xml
+++ b/baremaps-core/pom.xml
@@ -146,6 +146,10 @@ limitations under the License.
<groupId>org.wololo</groupId>
<artifactId>flatgeobuf</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.wololo</groupId>
+ <artifactId>flatgeobuf</artifactId>
+ </dependency>
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
diff --git a/baremaps-flatgeobuf/pom.xml b/baremaps-flatgeobuf/pom.xml
new file mode 100644
index 00000000..e1955007
--- /dev/null
+++ b/baremaps-flatgeobuf/pom.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.apache.baremaps</groupId>
+ <artifactId>baremaps</artifactId>
+ <version>0.7.4-SNAPSHOT</version>
+ </parent>
+ <artifactId>baremaps-flatgeobuf</artifactId>
+ <dependencies>
+ <dependency>
+ <groupId>com.google.flatbuffers</groupId>
+ <artifactId>flatbuffers-java</artifactId>
+ <version>24.3.25</version>
+ </dependency>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.baremaps</groupId>
+ <artifactId>baremaps-testing</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.locationtech.jts</groupId>
+ <artifactId>jts-core</artifactId>
+ </dependency>
+ </dependencies>
+</project>
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/BoundedInputStream.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/BoundedInputStream.java
new file mode 100644
index 00000000..38b91bf5
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/BoundedInputStream.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class BoundedInputStream extends InputStream {
+ private final InputStream in;
+ private long remaining;
+
+ public BoundedInputStream(InputStream in, long size) {
+ this.in = in;
+ this.remaining = size;
+ }
+
+ @Override
+ public int read() throws IOException {
+ if (remaining == 0) {
+ return -1;
+ }
+ int result = in.read();
+ if (result != -1) {
+ remaining--;
+ }
+ return result;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ if (remaining == 0) {
+ return -1;
+ }
+ int toRead = (int) Math.min(len, remaining);
+ int result = in.read(b, off, toRead);
+ if (result != -1) {
+ remaining -= result;
+ }
+ return result;
+ }
+
+ @Override
+ public long skip(long n) throws IOException {
+ long toSkip = Math.min(n, remaining);
+ long skipped = in.skip(toSkip);
+ remaining -= skipped;
+ return skipped;
+ }
+
+ @Override
+ public int available() throws IOException {
+ return (int) Math.min(in.available(), remaining);
+ }
+
+ @Override
+ public void close() throws IOException {
+ in.close();
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/BufferUtil.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/BufferUtil.java
new file mode 100644
index 00000000..5530a340
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/BufferUtil.java
@@ -0,0 +1,133 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.ReadableByteChannel;
+
+public class BufferUtil {
+
+ private BufferUtil() {
+ // Prevent instantiation
+ }
+
+ public static ByteBuffer createByteBuffer(int capacity, ByteOrder order) {
+ ByteBuffer buffer = ByteBuffer.allocate(capacity).order(order);
+ buffer.flip();
+ return buffer;
+ }
+
+ /**
+ * Skips the given number of bytes from the specified channel, accounting for the bytes already in
+ * the buffer.
+ *
+ * @param channel the channel to skip bytes from
+ * @param buffer the buffer to use
+ * @param bytesToSkip the number of bytes to skip
+ * @return the buffer after skipping the specified number of bytes
+ * @throws IOException if an I/O error occurs while reading from the channel
+ */
+ public static ByteBuffer skipBytes(ReadableByteChannel channel, ByteBuffer buffer,
+ long bytesToSkip) throws IOException {
+ if (channel == null || buffer == null) {
+ throw new IllegalArgumentException("Channel and buffer must not be null");
+ }
+
+ if (bytesToSkip < 0) {
+ throw new IllegalArgumentException("The number of bytes to skip must be non-negative");
+ }
+
+ // If the buffer already has `bytesToSkip` or more bytes remaining, simply adjust the position.
+ if (buffer.remaining() >= bytesToSkip) {
+ buffer.position(buffer.position() + (int) bytesToSkip);
+ return buffer;
+ }
+
+ // Calculate the number of bytes we still need to skip after accounting for the buffer's
+ // remaining bytes.
+ long remainingBytesToSkip = bytesToSkip - buffer.remaining();
+
+ // Clear the buffer to prepare it for reading.
+ buffer.clear();
+
+ // Skip bytes directly from the channel.
+ while (remainingBytesToSkip > 0) {
+ // Read into the buffer to discard the data.
+ int bytesRead = channel.read(buffer);
+ if (bytesRead == -1) {
+ break; // End of channel reached
+ }
+ remainingBytesToSkip -= bytesRead;
+ buffer.clear();
+ }
+
+ return buffer;
+ }
+
+ /**
+ * Prepares the given buffer for reading at least `n` bytes from the specified channel.
+ *
+ * @param channel the channel to read bytes from
+ * @param buffer the buffer to prepare for reading
+ * @param bytesToRead the minimum number of bytes the buffer should contain
+ * @return a ByteBuffer that contains at least `n` bytes read from the channel
+ * @throws IOException if an I/O error occurs while reading from the channel
+ */
+ public static ByteBuffer readBytes(ReadableByteChannel channel, ByteBuffer buffer,
+ int bytesToRead) throws IOException {
+ if (channel == null || buffer == null) {
+ throw new IllegalArgumentException("Channel and buffer must not be null");
+ }
+
+ if (bytesToRead < 0) {
+ throw new IllegalArgumentException("The number of bytes to read must be non-negative");
+ }
+
+ // If the buffer already has `n` or more bytes remaining, it will be returned as is.
+ if (buffer.remaining() >= bytesToRead) {
+ return buffer;
+ }
+
+ // If the buffer has sufficient capacity but fewer than `n` bytes remaining, compact it and read
+ // more bytes.
+ if (buffer.capacity() >= bytesToRead) {
+ buffer.compact();
+ while (buffer.position() < bytesToRead) {
+ if (channel.read(buffer) == -1) {
+ break; // End of channel reached
+ }
+ }
+ buffer.flip();
+ return buffer;
+ }
+
+ // If the buffer has insufficient capacity, allocate a new buffer with the required capacity.
+ ByteBuffer newBuffer = ByteBuffer.allocate(bytesToRead).order(buffer.order());
+ buffer.flip();
+ newBuffer.put(buffer);
+ while (newBuffer.position() < bytesToRead) {
+ if (channel.read(newBuffer) == -1) {
+ break; // End of channel reached
+ }
+ }
+ newBuffer.flip();
+ return newBuffer;
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/Constants.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/Constants.java
new file mode 100644
index 00000000..1a15e1b7
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/Constants.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import java.nio.ByteBuffer;
+
+public class Constants {
+
+ public static final byte[] MAGIC_BYTES =
+ new byte[] {0x66, 0x67, 0x62, 0x03, 0x66, 0x67, 0x62, 0x00};
+
+ public static boolean isFlatgeobuf(ByteBuffer bb) {
+ return bb.get() == MAGIC_BYTES[0] &&
+ bb.get() == MAGIC_BYTES[1] &&
+ bb.get() == MAGIC_BYTES[2] &&
+ bb.get() == MAGIC_BYTES[3] &&
+ bb.get() == MAGIC_BYTES[4] &&
+ bb.get() == MAGIC_BYTES[5] &&
+ bb.get() == MAGIC_BYTES[6] &&
+ bb.get() == MAGIC_BYTES[7];
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FeatureMetaIterator.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FeatureMetaIterator.java
new file mode 100644
index 00000000..c11b93f6
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FeatureMetaIterator.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+//
+// import java.io.IOException;
+// import java.nio.ByteBuffer;
+// import java.nio.channels.ReadableByteChannel;
+// import java.nio.channels.SeekableByteChannel;
+// import java.util.Iterator;
+// import java.util.NoSuchElementException;
+//
+// public class FeatureMetaIterator implements Iterator<FeatureMeta> {
+//
+// private final HeaderMeta headerMeta;
+//
+// private final ReadableByteChannel channel;
+//
+// private final ByteBuffer buffer;
+//
+// private long cursor = 0;
+//
+// /**
+// * Constructs a row iterator.
+// *
+// * @param channel the channel to read from
+// * @param headerMeta the header meta
+// * @param buffer the buffer to use
+// */
+// public FeatureMetaIterator(
+// SeekableByteChannel channel,
+// HeaderMeta headerMeta,
+// ByteBuffer buffer) {
+// this.channel = channel;
+// this.headerMeta = headerMeta;
+// this.buffer = buffer;
+// }
+//
+// /**
+// * {@inheritDoc}
+// */
+// @Override
+// public boolean hasNext() {
+// return cursor < headerMeta.featuresCount;
+// }
+//
+// /**
+// * {@inheritDoc}
+// */
+// @Override
+// public FeatureMeta next() {
+// try {
+// channel.read(buffer);
+// buffer.flip();
+//
+// var featureSize = buffer.getInt();
+// var featureMeta = FlatGeoBufReader.readFeature(buffer, headerMeta);
+//
+// buffer.position(Integer.BYTES + featureSize);
+// buffer.compact();
+//
+// cursor++;
+//
+// return featureMeta;
+// } catch (IOException e) {
+// throw new NoSuchElementException(e);
+// }
+// }
+//
+// }
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBuf.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBuf.java
new file mode 100644
index 00000000..0a07db14
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBuf.java
@@ -0,0 +1,231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+import org.apache.baremaps.flatgeobuf.FlatGeoBuf.Header.Feature;
+import org.locationtech.jts.geom.Geometry;
+
+public class FlatGeoBuf {
+
+ private FlatGeoBuf() {
+ // Prevent instantiation
+ }
+
+ // Geometry type enumeration
+ public enum GeometryType {
+ UNKNOWN(0),
+ POINT(1),
+ LINESTRING(2),
+ POLYGON(3),
+ MULTIPOINT(4),
+ MULTILINESTRING(5),
+ MULTIPOLYGON(6),
+ GEOMETRYCOLLECTION(7),
+ CIRCULARSTRING(8),
+ COMPOUNDCURVE(9),
+ CURVEPOLYGON(10),
+ MULTICURVE(11),
+ MULTISURFACE(12),
+ CURVE(13),
+ SURFACE(14),
+ POLYHEDRALSURFACE(15),
+ TIN(16),
+ TRIANGLE(17);
+
+ private final int value;
+
+ GeometryType(int value) {
+ this.value = value;
+ }
+
+ public int getValue() {
+ return value;
+ }
+ }
+
+ public enum ColumnType {
+ BYTE,
+ UBYTE,
+ BOOL,
+ SHORT,
+ USHORT,
+ INT,
+ UINT,
+ LONG,
+ ULONG,
+ FLOAT,
+ DOUBLE,
+ STRING,
+ JSON,
+ DATETIME,
+ BINARY
+ }
+
+ public record Column(
+ String name,
+ ColumnType type,
+ String title,
+ String description,
+ int width,
+ int precision,
+ int scale,
+ boolean nullable,
+ boolean unique,
+ boolean primaryKey,
+ String metadata) {
+ }
+
+ public record Crs(
+ String org,
+ int code,
+ String name,
+ String description,
+ String wkt,
+ String codeString) {
+ }
+
+ public record Header(
+ String name,
+ double[] envelope,
+ GeometryType geometryType,
+ boolean hasZ,
+ boolean hasM,
+ boolean hasT,
+ boolean hasTM,
+ List<Column> columns,
+ long featuresCount,
+ int indexNodeSize,
+ Crs crs,
+ String title,
+ String description,
+ String metadata) {
+ public Header {
+ indexNodeSize = indexNodeSize == 0 ? 16 : indexNodeSize;
+ }
+
+ public record Feature(
+ Geometry geometry,
+ List<Object> properties) {
+ }
+ }
+
+ public static Header asHeaderRecord(org.apache.baremaps.flatgeobuf.generated.Header header) {
+ return new Header(
+ header.name(),
+ new double[] {
+ header.envelope(0),
+ header.envelope(1),
+ header.envelope(2),
+ header.envelope(3)
+ },
+ GeometryType.values()[header.geometryType()],
+ header.hasZ(),
+ header.hasM(),
+ header.hasT(),
+ header.hasTm(),
+ IntStream.range(0, header.columnsLength())
+ .mapToObj(header::columns)
+ .map(column -> new Column(
+ column.name(),
+ ColumnType.values()[column.type()],
+ column.title(),
+ column.description(),
+ column.width(),
+ column.precision(),
+ column.scale(),
+ column.nullable(),
+ column.unique(),
+ column.primaryKey(),
+ column.metadata()))
+ .toList(),
+ header.featuresCount(),
+ header.indexNodeSize(),
+ new Crs(
+ header.crs().org(),
+ header.crs().code(),
+ header.crs().name(),
+ header.crs().description(),
+ header.crs().wkt(),
+ header.crs().codeString()),
+ header.title(),
+ header.description(),
+ header.metadata());
+ }
+
+ public static Feature asFeatureRecord(org.apache.baremaps.flatgeobuf.generated.Header header,
+ org.apache.baremaps.flatgeobuf.generated.Feature feature) {
+ var values = new ArrayList<>();
+ if (feature.propertiesLength() > 0) {
+ var propertiesBuffer = feature.propertiesAsByteBuffer();
+ while (propertiesBuffer.hasRemaining()) {
+ var columnPosition = propertiesBuffer.getShort();
+ var columnType = header.columns(columnPosition);
+ var columnValue = readValue(propertiesBuffer, columnType);
+ values.add(columnValue);
+ }
+ }
+ return new Feature(
+ GeometryConversions.readGeometry(feature.geometry(), header.geometryType()),
+ values);
+ }
+
+ private static Object readValue(ByteBuffer buffer,
+ org.apache.baremaps.flatgeobuf.generated.Column column) {
+ return switch (ColumnType.values()[column.type()]) {
+ case BYTE -> buffer.get();
+ case UBYTE -> buffer.get();
+ case BOOL -> buffer.get() == 1;
+ case SHORT -> buffer.getShort();
+ case USHORT -> buffer.getShort();
+ case INT -> buffer.getInt();
+ case UINT -> buffer.getInt();
+ case LONG -> buffer.getLong();
+ case ULONG -> buffer.getLong();
+ case FLOAT -> buffer.getFloat();
+ case DOUBLE -> buffer.getDouble();
+ case STRING -> readString(buffer);
+ case JSON -> readJson(buffer);
+ case DATETIME -> readDateTime(buffer);
+ case BINARY -> readBinary(buffer);
+ };
+ }
+
+ private static Object readString(ByteBuffer buffer) {
+ var length = buffer.getInt();
+ var bytes = new byte[length];
+ buffer.get(bytes);
+ return new String(bytes, StandardCharsets.UTF_8);
+ }
+
+ private static Object readJson(ByteBuffer buffer) {
+ throw new UnsupportedOperationException();
+ }
+
+ private static Object readDateTime(ByteBuffer buffer) {
+ throw new UnsupportedOperationException();
+ }
+
+ private static Object readBinary(ByteBuffer buffer) {
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBufReader.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBufReader.java
new file mode 100644
index 00000000..f59b9397
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBufReader.java
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import org.apache.baremaps.flatgeobuf.generated.Feature;
+import org.apache.baremaps.flatgeobuf.generated.Header;
+
+public class FlatGeoBufReader {
+
+ public static Header readHeader(ReadableByteChannel channel)
+ throws IOException {
+
+ // Check if the file is a flatgeobuf
+ ByteBuffer buffer = BufferUtil.createByteBuffer(12, ByteOrder.LITTLE_ENDIAN);
+ BufferUtil.readBytes(channel, buffer, 12);
+ if (!Constants.isFlatgeobuf(buffer)) {
+ throw new IOException("This is not a flatgeobuf!");
+ }
+
+ // Read the header size
+ int headerSize = buffer.getInt();
+ ByteBuffer headerBuffer = BufferUtil.createByteBuffer(headerSize, ByteOrder.LITTLE_ENDIAN);
+ BufferUtil.readBytes(channel, headerBuffer, headerSize);
+
+ return Header.getRootAsHeader(headerBuffer);
+ }
+
+ public static void skipIndex(ReadableByteChannel channel, Header header)
+ throws IOException {
+ readIndexAsBuffer(channel, header);
+ }
+
+ public static ByteBuffer readIndexAsBuffer(ReadableByteChannel channel, Header header)
+ throws IOException {
+ long indexSize = PackedRTree.calcSize(header.featuresCount(), header.indexNodeSize());
+
+ if (indexSize > 1L << 31) {
+ throw new IOException("Index size is greater than 2GB!");
+ }
+ ByteBuffer buffer = BufferUtil.createByteBuffer((int) indexSize, ByteOrder.LITTLE_ENDIAN);
+ BufferUtil.readBytes(channel, buffer, (int) indexSize);
+
+ return buffer;
+ }
+
+ public static InputStream readIndexAsStream(ReadableByteChannel channel, Header header) {
+ long indexSize = PackedRTree.calcSize(header.featuresCount(), header.indexNodeSize());
+ return new BoundedInputStream(Channels.newInputStream(channel), indexSize);
+ }
+
+ public static Feature readFeature(ReadableByteChannel channel, ByteBuffer buffer)
+ throws IOException {
+ ByteBuffer newBuffer = BufferUtil.readBytes(channel, buffer, 4);
+ int featureSize = newBuffer.getInt();
+ newBuffer = BufferUtil.readBytes(channel, buffer, featureSize);
+ Feature feature = Feature.getRootAsFeature(newBuffer);
+ buffer.position(buffer.position() + featureSize);
+ return feature;
+ }
+
+ // var geometryBuffer = feature.geometry();
+ // var geometry = GeometryConversions.readGeometry(geometryBuffer, geometryBuffer.type());
+ // var properties = new ArrayList<>();
+ // if (feature.propertiesLength() > 0) {
+ // var propertiesBuffer = feature.propertiesAsByteBuffer();
+ // while (propertiesBuffer.hasRemaining()) {
+ // var type = propertiesBuffer.getShort();
+ // var column = header.columns.get(type);
+ // var value = readColumnValue(propertiesBuffer, column);
+ // properties.add(value);
+ // }
+ // }
+ // }
+ //
+ // public static Object readColumnValue(ByteBuffer buffer, ColumnMeta column) {
+ // return switch (column.type()) {
+ // case ColumnType.Byte -> buffer.get();
+ // case ColumnType.Bool -> buffer.get() == 1;
+ // case ColumnType.Short -> buffer.getShort();
+ // case ColumnType.Int -> buffer.getInt();
+ // case ColumnType.Long -> buffer.getLong();
+ // case ColumnType.Float -> buffer.getFloat();
+ // case ColumnType.Double -> buffer.getDouble();
+ // case ColumnType.String -> readColumnString(buffer);
+ // case ColumnType.Json -> readColumnJson(buffer);
+ // case ColumnType.DateTime -> readColumnDateTime(buffer);
+ // case ColumnType.Binary -> readColumnBinary(buffer);
+ // default -> null;
+ // };
+ // }
+ //
+ // public static Object readColumnString(ByteBuffer buffer) {
+ // var length = buffer.getInt();
+ // var bytes = new byte[length];
+ // buffer.get(bytes);
+ // return new String(bytes, StandardCharsets.UTF_8);
+ // }
+ //
+ // public static Object readColumnJson(ByteBuffer buffer) {
+ // throw new UnsupportedOperationException();
+ // }
+ //
+ // public static Object readColumnDateTime(ByteBuffer buffer) {
+ // throw new UnsupportedOperationException();
+ // }
+ //
+ // public static Object readColumnBinary(ByteBuffer buffer) {
+ // throw new UnsupportedOperationException();
+ // }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBufWriter.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBufWriter.java
new file mode 100644
index 00000000..c1872857
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/FlatGeoBufWriter.java
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+//
+// import com.google.flatbuffers.FlatBufferBuilder;
+// import java.io.IOException;
+// import java.io.OutputStream;
+// import java.nio.ByteBuffer;
+// import java.nio.ByteOrder;
+// import java.nio.channels.Channels;
+// import java.nio.channels.WritableByteChannel;
+// import java.nio.charset.StandardCharsets;
+//
+// import org.wololo.flatgeobuf.generated.*;
+//
+// public class FlatGeoBufWriter {
+// public static void writeColumnValue(ByteBuffer buffer, ColumnMeta column, Object value) {
+// switch (column.type()) {
+// case ColumnType.Byte -> buffer.put((byte) value);
+// case ColumnType.Bool -> buffer.put((byte) ((boolean) value ? 1 : 0));
+// case ColumnType.Short -> buffer.putShort((short) value);
+// case ColumnType.Int -> buffer.putInt((int) value);
+// case ColumnType.Long -> buffer.putLong((long) value);
+// case ColumnType.Float -> buffer.putFloat((float) value);
+// case ColumnType.Double -> buffer.putDouble((double) value);
+// case ColumnType.String -> writeColumnString(buffer, value);
+// case ColumnType.Json -> writeColumnJson(buffer, value);
+// case ColumnType.DateTime -> writeColumnDateTime(buffer, value);
+// case ColumnType.Binary -> writeColumnBinary(buffer, value);
+// default -> {
+// // Do nothing
+// }
+// };
+// }
+//
+// public static void writeColumnString(ByteBuffer propertiesBuffer, Object value) {
+// var bytes = ((String) value).getBytes(StandardCharsets.UTF_8);
+// propertiesBuffer.putInt(bytes.length);
+// propertiesBuffer.put(bytes);
+// }
+//
+// public static void writeColumnJson(ByteBuffer propertiesBuffer, Object value) {
+// throw new UnsupportedOperationException();
+// }
+//
+// public static void writeColumnDateTime(ByteBuffer propertiesBuffer, Object value) {
+// throw new UnsupportedOperationException();
+// }
+//
+// public static void writeColumnBinary(ByteBuffer propertiesBuffer, Object value) {
+// throw new UnsupportedOperationException();
+// }
+//
+// public static void writeFeature(
+// OutputStream outputStream, HeaderMeta headerMeta,
+// FeatureMeta featureMeta) throws IOException {
+// var featureBuilder = new FlatBufferBuilder(4096);
+//
+// // Write the properties
+// var propertiesBuffer = ByteBuffer.allocate(1 << 20).order(ByteOrder.LITTLE_ENDIAN);
+// var properties = featureMeta.properties();
+// for (int i = 0; i < properties.size(); i++) {
+// var column = headerMeta.columns.get(i);
+// var value = properties.get(i);
+// propertiesBuffer.putShort((short) i);
+// writeColumnValue(propertiesBuffer, column, value);
+// }
+// if (propertiesBuffer.position() > 0) {
+// propertiesBuffer.flip();
+// }
+// var propertiesOffset = Feature.createPropertiesVector(featureBuilder, propertiesBuffer);
+//
+// // Write the geometry
+// var geometry = featureMeta.geometry();
+// var geometryOffset = 0;
+// if (geometry != null) {
+// geometryOffset =
+// GeometryConversions.writeGeometry(featureBuilder, geometry, headerMeta.geometryType);
+// }
+//
+// // Write the feature
+// var featureOffset = Feature.createFeature(featureBuilder, geometryOffset, propertiesOffset, 0);
+// featureBuilder.finishSizePrefixed(featureOffset);
+//
+// byte[] data = featureBuilder.sizedByteArray();
+// outputStream.write(data);
+// }
+//
+// public static void write(HeaderMeta headerMeta, OutputStream to, FlatBufferBuilder builder)
+// throws IOException {
+// int[] columnsArray = headerMeta.columns.stream().mapToInt(c -> {
+// int nameOffset = builder.createString(c.name());
+// int type = c.type();
+// return Column.createColumn(
+// builder,
+// nameOffset,
+// type,
+// 0,
+// 0,
+// c.width(),
+// c.precision(),
+// c.scale(),
+// c.nullable(),
+// c.unique(),
+// c.primaryKey(),
+// 0);
+// }).toArray();
+// int columnsOffset = Header.createColumnsVector(builder, columnsArray);
+//
+// int nameOffset = 0;
+// if (headerMeta.name != null) {
+// nameOffset = builder.createString(headerMeta.name);
+// }
+// int crsOffset = 0;
+// if (headerMeta.srid != 0) {
+// Crs.startCrs(builder);
+// Crs.addCode(builder, headerMeta.srid);
+// crsOffset = Crs.endCrs(builder);
+// }
+// int envelopeOffset = 0;
+// if (headerMeta.envelope != null) {
+// envelopeOffset = Header.createEnvelopeVector(builder,
+// new double[] {headerMeta.envelope.getMinX(), headerMeta.envelope.getMinY(),
+// headerMeta.envelope.getMaxX(), headerMeta.envelope.getMaxY()});
+// }
+// Header.startHeader(builder);
+// Header.addGeometryType(builder, headerMeta.geometryType);
+// Header.addIndexNodeSize(builder, headerMeta.indexNodeSize);
+// Header.addColumns(builder, columnsOffset);
+// Header.addEnvelope(builder, envelopeOffset);
+// Header.addName(builder, nameOffset);
+// Header.addCrs(builder, crsOffset);
+// Header.addFeaturesCount(builder, headerMeta.featuresCount);
+// int offset = Header.endHeader(builder);
+//
+// builder.finishSizePrefixed(offset);
+//
+// WritableByteChannel channel = Channels.newChannel(to);
+// ByteBuffer dataBuffer = builder.dataBuffer();
+// while (dataBuffer.hasRemaining()) {
+// channel.write(dataBuffer);
+// }
+// }
+// }
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/GeometryConversions.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/GeometryConversions.java
new file mode 100644
index 00000000..359b9e79
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/GeometryConversions.java
@@ -0,0 +1,353 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import com.google.flatbuffers.FlatBufferBuilder;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.function.IntFunction;
+import java.util.function.Supplier;
+import org.apache.baremaps.flatgeobuf.generated.Geometry;
+import org.apache.baremaps.flatgeobuf.generated.GeometryType;
+import org.locationtech.jts.geom.*;
+
+public class GeometryConversions {
+
+ public static GeometryOffsets writeGeometryPart(
+ FlatBufferBuilder builder,
+ org.locationtech.jts.geom.Geometry geometry,
+ int geometryType) throws IOException {
+
+ GeometryOffsets go = new GeometryOffsets();
+
+ if (geometry == null) {
+ return go;
+ }
+
+ if (geometryType == GeometryType.MultiLineString) {
+ int end = 0;
+ MultiLineString mls = (MultiLineString) geometry;
+ if (mls.getNumGeometries() > 1) {
+ go.ends = new long[mls.getNumGeometries()];
+ for (int i = 0; i < mls.getNumGeometries(); i++) {
+ go.ends[i] = end += mls.getGeometryN(i).getNumPoints();
+ }
+ }
+ } else if (geometryType == GeometryType.Polygon) {
+ Polygon p = (Polygon) geometry;
+ go.ends = new long[p.getNumInteriorRing() + 1];
+ int end = p.getExteriorRing().getNumPoints();
+ go.ends[0] = end;
+ for (int i = 0; i < p.getNumInteriorRing(); i++) {
+ go.ends[i + 1] = end += p.getInteriorRingN(i).getNumPoints();
+ }
+ } else if (geometryType == GeometryType.MultiPolygon) {
+ MultiPolygon mp = (MultiPolygon) geometry;
+ int numGeometries = mp.getNumGeometries();
+ GeometryOffsets[] gos = new GeometryOffsets[numGeometries];
+ for (int i = 0; i < numGeometries; i++) {
+ Polygon p = (Polygon) mp.getGeometryN(i);
+ gos[i] = writeGeometryPart(builder, p, GeometryType.Polygon);
+ }
+ go.gos = gos;
+ return go;
+ }
+
+ final int numPoints = geometry.getNumPoints();
+ // build the vector "manually", using a CoordinateSequenceFilter to avoid creating
+ // Coordinate arrays or any Coordinate at all, depending on the underlying
+ // CoordinateSequence implementation. Vector elements ought to be added in reverse order
+ Geometry.startXyVector(builder, 2 * numPoints);
+ ReverseXYCoordinateSequenceFilter filter = new ReverseXYCoordinateSequenceFilter(builder);
+ applyInReverseOrder(geometry, filter);
+ go.coordsOffset = builder.endVector();
+
+ if (filter.hasZ) {
+ Geometry.startZVector(builder, numPoints);
+ applyInReverseOrder(geometry, new OrdinateCoordinateSequenceFilter(builder, 2));
+ go.zOffset = builder.endVector();
+ } else {
+ go.zOffset = 0;
+ }
+
+ if (filter.hasM) {
+ Geometry.startMVector(builder, numPoints);
+ applyInReverseOrder(geometry, new OrdinateCoordinateSequenceFilter(builder, 3));
+ go.mOffset = builder.endVector();
+ } else {
+ go.mOffset = 0;
+ }
+
+ if (go.ends != null) {
+ go.endsOffset = Geometry.createEndsVector(builder, go.ends);
+ }
+
+ go.type = geometryType;
+
+ return go;
+ }
+
+ public static int writeGeometry(FlatBufferBuilder builder,
+ org.locationtech.jts.geom.Geometry geometry, byte geometryType) throws IOException {
+ byte knownGeometryType = geometryType;
+ if (geometryType == GeometryType.Unknown) {
+ knownGeometryType = GeometryConversions.toGeometryType(geometry.getClass());
+ }
+
+ GeometryOffsets go =
+ GeometryConversions.writeGeometryPart(builder, geometry, knownGeometryType);
+
+ int geometryOffset;
+ if (go.gos != null && go.gos.length > 0) {
+ int[] partOffsets = new int[go.gos.length];
+ for (int i = 0; i < go.gos.length; i++) {
+ GeometryOffsets goPart = go.gos[i];
+ int partOffset = Geometry.createGeometry(builder, goPart.endsOffset,
+ goPart.coordsOffset, goPart.zOffset, goPart.mOffset, 0, 0, goPart.type, 0);
+ partOffsets[i] = partOffset;
+ }
+ int partsOffset = Geometry.createPartsVector(builder, partOffsets);
+ geometryOffset = Geometry.createGeometry(builder, 0, 0, 0, 0, 0, 0,
+ geometryType == GeometryType.Unknown ? knownGeometryType : 0, partsOffset);
+ } else {
+ geometryOffset =
+ Geometry.createGeometry(builder, go.endsOffset, go.coordsOffset, go.zOffset, go.mOffset,
+ 0, 0, geometryType == GeometryType.Unknown ? knownGeometryType : 0, 0);
+ }
+ return geometryOffset;
+ }
+
+ /**
+ * Applies the {@code filter} to all {@link org.locationtech.jts.geom.Geometry#getGeometryN(int)
+ * subgeometries} in reverse order if it's a {@link GeometryCollection} or a {@link Polygon} (i.e.
+ * interior rings in reverse order first)
+ */
+ private static void applyInReverseOrder(org.locationtech.jts.geom.Geometry geometry,
+ CoordinateSequenceFilter filter) {
+
+ final int numGeometries = geometry.getNumGeometries();
+ if (numGeometries > 1) {
+ for (int i = numGeometries - 1; i >= 0; i--) {
+ org.locationtech.jts.geom.Geometry sub = geometry.getGeometryN(i);
+ applyInReverseOrder(sub, filter);
+ }
+ } else if (geometry instanceof Polygon) {
+ Polygon p = (Polygon) geometry;
+ for (int i = p.getNumInteriorRing() - 1; i >= 0; i--) {
+ org.locationtech.jts.geom.Geometry hole = p.getInteriorRingN(i);
+ applyInReverseOrder(hole, filter);
+ }
+ applyInReverseOrder(p.getExteriorRing(), filter);
+ } else {
+ geometry.apply(filter);
+ }
+ }
+
+
+ private static class OrdinateCoordinateSequenceFilter implements CoordinateSequenceFilter {
+ private FlatBufferBuilder builder;
+ private final int ordinateIndex;
+
+ OrdinateCoordinateSequenceFilter(FlatBufferBuilder builder, int ordinateIndex) {
+ this.builder = builder;
+ this.ordinateIndex = ordinateIndex;
+ }
+
+ public @Override void filter(final CoordinateSequence seq, final int coordIndex) {
+ int reverseSeqIndex = seq.size() - coordIndex - 1;
+ builder.addDouble(seq.getOrdinate(reverseSeqIndex, ordinateIndex));
+ }
+
+ public @Override boolean isGeometryChanged() {
+ return false;
+ }
+
+ public @Override boolean isDone() {
+ return false;
+ }
+ }
+
+ private static class ReverseXYCoordinateSequenceFilter implements CoordinateSequenceFilter {
+ private FlatBufferBuilder builder;
+ boolean hasZ = false;
+ boolean hasM = false;
+
+ ReverseXYCoordinateSequenceFilter(FlatBufferBuilder builder) {
+ this.builder = builder;
+ }
+
+ public @Override void filter(final CoordinateSequence seq, final int coordIndex) {
+ int reverseSeqIndex = seq.size() - coordIndex - 1;
+ double y = seq.getOrdinate(reverseSeqIndex, 1);
+ double x = seq.getOrdinate(reverseSeqIndex, 0);
+ builder.addDouble(y);
+ builder.addDouble(x);
+ if (!hasZ && seq.hasZ()) {
+ hasZ = true;
+ }
+ if (!hasM && seq.hasM()) {
+ hasM = true;
+ }
+ }
+
+ public boolean isHasZ() {
+ return hasZ;
+ }
+
+ public boolean isHasM() {
+ return hasM;
+ }
+
+ public @Override boolean isGeometryChanged() {
+ return false;
+ }
+
+ public @Override boolean isDone() {
+ return false;
+ }
+ }
+
+ public static org.locationtech.jts.geom.Geometry readGeometry(Geometry geometry,
+ int geometryType) {
+ GeometryFactory factory = new GeometryFactory();
+
+ if (geometryType == GeometryType.MultiPolygon) {
+ int partsLength = geometry.partsLength();
+ Polygon[] polygons = new Polygon[partsLength];
+ for (int i = 0; i < geometry.partsLength(); i++) {
+ polygons[i] = (Polygon) readGeometry(geometry.parts(i), GeometryType.Polygon);
+ }
+ return factory.createMultiPolygon(polygons);
+ }
+
+ int xyLength = geometry.xyLength();
+
+ Coordinate[] coordinates = new Coordinate[xyLength >> 1];
+
+ int c = 0;
+ for (int i = 0; i < xyLength; i = i + 2) {
+ if (c < geometry.mLength()) {
+ coordinates[c++] = new CoordinateXYZM(geometry.xy(i), geometry.xy(i + 1),
+ (i >> 1) < geometry.zLength() ? geometry.z((i >> 1)) : Coordinate.NULL_ORDINATE,
+ (i >> 1) < geometry.mLength() ? geometry.m((i >> 1)) : Coordinate.NULL_ORDINATE);
+ } else {
+ coordinates[c++] = new Coordinate(geometry.xy(i), geometry.xy(i + 1),
+ (i >> 1) < geometry.zLength() ? geometry.z((i >> 1)) : Coordinate.NULL_ORDINATE);
+ }
+ }
+
+ IntFunction<Polygon> makePolygonWithRings = (int endsLength) -> {
+ LinearRing[] lrs = new LinearRing[endsLength];
+ int s = 0;
+ for (int i = 0; i < endsLength; i++) {
+ int e = (int) geometry.ends(i);
+ Coordinate[] cs = Arrays.copyOfRange(coordinates, s, e);
+ lrs[i] = factory.createLinearRing(cs);
+ s = e;
+ }
+ LinearRing shell = lrs[0];
+ LinearRing holes[] = Arrays.copyOfRange(lrs, 1, endsLength);
+ return factory.createPolygon(shell, holes);
+ };
+
+ Supplier<Polygon> makePolygon = () -> {
+ int endsLength = geometry.endsLength();
+ if (endsLength > 1) {
+ return makePolygonWithRings.apply(endsLength);
+ } else {
+ return factory.createPolygon(coordinates);
+ }
+ };
+
+ switch (geometryType) {
+ case GeometryType.Unknown:
+ return null;
+ case GeometryType.Point:
+ if (coordinates.length > 0) {
+ return factory.createPoint(coordinates[0]);
+ } else {
+ return factory.createPoint();
+ }
+ case GeometryType.MultiPoint:
+ return factory.createMultiPointFromCoords(coordinates);
+ case GeometryType.LineString:
+ return factory.createLineString(coordinates);
+ case GeometryType.MultiLineString: {
+ int lengthLengths = geometry.endsLength();
+ if (lengthLengths < 2) {
+ return factory
+ .createMultiLineString(new LineString[] {factory.createLineString(coordinates)});
+ }
+ LineString[] lss = new LineString[lengthLengths];
+ int s = 0;
+ for (int i = 0; i < lengthLengths; i++) {
+ int e = (int) geometry.ends(i);
+ Coordinate[] cs = Arrays.copyOfRange(coordinates, s, e);
+ lss[i] = factory.createLineString(cs);
+ s = e;
+ }
+ return factory.createMultiLineString(lss);
+ }
+ case GeometryType.Polygon:
+ return makePolygon.get();
+ default:
+ throw new RuntimeException("Unknown geometry type");
+ }
+ }
+
+ public static Class<?> getGeometryClass(int geometryType) {
+ switch (geometryType) {
+ case GeometryType.Unknown:
+ return Geometry.class;
+ case GeometryType.Point:
+ return Point.class;
+ case GeometryType.MultiPoint:
+ return MultiPoint.class;
+ case GeometryType.LineString:
+ return LineString.class;
+ case GeometryType.MultiLineString:
+ return MultiLineString.class;
+ case GeometryType.Polygon:
+ return Polygon.class;
+ case GeometryType.MultiPolygon:
+ return MultiPolygon.class;
+ default:
+ throw new RuntimeException("Unknown geometry type");
+ }
+ }
+
+ public static byte toGeometryType(Class<?> geometryClass) {
+ if (geometryClass == org.locationtech.jts.geom.Geometry.class) {
+ return GeometryType.Unknown;
+ } else if (MultiPoint.class.isAssignableFrom(geometryClass)) {
+ return GeometryType.MultiPoint;
+ } else if (Point.class.isAssignableFrom(geometryClass)) {
+ return GeometryType.Point;
+ } else if (MultiLineString.class.isAssignableFrom(geometryClass)) {
+ return GeometryType.MultiLineString;
+ } else if (LineString.class.isAssignableFrom(geometryClass)) {
+ return GeometryType.LineString;
+ } else if (MultiPolygon.class.isAssignableFrom(geometryClass)) {
+ return GeometryType.MultiPolygon;
+ } else if (Polygon.class.isAssignableFrom(geometryClass)) {
+ return GeometryType.Polygon;
+ } else {
+ throw new RuntimeException("Unknown geometry type");
+ }
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/GeometryOffsets.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/GeometryOffsets.java
new file mode 100644
index 00000000..c4c22a43
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/GeometryOffsets.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+public class GeometryOffsets {
+ public int coordsOffset;
+ public int zOffset;
+ public int mOffset;
+ public long[] ends = null;
+ public int[] lengths = null;
+ public int endsOffset = 0;
+ public int lengthsOffset = 0;
+ public int type = 0;
+ public GeometryOffsets[] gos = null;
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/NodeItem.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/NodeItem.java
new file mode 100644
index 00000000..c55a5c51
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/NodeItem.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import org.locationtech.jts.geom.Envelope;
+
+public record NodeItem(
+ double minX,
+ double minY,
+ double maxX,
+ double maxY,
+ long offset) {
+
+ public NodeItem(double minX, double minY, double maxX, double maxY) {
+ this(minX, minY, maxX, maxY, 0);
+ }
+
+ public NodeItem(long offset) {
+ this(
+ Double.POSITIVE_INFINITY,
+ Double.POSITIVE_INFINITY,
+ Double.NEGATIVE_INFINITY,
+ Double.NEGATIVE_INFINITY,
+ offset);
+ }
+
+ public double width() {
+ return maxX - minX;
+ }
+
+ public double height() {
+ return maxY - minY;
+ }
+
+ public static NodeItem sum(NodeItem a, final NodeItem b) {
+ return a.expand(b);
+ }
+
+ public NodeItem expand(final NodeItem nodeItem) {
+ return new NodeItem(
+ Math.min(nodeItem.minX, minX),
+ Math.min(nodeItem.minY, minY),
+ Math.max(nodeItem.maxX, maxX),
+ Math.max(nodeItem.maxY, maxY),
+ offset);
+ }
+
+ public boolean intersects(NodeItem nodeItem) {
+ if (nodeItem.minX > maxX) {
+ return false;
+ }
+ if (nodeItem.minY > maxY) {
+ return false;
+ }
+ if (nodeItem.maxX < minX) {
+ return false;
+ }
+ if (nodeItem.maxY < minY) {
+ return false;
+ }
+ return true;
+ }
+
+ public Envelope toEnvelope() {
+ return new Envelope(minX, maxX, minY, maxY);
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/PackedRTree.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/PackedRTree.java
new file mode 100644
index 00000000..14f8fb56
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/PackedRTree.java
@@ -0,0 +1,443 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import com.google.common.io.LittleEndianDataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.*;
+import org.apache.baremaps.flatgeobuf.generated.Header;
+import org.locationtech.jts.geom.Envelope;
+
+public class PackedRTree {
+
+ private static int NODE_ITEM_LEN = 8 * 4 + 8;
+ final static int HILBERT_MAX = (1 << 16) - 1;
+ private int numItems;
+ private int nodeSize;
+ public NodeItem[] nodeItems;
+ private long numNodes;
+ private List<Pair<Integer, Integer>> levelBounds;
+
+ public PackedRTree(final List<? extends Item> items, final short nodeSize) {
+ this.numItems = items.size();
+ init(nodeSize);
+ int k = (int) (this.numNodes - (long) this.numItems);
+ Iterator<? extends Item> it = items.iterator();
+ for (int i = 0; i < this.numItems; ++i) {
+ this.nodeItems[k++] = it.next().nodeItem;
+ }
+ generateNodes();
+ }
+
+ public void init(int nodeSize) {
+ if (nodeSize < 2)
+ throw new RuntimeException("Node size must be at least 2");
+ if (numItems == 0)
+ throw new RuntimeException("Number of items must be greater than 0");
+ this.nodeSize = Math.min(Math.max(2, nodeSize), HILBERT_MAX);
+ this.levelBounds = generateLevelBounds(numItems, this.nodeSize);
+ this.numNodes = levelBounds.get(0).second;
+ this.nodeItems = new NodeItem[Math.toIntExact(numNodes)];
+ }
+
+ void generateNodes() {
+ long pos;
+ long end = 0;
+ for (short i = 0; i < levelBounds.size() - 1; i++) {
+ pos = levelBounds.get(i).first;
+ end = levelBounds.get(i).second;
+ long newpos = levelBounds.get(i + 1).first;
+ while (pos < end) {
+ NodeItem node = new NodeItem(pos);
+ for (short j = 0; j < this.nodeSize && pos < end; j++)
+ node.expand(nodeItems[(int) pos++]);
+ nodeItems[(int) newpos++] = node;
+ }
+ }
+ }
+
+ public static List<? extends Item> hilbertSort(List<? extends Item> items, NodeItem extent) {
+ double minX = extent.minX();
+ double minY = extent.minY();
+ double width = extent.width();
+ double height = extent.height();
+ Collections.sort(items, (a, b) -> {
+ long ha = hibert(a.nodeItem, HILBERT_MAX, minX, minY, width, height);
+ long hb = hibert(b.nodeItem, HILBERT_MAX, minX, minY, width, height);
+ return (ha - hb) > 0 ? 1 : (ha - hb) == 0 ? 0 : -1;
+ });
+ return items;
+ }
+
+ public static long hibert(NodeItem nodeItem, int hilbertMax, double minX, double minY,
+ double width, double height) {
+ long x = 0;
+ long y = 0;
+ if (width != 0.0)
+ x = (long) Math.floor(hilbertMax * ((nodeItem.minX() + nodeItem.maxX()) / 2 - minX) / width);
+ if (height != 0.0)
+ y = (long) Math.floor(hilbertMax * ((nodeItem.minY() + nodeItem.maxY()) / 2 - minY) / height);
+ return hibert(x, y);
+ }
+
+ // Based on public domain code at https://github.com/rawrunprotected/hilbert_curves
+ private static long hibert(long x, long y) {
+ long a = x ^ y;
+ long b = 0xFFFF ^ a;
+ long c = 0xFFFF ^ (x | y);
+ long d = x & (y ^ 0xFFFF);
+ long A = a | (b >> 1);
+ long B = (a >> 1) ^ a;
+ long C = ((c >> 1) ^ (b & (d >> 1))) ^ c;
+ long D = ((a & (c >> 1)) ^ (d >> 1)) ^ d;
+
+ a = A;
+ b = B;
+ c = C;
+ d = D;
+ A = ((a & (a >> 2)) ^ (b & (b >> 2)));
+ B = ((a & (b >> 2)) ^ (b & ((a ^ b) >> 2)));
+ C ^= ((a & (c >> 2)) ^ (b & (d >> 2)));
+ D ^= ((b & (c >> 2)) ^ ((a ^ b) & (d >> 2)));
+
+ a = A;
+ b = B;
+ c = C;
+ d = D;
+ A = ((a & (a >> 4)) ^ (b & (b >> 4)));
+ B = ((a & (b >> 4)) ^ (b & ((a ^ b) >> 4)));
+ C ^= ((a & (c >> 4)) ^ (b & (d >> 4)));
+ D ^= ((b & (c >> 4)) ^ ((a ^ b) & (d >> 4)));
+
+ a = A;
+ b = B;
+ c = C;
+ d = D;
+ C ^= ((a & (c >> 8)) ^ (b & (d >> 8)));
+ D ^= ((b & (c >> 8)) ^ ((a ^ b) & (d >> 8)));
+
+ a = C ^ (C >> 1);
+ b = D ^ (D >> 1);
+
+ long i0 = x ^ y;
+ long i1 = b | (0xFFFF ^ (i0 | a));
+
+ i0 = (i0 | (i0 << 8)) & 0x00FF00FF;
+ i0 = (i0 | (i0 << 4)) & 0x0F0F0F0F;
+ i0 = (i0 | (i0 << 2)) & 0x33333333;
+ i0 = (i0 | (i0 << 1)) & 0x55555555;
+
+ i1 = (i1 | (i1 << 8)) & 0x00FF00FF;
+ i1 = (i1 | (i1 << 4)) & 0x0F0F0F0F;
+ i1 = (i1 | (i1 << 2)) & 0x33333333;
+ i1 = (i1 | (i1 << 1)) & 0x55555555;
+
+ long value = ((i1 << 1) | i0);
+
+ return value;
+ }
+
+ public static NodeItem calcExtent(List<? extends Item> items) {
+ return items.stream().map(item -> item.nodeItem).reduce(new NodeItem(0),
+ (nodeItem, nodeItem2) -> nodeItem.expand(nodeItem2));
+ }
+
+ public void write(OutputStream outputStream) {
+ // nodeItem 40 Byte
+ ByteBuffer buffer = ByteBuffer.allocate((int) (NODE_ITEM_LEN * numNodes));
+ buffer.order(ByteOrder.LITTLE_ENDIAN);
+ for (NodeItem nodeItem : nodeItems) {
+ buffer.putDouble(nodeItem.minX());
+ buffer.putDouble(nodeItem.minY());
+ buffer.putDouble(nodeItem.maxX());
+ buffer.putDouble(nodeItem.maxY());
+ buffer.putLong(nodeItem.offset());
+ }
+ buffer.flip();
+ try {
+ if (buffer.hasRemaining()) {
+ byte[] arr = new byte[buffer.remaining()];
+ buffer.get(arr);
+ outputStream.write(arr);
+ outputStream.flush();
+ }
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ } finally {
+ buffer.clear();
+ buffer = null;
+ }
+ }
+
+ public static long calcSize(long numItems, int nodeSize) {
+ if (nodeSize < 2)
+ throw new RuntimeException("Node size must be at least 2");
+ if (numItems == 0)
+ throw new RuntimeException("Number of items must be greater than 0");
+ int nodeSizeMin = Math.min(Math.max(nodeSize, 2), 65535);
+ // limit so that resulting size in bytes can be represented by ulong
+ if (numItems > 1 << 56)
+ throw new IndexOutOfBoundsException("Number of items must be less than 2^56");
+ long n = numItems;
+ long numNodes = n;
+ do {
+ n = (n + nodeSizeMin - 1) / nodeSizeMin;
+ numNodes += n;
+ } while (n != 1);
+ return numNodes * NODE_ITEM_LEN;
+ }
+
+ static List<Pair<Integer, Integer>> generateLevelBounds(int numItems, int nodeSize) {
+ if (nodeSize < 2)
+ throw new RuntimeException("Node size must be at least 2");
+ if (numItems == 0)
+ throw new RuntimeException("Number of items must be greater than 0");
+
+ // number of nodes per level in bottom-up order
+ int n = numItems;
+ int numNodes = n;
+ ArrayList<Integer> levelNumNodes = new ArrayList<Integer>();
+ levelNumNodes.add(n);
+ do {
+ n = (n + nodeSize - 1) / nodeSize;
+ numNodes += n;
+ levelNumNodes.add(n);
+ } while (n != 1);
+
+ // offsets per level in reversed storage order (top-down)
+ ArrayList<Integer> levelOffsets = new ArrayList<Integer>();
+ n = numNodes;
+ for (int size : levelNumNodes)
+ levelOffsets.add(n -= size);
+ List<Pair<Integer, Integer>> levelBounds = new LinkedList<>();
+ // bounds per level in reversed storage order (top-down)
+ for (int i = 0; i < levelNumNodes.size(); i++)
+ levelBounds.add(new Pair<>(levelOffsets.get(i), levelOffsets.get(i) + levelNumNodes.get(i)));
+ return levelBounds;
+ }
+
+ private static class QueueItem {
+ public QueueItem(long nodeIndex, int level) {
+ this.nodeIndex = nodeIndex;
+ this.level = level;
+ }
+
+ long nodeIndex;
+ int level;
+ }
+
+ public static class SearchHit {
+ public SearchHit(long offset, long index) {
+ this.offset = offset;
+ this.index = index;
+ }
+
+ public long offset;
+ public long index;
+ }
+
+ public static ArrayList<SearchHit> search(ByteBuffer bb, int start, int numItems, int nodeSize,
+ Envelope rect) {
+ ArrayList<SearchHit> searchHits = new ArrayList<SearchHit>();
+ double minX = rect.getMinX();
+ double minY = rect.getMinY();
+ double maxX = rect.getMaxX();
+ double maxY = rect.getMaxY();
+ List<Pair<Integer, Integer>> levelBounds = generateLevelBounds(numItems, nodeSize);
+ int leafNodesOffset = levelBounds.get(0).first;
+ int numNodes = levelBounds.get(0).second;
+ Deque<QueueItem> queue = new LinkedList<QueueItem>();
+ queue.add(new QueueItem(0, levelBounds.size() - 1));
+ while (queue.size() != 0) {
+ QueueItem stackItem = queue.pop();
+ int nodeIndex = (int) stackItem.nodeIndex;
+ int level = stackItem.level;
+ boolean isLeafNode = nodeIndex >= numNodes - numItems;
+ // find the end index of the node
+ int levelEnd = levelBounds.get(level).second;
+ int end = Math.min(nodeIndex + nodeSize, levelEnd);
+ int nodeStart = start + (nodeIndex * NODE_ITEM_LEN);
+ // int length = end - nodeIndex;
+ // search through child nodes
+ for (int pos = nodeIndex; pos < end; pos++) {
+ int offset = nodeStart + ((pos - nodeIndex) * NODE_ITEM_LEN);
+ double nodeMinX = bb.getDouble(offset + 0);
+ double nodeMinY = bb.getDouble(offset + 8);
+ double nodeMaxX = bb.getDouble(offset + 16);
+ double nodeMaxY = bb.getDouble(offset + 24);
+ if (maxX < nodeMinX)
+ continue;
+ if (maxY < nodeMinY)
+ continue;
+ if (minX > nodeMaxX)
+ continue;
+ if (minY > nodeMaxY)
+ continue;
+ long indexOffset = bb.getLong(offset + 32);
+ if (isLeafNode)
+ searchHits.add(new SearchHit(indexOffset, pos - leafNodesOffset));
+ else
+ queue.add(new QueueItem(indexOffset, level - 1));
+ }
+ }
+ return searchHits;
+ }
+
+ public static class SearchResult {
+ public ArrayList<SearchHit> hits = new ArrayList<SearchHit>();
+ public int pos;
+ }
+
+ public static SearchResult search(InputStream stream, int start, int numItems, int nodeSize,
+ Envelope rect) throws IOException {
+ LittleEndianDataInputStream data = new LittleEndianDataInputStream(stream);
+ int dataPos = 0;
+ int skip;
+ SearchResult searchResult = new SearchResult();
+ double minX = rect.getMinX();
+ double minY = rect.getMinY();
+ double maxX = rect.getMaxX();
+ double maxY = rect.getMaxY();
+ List<Pair<Integer, Integer>> levelBounds = generateLevelBounds(numItems, nodeSize);
+ int leafNodesOffset = levelBounds.get(0).first;
+ int numNodes = levelBounds.get(0).second;
+ Deque<QueueItem> queue = new LinkedList<QueueItem>();
+ queue.add(new QueueItem(0, levelBounds.size() - 1));
+ while (queue.size() != 0) {
+ QueueItem stackItem = queue.pop();
+ int nodeIndex = (int) stackItem.nodeIndex;
+ int level = stackItem.level;
+ boolean isLeafNode = nodeIndex >= numNodes - numItems;
+ // find the end index of the node
+ int levelBound = levelBounds.get(level).second;
+ int end = Math.min(nodeIndex + nodeSize, levelBound);
+ int nodeStart = nodeIndex * NODE_ITEM_LEN;
+ skip = nodeStart - dataPos;
+ if (skip > 0) {
+ skipNBytes(data, skip);
+ dataPos += skip;
+ }
+ // int length = end - nodeIndex;
+ // search through child nodes
+ for (int pos = nodeIndex; pos < end; pos++) {
+ int offset = nodeStart + ((pos - nodeIndex) * NODE_ITEM_LEN);
+ skip = offset - dataPos;
+ if (skip > 0) {
+ skipNBytes(data, skip);
+ dataPos += skip;
+ }
+ double nodeMinX = data.readDouble();
+ dataPos += 8;
+ if (maxX < nodeMinX)
+ continue;
+ double nodeMinY = data.readDouble();
+ dataPos += 8;
+ if (maxY < nodeMinY)
+ continue;
+ double nodeMaxX = data.readDouble();
+ dataPos += 8;
+ if (minX > nodeMaxX)
+ continue;
+ double nodeMaxY = data.readDouble();
+ dataPos += 8;
+ if (minY > nodeMaxY)
+ continue;
+ long indexOffset = data.readLong();
+ dataPos += 8;
+ if (isLeafNode)
+ searchResult.hits.add(new SearchHit(indexOffset, pos - leafNodesOffset));
+ else
+ queue.add(new QueueItem(indexOffset, level - 1));
+ }
+ }
+ searchResult.pos = dataPos;
+ return searchResult;
+ }
+
+ public static long[] readFeatureOffsets(
+ LittleEndianDataInputStream data, long[] fids, Header header)
+ throws IOException {
+
+ long treeSize = calcSize((int) header.featuresCount(), header.indexNodeSize());
+ List<Pair<Integer, Integer>> levelBounds =
+ generateLevelBounds((int) header.featuresCount(), header.indexNodeSize());
+ long bottomLevelOffset = levelBounds.get(0).first * 40;
+
+ long pos = 0;
+ long[] featureOffsets = new long[fids.length];
+ for (int i = 0; i < fids.length; i++) {
+ if (fids[i] > header.featuresCount() - 1)
+ throw new NoSuchElementException();
+ long nodeItemOffset = bottomLevelOffset + (fids[i] * 40);
+ long delta = nodeItemOffset + (8 * 4) - pos;
+ skipNBytes(data, delta);
+ long featureOffset = data.readLong();
+ pos += delta + 8;
+ featureOffsets[i] = featureOffset;
+ }
+ long remainingIndexOffset = treeSize - pos;
+ skipNBytes(data, remainingIndexOffset);
+
+ return featureOffsets;
+ }
+
+ static void skipNBytes(InputStream stream, long skip) throws IOException {
+ long remaining = skip;
+ while (remaining > 0) {
+ remaining -= stream.skip(remaining);
+ }
+ }
+
+ public static class Item {
+ public NodeItem nodeItem;
+ }
+
+ public static class FeatureItem extends Item {
+ public long size;
+ public long offset;
+ }
+
+ static class Pair<T, U> {
+ public T first;
+ public U second;
+
+ public Pair(T first, U second) {
+ this.first = first;
+ this.second = second;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o)
+ return true;
+ if (o == null || getClass() != o.getClass())
+ return false;
+ Pair<?, ?> pair = (Pair<?, ?>) o;
+ return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(first, second);
+ }
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Column.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Column.java
new file mode 100644
index 00000000..02aaf9e2
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Column.java
@@ -0,0 +1,233 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf.generated;
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.Table;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class Column extends Table {
+ public static void ValidateVersion() {
+ Constants.FLATBUFFERS_24_3_25();
+ }
+
+ public static Column getRootAsColumn(ByteBuffer _bb) {
+ return getRootAsColumn(_bb, new Column());
+ }
+
+ public static Column getRootAsColumn(ByteBuffer _bb, Column obj) {
+ _bb.order(ByteOrder.LITTLE_ENDIAN);
+ return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb));
+ }
+
+ public void __init(int _i, ByteBuffer _bb) {
+ __reset(_i, _bb);
+ }
+
+ public Column __assign(int _i, ByteBuffer _bb) {
+ __init(_i, _bb);
+ return this;
+ }
+
+ public String name() {
+ int o = __offset(4);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer nameAsByteBuffer() {
+ return __vector_as_bytebuffer(4, 1);
+ }
+
+ public ByteBuffer nameInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 4, 1);
+ }
+
+ public int type() {
+ int o = __offset(6);
+ return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0;
+ }
+
+ public String title() {
+ int o = __offset(8);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer titleAsByteBuffer() {
+ return __vector_as_bytebuffer(8, 1);
+ }
+
+ public ByteBuffer titleInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 8, 1);
+ }
+
+ public String description() {
+ int o = __offset(10);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer descriptionAsByteBuffer() {
+ return __vector_as_bytebuffer(10, 1);
+ }
+
+ public ByteBuffer descriptionInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 10, 1);
+ }
+
+ public int width() {
+ int o = __offset(12);
+ return o != 0 ? bb.getInt(o + bb_pos) : -1;
+ }
+
+ public int precision() {
+ int o = __offset(14);
+ return o != 0 ? bb.getInt(o + bb_pos) : -1;
+ }
+
+ public int scale() {
+ int o = __offset(16);
+ return o != 0 ? bb.getInt(o + bb_pos) : -1;
+ }
+
+ public boolean nullable() {
+ int o = __offset(18);
+ return o != 0 ? 0 != bb.get(o + bb_pos) : true;
+ }
+
+ public boolean unique() {
+ int o = __offset(20);
+ return o != 0 ? 0 != bb.get(o + bb_pos) : false;
+ }
+
+ public boolean primaryKey() {
+ int o = __offset(22);
+ return o != 0 ? 0 != bb.get(o + bb_pos) : false;
+ }
+
+ public String metadata() {
+ int o = __offset(24);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer metadataAsByteBuffer() {
+ return __vector_as_bytebuffer(24, 1);
+ }
+
+ public ByteBuffer metadataInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 24, 1);
+ }
+
+ public static int createColumn(FlatBufferBuilder builder,
+ int nameOffset,
+ int type,
+ int titleOffset,
+ int descriptionOffset,
+ int width,
+ int precision,
+ int scale,
+ boolean nullable,
+ boolean unique,
+ boolean primaryKey,
+ int metadataOffset) {
+ builder.startTable(11);
+ Column.addMetadata(builder, metadataOffset);
+ Column.addScale(builder, scale);
+ Column.addPrecision(builder, precision);
+ Column.addWidth(builder, width);
+ Column.addDescription(builder, descriptionOffset);
+ Column.addTitle(builder, titleOffset);
+ Column.addName(builder, nameOffset);
+ Column.addPrimaryKey(builder, primaryKey);
+ Column.addUnique(builder, unique);
+ Column.addNullable(builder, nullable);
+ Column.addType(builder, type);
+ return Column.endColumn(builder);
+ }
+
+ public static void startColumn(FlatBufferBuilder builder) {
+ builder.startTable(11);
+ }
+
+ public static void addName(FlatBufferBuilder builder, int nameOffset) {
+ builder.addOffset(0, nameOffset, 0);
+ }
+
+ public static void addType(FlatBufferBuilder builder, int type) {
+ builder.addByte(1, (byte) type, (byte) 0);
+ }
+
+ public static void addTitle(FlatBufferBuilder builder, int titleOffset) {
+ builder.addOffset(2, titleOffset, 0);
+ }
+
+ public static void addDescription(FlatBufferBuilder builder, int descriptionOffset) {
+ builder.addOffset(3, descriptionOffset, 0);
+ }
+
+ public static void addWidth(FlatBufferBuilder builder, int width) {
+ builder.addInt(4, width, -1);
+ }
+
+ public static void addPrecision(FlatBufferBuilder builder, int precision) {
+ builder.addInt(5, precision, -1);
+ }
+
+ public static void addScale(FlatBufferBuilder builder, int scale) {
+ builder.addInt(6, scale, -1);
+ }
+
+ public static void addNullable(FlatBufferBuilder builder, boolean nullable) {
+ builder.addBoolean(7, nullable, true);
+ }
+
+ public static void addUnique(FlatBufferBuilder builder, boolean unique) {
+ builder.addBoolean(8, unique, false);
+ }
+
+ public static void addPrimaryKey(FlatBufferBuilder builder, boolean primaryKey) {
+ builder.addBoolean(9, primaryKey, false);
+ }
+
+ public static void addMetadata(FlatBufferBuilder builder, int metadataOffset) {
+ builder.addOffset(10, metadataOffset, 0);
+ }
+
+ public static int endColumn(FlatBufferBuilder builder) {
+ int o = builder.endTable();
+ builder.required(o, 4); // name
+ return o;
+ }
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) {
+ __reset(_vector, _element_size, _bb);
+ return this;
+ }
+
+ public Column get(int j) {
+ return get(new Column(), j);
+ }
+
+ public Column get(Column obj, int j) {
+ return obj.__assign(__indirect(__element(j), bb), bb);
+ }
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/ColumnType.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/ColumnType.java
new file mode 100644
index 00000000..1da21f8e
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/ColumnType.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf.generated;
+
+@SuppressWarnings("unused")
+public final class ColumnType {
+ private ColumnType() {}
+
+ public static final int Byte = 0;
+ public static final int UByte = 1;
+ public static final int Bool = 2;
+ public static final int Short = 3;
+ public static final int UShort = 4;
+ public static final int Int = 5;
+ public static final int UInt = 6;
+ public static final int Long = 7;
+ public static final int ULong = 8;
+ public static final int Float = 9;
+ public static final int Double = 10;
+ public static final int String = 11;
+ public static final int Json = 12;
+ public static final int DateTime = 13;
+ public static final int Binary = 14;
+
+ public static final String[] names = {"Byte", "UByte", "Bool", "Short", "UShort", "Int", "UInt",
+ "Long", "ULong", "Float", "Double", "String", "Json", "DateTime", "Binary",};
+
+ public static String name(int e) {
+ return names[e];
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Crs.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Crs.java
new file mode 100644
index 00000000..291de1dc
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Crs.java
@@ -0,0 +1,185 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf.generated;
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.Table;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class Crs extends Table {
+ public static void ValidateVersion() {
+ Constants.FLATBUFFERS_24_3_25();
+ }
+
+ public static Crs getRootAsCrs(ByteBuffer _bb) {
+ return getRootAsCrs(_bb, new Crs());
+ }
+
+ public static Crs getRootAsCrs(ByteBuffer _bb, Crs obj) {
+ _bb.order(ByteOrder.LITTLE_ENDIAN);
+ return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb));
+ }
+
+ public void __init(int _i, ByteBuffer _bb) {
+ __reset(_i, _bb);
+ }
+
+ public Crs __assign(int _i, ByteBuffer _bb) {
+ __init(_i, _bb);
+ return this;
+ }
+
+ public String org() {
+ int o = __offset(4);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer orgAsByteBuffer() {
+ return __vector_as_bytebuffer(4, 1);
+ }
+
+ public ByteBuffer orgInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 4, 1);
+ }
+
+ public int code() {
+ int o = __offset(6);
+ return o != 0 ? bb.getInt(o + bb_pos) : 0;
+ }
+
+ public String name() {
+ int o = __offset(8);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer nameAsByteBuffer() {
+ return __vector_as_bytebuffer(8, 1);
+ }
+
+ public ByteBuffer nameInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 8, 1);
+ }
+
+ public String description() {
+ int o = __offset(10);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer descriptionAsByteBuffer() {
+ return __vector_as_bytebuffer(10, 1);
+ }
+
+ public ByteBuffer descriptionInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 10, 1);
+ }
+
+ public String wkt() {
+ int o = __offset(12);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer wktAsByteBuffer() {
+ return __vector_as_bytebuffer(12, 1);
+ }
+
+ public ByteBuffer wktInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 12, 1);
+ }
+
+ public String codeString() {
+ int o = __offset(14);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer codeStringAsByteBuffer() {
+ return __vector_as_bytebuffer(14, 1);
+ }
+
+ public ByteBuffer codeStringInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 14, 1);
+ }
+
+ public static int createCrs(FlatBufferBuilder builder,
+ int orgOffset,
+ int code,
+ int nameOffset,
+ int descriptionOffset,
+ int wktOffset,
+ int codeStringOffset) {
+ builder.startTable(6);
+ Crs.addCodeString(builder, codeStringOffset);
+ Crs.addWkt(builder, wktOffset);
+ Crs.addDescription(builder, descriptionOffset);
+ Crs.addName(builder, nameOffset);
+ Crs.addCode(builder, code);
+ Crs.addOrg(builder, orgOffset);
+ return Crs.endCrs(builder);
+ }
+
+ public static void startCrs(FlatBufferBuilder builder) {
+ builder.startTable(6);
+ }
+
+ public static void addOrg(FlatBufferBuilder builder, int orgOffset) {
+ builder.addOffset(0, orgOffset, 0);
+ }
+
+ public static void addCode(FlatBufferBuilder builder, int code) {
+ builder.addInt(1, code, 0);
+ }
+
+ public static void addName(FlatBufferBuilder builder, int nameOffset) {
+ builder.addOffset(2, nameOffset, 0);
+ }
+
+ public static void addDescription(FlatBufferBuilder builder, int descriptionOffset) {
+ builder.addOffset(3, descriptionOffset, 0);
+ }
+
+ public static void addWkt(FlatBufferBuilder builder, int wktOffset) {
+ builder.addOffset(4, wktOffset, 0);
+ }
+
+ public static void addCodeString(FlatBufferBuilder builder, int codeStringOffset) {
+ builder.addOffset(5, codeStringOffset, 0);
+ }
+
+ public static int endCrs(FlatBufferBuilder builder) {
+ int o = builder.endTable();
+ return o;
+ }
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) {
+ __reset(_vector, _element_size, _bb);
+ return this;
+ }
+
+ public Crs get(int j) {
+ return get(new Crs(), j);
+ }
+
+ public Crs get(Crs obj, int j) {
+ return obj.__assign(__indirect(__element(j), bb), bb);
+ }
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Feature.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Feature.java
new file mode 100644
index 00000000..0a9ba8f2
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Feature.java
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf.generated;
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.ByteVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.Table;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class Feature extends Table {
+ public static void ValidateVersion() {
+ Constants.FLATBUFFERS_24_3_25();
+ }
+
+ public static Feature getRootAsFeature(ByteBuffer _bb) {
+ return getRootAsFeature(_bb, new Feature());
+ }
+
+ public static Feature getRootAsFeature(ByteBuffer _bb, Feature obj) {
+ _bb.order(ByteOrder.LITTLE_ENDIAN);
+ return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb));
+ }
+
+ public void __init(int _i, ByteBuffer _bb) {
+ __reset(_i, _bb);
+ }
+
+ public Feature __assign(int _i, ByteBuffer _bb) {
+ __init(_i, _bb);
+ return this;
+ }
+
+ public Geometry geometry() {
+ return geometry(new Geometry());
+ }
+
+ public Geometry geometry(Geometry obj) {
+ int o = __offset(4);
+ return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null;
+ }
+
+ public int properties(int j) {
+ int o = __offset(6);
+ return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0;
+ }
+
+ public int propertiesLength() {
+ int o = __offset(6);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public ByteVector propertiesVector() {
+ return propertiesVector(new ByteVector());
+ }
+
+ public ByteVector propertiesVector(ByteVector obj) {
+ int o = __offset(6);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer propertiesAsByteBuffer() {
+ return __vector_as_bytebuffer(6, 1);
+ }
+
+ public ByteBuffer propertiesInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 6, 1);
+ }
+
+ public Column columns(int j) {
+ return columns(new Column(), j);
+ }
+
+ public Column columns(Column obj, int j) {
+ int o = __offset(8);
+ return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null;
+ }
+
+ public int columnsLength() {
+ int o = __offset(8);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public Column.Vector columnsVector() {
+ return columnsVector(new Column.Vector());
+ }
+
+ public Column.Vector columnsVector(Column.Vector obj) {
+ int o = __offset(8);
+ return o != 0 ? obj.__assign(__vector(o), 4, bb) : null;
+ }
+
+ public static int createFeature(FlatBufferBuilder builder,
+ int geometryOffset,
+ int propertiesOffset,
+ int columnsOffset) {
+ builder.startTable(3);
+ Feature.addColumns(builder, columnsOffset);
+ Feature.addProperties(builder, propertiesOffset);
+ Feature.addGeometry(builder, geometryOffset);
+ return Feature.endFeature(builder);
+ }
+
+ public static void startFeature(FlatBufferBuilder builder) {
+ builder.startTable(3);
+ }
+
+ public static void addGeometry(FlatBufferBuilder builder, int geometryOffset) {
+ builder.addOffset(0, geometryOffset, 0);
+ }
+
+ public static void addProperties(FlatBufferBuilder builder, int propertiesOffset) {
+ builder.addOffset(1, propertiesOffset, 0);
+ }
+
+ public static int createPropertiesVector(FlatBufferBuilder builder, byte[] data) {
+ return builder.createByteVector(data);
+ }
+
+ public static int createPropertiesVector(FlatBufferBuilder builder, ByteBuffer data) {
+ return builder.createByteVector(data);
+ }
+
+ public static void startPropertiesVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(1, numElems, 1);
+ }
+
+ public static void addColumns(FlatBufferBuilder builder, int columnsOffset) {
+ builder.addOffset(2, columnsOffset, 0);
+ }
+
+ public static int createColumnsVector(FlatBufferBuilder builder, int[] data) {
+ builder.startVector(4, data.length, 4);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addOffset(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startColumnsVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(4, numElems, 4);
+ }
+
+ public static int endFeature(FlatBufferBuilder builder) {
+ int o = builder.endTable();
+ return o;
+ }
+
+ public static void finishFeatureBuffer(FlatBufferBuilder builder, int offset) {
+ builder.finish(offset);
+ }
+
+ public static void finishSizePrefixedFeatureBuffer(FlatBufferBuilder builder, int offset) {
+ builder.finishSizePrefixed(offset);
+ }
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) {
+ __reset(_vector, _element_size, _bb);
+ return this;
+ }
+
+ public Feature get(int j) {
+ return get(new Feature(), j);
+ }
+
+ public Feature get(Feature obj, int j) {
+ return obj.__assign(__indirect(__element(j), bb), bb);
+ }
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Geometry.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Geometry.java
new file mode 100644
index 00000000..02d93f42
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Geometry.java
@@ -0,0 +1,397 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf.generated;
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.DoubleVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.IntVector;
+import com.google.flatbuffers.LongVector;
+import com.google.flatbuffers.Table;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class Geometry extends Table {
+ public static void ValidateVersion() {
+ Constants.FLATBUFFERS_24_3_25();
+ }
+
+ public static Geometry getRootAsGeometry(ByteBuffer _bb) {
+ return getRootAsGeometry(_bb, new Geometry());
+ }
+
+ public static Geometry getRootAsGeometry(ByteBuffer _bb, Geometry obj) {
+ _bb.order(ByteOrder.LITTLE_ENDIAN);
+ return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb));
+ }
+
+ public void __init(int _i, ByteBuffer _bb) {
+ __reset(_i, _bb);
+ }
+
+ public Geometry __assign(int _i, ByteBuffer _bb) {
+ __init(_i, _bb);
+ return this;
+ }
+
+ public long ends(int j) {
+ int o = __offset(4);
+ return o != 0 ? (long) bb.getInt(__vector(o) + j * 4) & 0xFFFFFFFFL : 0;
+ }
+
+ public int endsLength() {
+ int o = __offset(4);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public IntVector endsVector() {
+ return endsVector(new IntVector());
+ }
+
+ public IntVector endsVector(IntVector obj) {
+ int o = __offset(4);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer endsAsByteBuffer() {
+ return __vector_as_bytebuffer(4, 4);
+ }
+
+ public ByteBuffer endsInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 4, 4);
+ }
+
+ public double xy(int j) {
+ int o = __offset(6);
+ return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0;
+ }
+
+ public int xyLength() {
+ int o = __offset(6);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public DoubleVector xyVector() {
+ return xyVector(new DoubleVector());
+ }
+
+ public DoubleVector xyVector(DoubleVector obj) {
+ int o = __offset(6);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer xyAsByteBuffer() {
+ return __vector_as_bytebuffer(6, 8);
+ }
+
+ public ByteBuffer xyInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 6, 8);
+ }
+
+ public double z(int j) {
+ int o = __offset(8);
+ return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0;
+ }
+
+ public int zLength() {
+ int o = __offset(8);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public DoubleVector zVector() {
+ return zVector(new DoubleVector());
+ }
+
+ public DoubleVector zVector(DoubleVector obj) {
+ int o = __offset(8);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer zAsByteBuffer() {
+ return __vector_as_bytebuffer(8, 8);
+ }
+
+ public ByteBuffer zInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 8, 8);
+ }
+
+ public double m(int j) {
+ int o = __offset(10);
+ return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0;
+ }
+
+ public int mLength() {
+ int o = __offset(10);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public DoubleVector mVector() {
+ return mVector(new DoubleVector());
+ }
+
+ public DoubleVector mVector(DoubleVector obj) {
+ int o = __offset(10);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer mAsByteBuffer() {
+ return __vector_as_bytebuffer(10, 8);
+ }
+
+ public ByteBuffer mInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 10, 8);
+ }
+
+ public double t(int j) {
+ int o = __offset(12);
+ return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0;
+ }
+
+ public int tLength() {
+ int o = __offset(12);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public DoubleVector tVector() {
+ return tVector(new DoubleVector());
+ }
+
+ public DoubleVector tVector(DoubleVector obj) {
+ int o = __offset(12);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer tAsByteBuffer() {
+ return __vector_as_bytebuffer(12, 8);
+ }
+
+ public ByteBuffer tInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 12, 8);
+ }
+
+ public long tm(int j) {
+ int o = __offset(14);
+ return o != 0 ? bb.getLong(__vector(o) + j * 8) : 0;
+ }
+
+ public int tmLength() {
+ int o = __offset(14);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public LongVector tmVector() {
+ return tmVector(new LongVector());
+ }
+
+ public LongVector tmVector(LongVector obj) {
+ int o = __offset(14);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer tmAsByteBuffer() {
+ return __vector_as_bytebuffer(14, 8);
+ }
+
+ public ByteBuffer tmInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 14, 8);
+ }
+
+ public int type() {
+ int o = __offset(16);
+ return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0;
+ }
+
+ public Geometry parts(int j) {
+ return parts(new Geometry(), j);
+ }
+
+ public Geometry parts(Geometry obj, int j) {
+ int o = __offset(18);
+ return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null;
+ }
+
+ public int partsLength() {
+ int o = __offset(18);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public Geometry.Vector partsVector() {
+ return partsVector(new Geometry.Vector());
+ }
+
+ public Geometry.Vector partsVector(Geometry.Vector obj) {
+ int o = __offset(18);
+ return o != 0 ? obj.__assign(__vector(o), 4, bb) : null;
+ }
+
+ public static int createGeometry(FlatBufferBuilder builder,
+ int endsOffset,
+ int xyOffset,
+ int zOffset,
+ int mOffset,
+ int tOffset,
+ int tmOffset,
+ int type,
+ int partsOffset) {
+ builder.startTable(8);
+ Geometry.addParts(builder, partsOffset);
+ Geometry.addTm(builder, tmOffset);
+ Geometry.addT(builder, tOffset);
+ Geometry.addM(builder, mOffset);
+ Geometry.addZ(builder, zOffset);
+ Geometry.addXy(builder, xyOffset);
+ Geometry.addEnds(builder, endsOffset);
+ Geometry.addType(builder, type);
+ return Geometry.endGeometry(builder);
+ }
+
+ public static void startGeometry(FlatBufferBuilder builder) {
+ builder.startTable(8);
+ }
+
+ public static void addEnds(FlatBufferBuilder builder, int endsOffset) {
+ builder.addOffset(0, endsOffset, 0);
+ }
+
+ public static int createEndsVector(FlatBufferBuilder builder, long[] data) {
+ builder.startVector(4, data.length, 4);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addInt((int) data[i]);
+ return builder.endVector();
+ }
+
+ public static void startEndsVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(4, numElems, 4);
+ }
+
+ public static void addXy(FlatBufferBuilder builder, int xyOffset) {
+ builder.addOffset(1, xyOffset, 0);
+ }
+
+ public static int createXyVector(FlatBufferBuilder builder, double[] data) {
+ builder.startVector(8, data.length, 8);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addDouble(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startXyVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(8, numElems, 8);
+ }
+
+ public static void addZ(FlatBufferBuilder builder, int zOffset) {
+ builder.addOffset(2, zOffset, 0);
+ }
+
+ public static int createZVector(FlatBufferBuilder builder, double[] data) {
+ builder.startVector(8, data.length, 8);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addDouble(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startZVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(8, numElems, 8);
+ }
+
+ public static void addM(FlatBufferBuilder builder, int mOffset) {
+ builder.addOffset(3, mOffset, 0);
+ }
+
+ public static int createMVector(FlatBufferBuilder builder, double[] data) {
+ builder.startVector(8, data.length, 8);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addDouble(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startMVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(8, numElems, 8);
+ }
+
+ public static void addT(FlatBufferBuilder builder, int tOffset) {
+ builder.addOffset(4, tOffset, 0);
+ }
+
+ public static int createTVector(FlatBufferBuilder builder, double[] data) {
+ builder.startVector(8, data.length, 8);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addDouble(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startTVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(8, numElems, 8);
+ }
+
+ public static void addTm(FlatBufferBuilder builder, int tmOffset) {
+ builder.addOffset(5, tmOffset, 0);
+ }
+
+ public static int createTmVector(FlatBufferBuilder builder, long[] data) {
+ builder.startVector(8, data.length, 8);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addLong(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startTmVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(8, numElems, 8);
+ }
+
+ public static void addType(FlatBufferBuilder builder, int type) {
+ builder.addByte(6, (byte) type, (byte) 0);
+ }
+
+ public static void addParts(FlatBufferBuilder builder, int partsOffset) {
+ builder.addOffset(7, partsOffset, 0);
+ }
+
+ public static int createPartsVector(FlatBufferBuilder builder, int[] data) {
+ builder.startVector(4, data.length, 4);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addOffset(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startPartsVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(4, numElems, 4);
+ }
+
+ public static int endGeometry(FlatBufferBuilder builder) {
+ int o = builder.endTable();
+ return o;
+ }
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) {
+ __reset(_vector, _element_size, _bb);
+ return this;
+ }
+
+ public Geometry get(int j) {
+ return get(new Geometry(), j);
+ }
+
+ public Geometry get(Geometry obj, int j) {
+ return obj.__assign(__indirect(__element(j), bb), bb);
+ }
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/GeometryType.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/GeometryType.java
new file mode 100644
index 00000000..82584c6f
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/GeometryType.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf.generated;
+
+@SuppressWarnings("unused")
+public final class GeometryType {
+ private GeometryType() {}
+
+ public static final int Unknown = 0;
+ public static final int Point = 1;
+ public static final int LineString = 2;
+ public static final int Polygon = 3;
+ public static final int MultiPoint = 4;
+ public static final int MultiLineString = 5;
+ public static final int MultiPolygon = 6;
+ public static final int GeometryCollection = 7;
+ public static final int CircularString = 8;
+ public static final int CompoundCurve = 9;
+ public static final int CurvePolygon = 10;
+ public static final int MultiCurve = 11;
+ public static final int MultiSurface = 12;
+ public static final int Curve = 13;
+ public static final int Surface = 14;
+ public static final int PolyhedralSurface = 15;
+ public static final int TIN = 16;
+ public static final int Triangle = 17;
+
+ public static final String[] names =
+ {"Unknown", "Point", "LineString", "Polygon", "MultiPoint", "MultiLineString", "MultiPolygon",
+ "GeometryCollection", "CircularString", "CompoundCurve", "CurvePolygon", "MultiCurve",
+ "MultiSurface", "Curve", "Surface", "PolyhedralSurface", "TIN", "Triangle",};
+
+ public static String name(int e) {
+ return names[e];
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Header.java b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Header.java
new file mode 100644
index 00000000..d4d17ee9
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/java/org/apache/baremaps/flatgeobuf/generated/Header.java
@@ -0,0 +1,340 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf.generated;
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.DoubleVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.Table;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class Header extends Table {
+ public static void ValidateVersion() {
+ Constants.FLATBUFFERS_24_3_25();
+ }
+
+ public static Header getRootAsHeader(ByteBuffer _bb) {
+ return getRootAsHeader(_bb, new Header());
+ }
+
+ public static Header getRootAsHeader(ByteBuffer _bb, Header obj) {
+ _bb.order(ByteOrder.LITTLE_ENDIAN);
+ return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb));
+ }
+
+ public void __init(int _i, ByteBuffer _bb) {
+ __reset(_i, _bb);
+ }
+
+ public Header __assign(int _i, ByteBuffer _bb) {
+ __init(_i, _bb);
+ return this;
+ }
+
+ public String name() {
+ int o = __offset(4);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer nameAsByteBuffer() {
+ return __vector_as_bytebuffer(4, 1);
+ }
+
+ public ByteBuffer nameInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 4, 1);
+ }
+
+ public double envelope(int j) {
+ int o = __offset(6);
+ return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0;
+ }
+
+ public int envelopeLength() {
+ int o = __offset(6);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public DoubleVector envelopeVector() {
+ return envelopeVector(new DoubleVector());
+ }
+
+ public DoubleVector envelopeVector(DoubleVector obj) {
+ int o = __offset(6);
+ return o != 0 ? obj.__assign(__vector(o), bb) : null;
+ }
+
+ public ByteBuffer envelopeAsByteBuffer() {
+ return __vector_as_bytebuffer(6, 8);
+ }
+
+ public ByteBuffer envelopeInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 6, 8);
+ }
+
+ public int geometryType() {
+ int o = __offset(8);
+ return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0;
+ }
+
+ public boolean hasZ() {
+ int o = __offset(10);
+ return o != 0 ? 0 != bb.get(o + bb_pos) : false;
+ }
+
+ public boolean hasM() {
+ int o = __offset(12);
+ return o != 0 ? 0 != bb.get(o + bb_pos) : false;
+ }
+
+ public boolean hasT() {
+ int o = __offset(14);
+ return o != 0 ? 0 != bb.get(o + bb_pos) : false;
+ }
+
+ public boolean hasTm() {
+ int o = __offset(16);
+ return o != 0 ? 0 != bb.get(o + bb_pos) : false;
+ }
+
+ public Column columns(int j) {
+ return columns(new Column(), j);
+ }
+
+ public Column columns(Column obj, int j) {
+ int o = __offset(18);
+ return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null;
+ }
+
+ public int columnsLength() {
+ int o = __offset(18);
+ return o != 0 ? __vector_len(o) : 0;
+ }
+
+ public Column.Vector columnsVector() {
+ return columnsVector(new Column.Vector());
+ }
+
+ public Column.Vector columnsVector(Column.Vector obj) {
+ int o = __offset(18);
+ return o != 0 ? obj.__assign(__vector(o), 4, bb) : null;
+ }
+
+ public long featuresCount() {
+ int o = __offset(20);
+ return o != 0 ? bb.getLong(o + bb_pos) : 0L;
+ }
+
+ public int indexNodeSize() {
+ int o = __offset(22);
+ return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 16;
+ }
+
+ public Crs crs() {
+ return crs(new Crs());
+ }
+
+ public Crs crs(Crs obj) {
+ int o = __offset(24);
+ return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null;
+ }
+
+ public String title() {
+ int o = __offset(26);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer titleAsByteBuffer() {
+ return __vector_as_bytebuffer(26, 1);
+ }
+
+ public ByteBuffer titleInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 26, 1);
+ }
+
+ public String description() {
+ int o = __offset(28);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer descriptionAsByteBuffer() {
+ return __vector_as_bytebuffer(28, 1);
+ }
+
+ public ByteBuffer descriptionInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 28, 1);
+ }
+
+ public String metadata() {
+ int o = __offset(30);
+ return o != 0 ? __string(o + bb_pos) : null;
+ }
+
+ public ByteBuffer metadataAsByteBuffer() {
+ return __vector_as_bytebuffer(30, 1);
+ }
+
+ public ByteBuffer metadataInByteBuffer(ByteBuffer _bb) {
+ return __vector_in_bytebuffer(_bb, 30, 1);
+ }
+
+ public static int createHeader(FlatBufferBuilder builder,
+ int nameOffset,
+ int envelopeOffset,
+ int geometryType,
+ boolean hasZ,
+ boolean hasM,
+ boolean hasT,
+ boolean hasTm,
+ int columnsOffset,
+ long featuresCount,
+ int indexNodeSize,
+ int crsOffset,
+ int titleOffset,
+ int descriptionOffset,
+ int metadataOffset) {
+ builder.startTable(14);
+ Header.addFeaturesCount(builder, featuresCount);
+ Header.addMetadata(builder, metadataOffset);
+ Header.addDescription(builder, descriptionOffset);
+ Header.addTitle(builder, titleOffset);
+ Header.addCrs(builder, crsOffset);
+ Header.addColumns(builder, columnsOffset);
+ Header.addEnvelope(builder, envelopeOffset);
+ Header.addName(builder, nameOffset);
+ Header.addIndexNodeSize(builder, indexNodeSize);
+ Header.addHasTm(builder, hasTm);
+ Header.addHasT(builder, hasT);
+ Header.addHasM(builder, hasM);
+ Header.addHasZ(builder, hasZ);
+ Header.addGeometryType(builder, geometryType);
+ return Header.endHeader(builder);
+ }
+
+ public static void startHeader(FlatBufferBuilder builder) {
+ builder.startTable(14);
+ }
+
+ public static void addName(FlatBufferBuilder builder, int nameOffset) {
+ builder.addOffset(0, nameOffset, 0);
+ }
+
+ public static void addEnvelope(FlatBufferBuilder builder, int envelopeOffset) {
+ builder.addOffset(1, envelopeOffset, 0);
+ }
+
+ public static int createEnvelopeVector(FlatBufferBuilder builder, double[] data) {
+ builder.startVector(8, data.length, 8);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addDouble(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startEnvelopeVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(8, numElems, 8);
+ }
+
+ public static void addGeometryType(FlatBufferBuilder builder, int geometryType) {
+ builder.addByte(2, (byte) geometryType, (byte) 0);
+ }
+
+ public static void addHasZ(FlatBufferBuilder builder, boolean hasZ) {
+ builder.addBoolean(3, hasZ, false);
+ }
+
+ public static void addHasM(FlatBufferBuilder builder, boolean hasM) {
+ builder.addBoolean(4, hasM, false);
+ }
+
+ public static void addHasT(FlatBufferBuilder builder, boolean hasT) {
+ builder.addBoolean(5, hasT, false);
+ }
+
+ public static void addHasTm(FlatBufferBuilder builder, boolean hasTm) {
+ builder.addBoolean(6, hasTm, false);
+ }
+
+ public static void addColumns(FlatBufferBuilder builder, int columnsOffset) {
+ builder.addOffset(7, columnsOffset, 0);
+ }
+
+ public static int createColumnsVector(FlatBufferBuilder builder, int[] data) {
+ builder.startVector(4, data.length, 4);
+ for (int i = data.length - 1; i >= 0; i--)
+ builder.addOffset(data[i]);
+ return builder.endVector();
+ }
+
+ public static void startColumnsVector(FlatBufferBuilder builder, int numElems) {
+ builder.startVector(4, numElems, 4);
+ }
+
+ public static void addFeaturesCount(FlatBufferBuilder builder, long featuresCount) {
+ builder.addLong(8, featuresCount, 0L);
+ }
+
+ public static void addIndexNodeSize(FlatBufferBuilder builder, int indexNodeSize) {
+ builder.addShort(9, (short) indexNodeSize, (short) 16);
+ }
+
+ public static void addCrs(FlatBufferBuilder builder, int crsOffset) {
+ builder.addOffset(10, crsOffset, 0);
+ }
+
+ public static void addTitle(FlatBufferBuilder builder, int titleOffset) {
+ builder.addOffset(11, titleOffset, 0);
+ }
+
+ public static void addDescription(FlatBufferBuilder builder, int descriptionOffset) {
+ builder.addOffset(12, descriptionOffset, 0);
+ }
+
+ public static void addMetadata(FlatBufferBuilder builder, int metadataOffset) {
+ builder.addOffset(13, metadataOffset, 0);
+ }
+
+ public static int endHeader(FlatBufferBuilder builder) {
+ int o = builder.endTable();
+ return o;
+ }
+
+ public static void finishHeaderBuffer(FlatBufferBuilder builder, int offset) {
+ builder.finish(offset);
+ }
+
+ public static void finishSizePrefixedHeaderBuffer(FlatBufferBuilder builder, int offset) {
+ builder.finishSizePrefixed(offset);
+ }
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) {
+ __reset(_vector, _element_size, _bb);
+ return this;
+ }
+
+ public Header get(int j) {
+ return get(new Header(), j);
+ }
+
+ public Header get(Header obj, int j) {
+ return obj.__assign(__indirect(__element(j), bb), bb);
+ }
+ }
+}
diff --git a/baremaps-flatgeobuf/src/main/resources/fbs/feature.fbs b/baremaps-flatgeobuf/src/main/resources/fbs/feature.fbs
new file mode 100644
index 00000000..b9a874dc
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/resources/fbs/feature.fbs
@@ -0,0 +1,22 @@
+include "header.fbs";
+
+namespace FlatGeobuf;
+
+table Geometry {
+ ends: [uint]; // Array of end index in flat coordinates per geometry part with exterior ring first (NOTE: allowed and recommended to be null if 1 part)
+ xy: [double]; // Flat x and y coordinate array (flat pairs) (should not be null or empty)
+ z: [double]; // Flat z height array (should not be null or empty if header hasZ)
+ m: [double]; // Flat m measurement array (should not be null or empty if header hasM)
+ t: [double]; // Flat t geodetic decimal year time array (should not be null or empty if header hasT)
+ tm: [ulong]; // Flat tm time nanosecond measurement array (should not be null or empty if header hasTM)
+ type: GeometryType; // Type of geometry (only for elements in heterogeneous collection types or if unknown in header)
+ parts: [Geometry]; // Array of parts (for heterogeneous collection types)
+}
+
+table Feature {
+ geometry: Geometry; // Geometry
+ properties: [ubyte]; // Custom buffer, variable length collection of key/value pairs (key=ushort)
+ columns: [Column]; // Attribute columns schema (optional)
+}
+
+root_type Feature;
\ No newline at end of file
diff --git a/baremaps-flatgeobuf/src/main/resources/fbs/header.fbs b/baremaps-flatgeobuf/src/main/resources/fbs/header.fbs
new file mode 100644
index 00000000..b1e716c5
--- /dev/null
+++ b/baremaps-flatgeobuf/src/main/resources/fbs/header.fbs
@@ -0,0 +1,84 @@
+namespace FlatGeobuf;
+
+// Geometry type enumeration
+// NOTE: Same as WKB 2D geometry type enumeration
+enum GeometryType: ubyte {
+ Unknown = 0,
+ Point = 1,
+ LineString = 2,
+ Polygon = 3,
+ MultiPoint = 4,
+ MultiLineString = 5,
+ MultiPolygon = 6,
+ GeometryCollection = 7,
+ CircularString = 8,
+ CompoundCurve = 9,
+ CurvePolygon = 10,
+ MultiCurve = 11,
+ MultiSurface = 12,
+ Curve = 13,
+ Surface = 14,
+ PolyhedralSurface = 15,
+ TIN = 16,
+ Triangle = 17
+}
+
+enum ColumnType: ubyte {
+ Byte, // Signed 8-bit integer
+ UByte, // Unsigned 8-bit integer
+ Bool, // Boolean
+ Short, // Signed 16-bit integer
+ UShort, // Unsigned 16-bit integer
+ Int, // Signed 32-bit integer
+ UInt, // Unsigned 32-bit integer
+ Long, // Signed 64-bit integer
+ ULong, // Unsigned 64-bit integer
+ Float, // Single precision floating point number
+ Double, // Double precision floating point number
+ String, // UTF8 string
+ Json, // General JSON type intended to be application specific
+ DateTime, // ISO 8601 date time
+ Binary // General binary type intended to be application specific
+}
+
+table Column {
+ name: string (required); // Column name
+ type: ColumnType; // Column type
+ title: string; // Column title
+ description: string; // Column description (intended for free form long text)
+ width: int = -1; // Column values expected width (-1 = unknown) (currently only used to indicate the number of characters in strings)
+ precision: int = -1; // Column values expected precision (-1 = unknown) as defined by SQL
+ scale: int = -1; // Column values expected scale (-1 = unknown) as defined by SQL
+ nullable: bool = true; // Column values expected nullability
+ unique: bool = false; // Column values expected uniqueness
+ primary_key: bool = false; // Indicates this column has been (part of) a primary key
+ metadata: string; // Column metadata (intended to be application specific and suggested to be structured fx. JSON)
+}
+
+table Crs {
+ org: string; // Case-insensitive name of the defining organization e.g. EPSG or epsg (NULL = EPSG)
+ code: int; // Numeric ID of the Spatial Reference System assigned by the organization (0 = unknown)
+ name: string; // Human readable name of this SRS
+ description: string; // Human readable description of this SRS
+ wkt: string; // Well-known Text Representation of the Spatial Reference System
+ code_string: string; // Text ID of the Spatial Reference System assigned by the organization in the (rare) case when it is not an integer and thus cannot be set into code
+}
+
+table Header {
+ name: string; // Dataset name
+ envelope: [double]; // Bounds
+ geometry_type: GeometryType; // Geometry type (should be set to Unknown if per feature geometry type)
+ has_z: bool = false; // Does geometry have Z dimension?
+ has_m: bool = false; // Does geometry have M dimension?
+ has_t: bool = false; // Does geometry have T dimension?
+ has_tm: bool = false; // Does geometry have TM dimension?
+ columns: [Column]; // Attribute columns schema (can be omitted if per feature schema)
+ features_count: ulong; // Number of features in the dataset (0 = unknown)
+ index_node_size: ushort = 16; // Index node size (0 = no index)
+ crs: Crs; // Spatial Reference System
+ title: string; // Dataset title
+ description: string; // Dataset description (intended for free form long text)
+ metadata: string; // Dataset metadata (intended to be application specific and suggested to be structured fx. JSON)
+}
+
+root_type Header;
\ No newline at end of file
diff --git a/baremaps-flatgeobuf/src/test/java/org/apache/baremaps/flatgeobuf/BufferUtilTest.java b/baremaps-flatgeobuf/src/test/java/org/apache/baremaps/flatgeobuf/BufferUtilTest.java
new file mode 100644
index 00000000..54906543
--- /dev/null
+++ b/baremaps-flatgeobuf/src/test/java/org/apache/baremaps/flatgeobuf/BufferUtilTest.java
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import static org.junit.Assert.*;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import org.junit.jupiter.api.Test;
+
+public class BufferUtilTest {
+
+ @Test
+ void testPrepareBufferAlreadySufficient() throws IOException {
+ byte[] data = "Hello, World!".getBytes();
+ ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
+ ByteBuffer buffer = ByteBuffer.allocate(15);
+ buffer.put(data);
+ buffer.flip();
+
+ ByteBuffer result = BufferUtil.readBytes(channel, buffer, 5);
+ assertEquals(buffer, result);
+ assertEquals(13, result.remaining());
+ }
+
+ @Test
+ void testPrepareBufferCompactAndRead() throws IOException {
+ byte[] data = "Hello, World!".getBytes();
+ ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
+ ByteBuffer buffer = ByteBuffer.allocate(15);
+ buffer.put("Hello".getBytes());
+ buffer.flip();
+
+ ByteBuffer result = BufferUtil.readBytes(channel, buffer, 10);
+ assertEquals(buffer, result);
+ assertTrue(result.remaining() >= 10);
+ }
+
+ @Test
+ void testPrepareBufferAllocateNewBuffer() throws IOException {
+ byte[] data = "Hello, World!".getBytes();
+ ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
+ ByteBuffer buffer = ByteBuffer.allocate(5);
+ buffer.put("Hi".getBytes());
+ buffer.flip();
+
+ ByteBuffer result = BufferUtil.readBytes(channel, buffer, 10);
+ assertNotEquals(buffer, result);
+ assertTrue(result.capacity() >= 10);
+ assertTrue(result.remaining() >= 10);
+ }
+
+ @Test
+ void testPrepareBufferWithExactCapacity() throws IOException {
+ byte[] data = "Hello, World!".getBytes();
+ ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
+ ByteBuffer buffer = ByteBuffer.allocate(13);
+ buffer.put(data, 0, 5);
+ buffer.flip();
+
+ ByteBuffer result = BufferUtil.readBytes(channel, buffer, 10);
+ assertEquals(buffer, result);
+ assertTrue(result.remaining() >= 10);
+ }
+
+ @Test
+ void testPrepareEndOfChannel() throws IOException {
+ byte[] data = "Hello".getBytes();
+ ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
+ ByteBuffer buffer = ByteBuffer.allocate(10);
+ buffer.put("Hi".getBytes());
+ buffer.flip();
+
+ ByteBuffer result = BufferUtil.readBytes(channel, buffer, 10);
+ assertEquals(buffer, result);
+ assertTrue(result.remaining() <= 10);
+ }
+
+ @Test
+ void testPrepareNullChannel() {
+ ByteBuffer buffer = ByteBuffer.allocate(10);
+ IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
+ BufferUtil.readBytes(null, buffer, 10);
+ });
+ assertEquals("Channel and buffer must not be null", thrown.getMessage());
+ }
+
+ @Test
+ void testPrepareNullBuffer() {
+ byte[] data = "Hello".getBytes();
+ ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
+ IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
+ BufferUtil.readBytes(channel, null, 10);
+ });
+ assertEquals("Channel and buffer must not be null", thrown.getMessage());
+ }
+
+ @Test
+ void testPrepareNegativeBytes() {
+ byte[] data = "Hello".getBytes();
+ ReadableByteChannel channel = Channels.newChannel(new ByteArrayInputStream(data));
+ ByteBuffer buffer = ByteBuffer.allocate(10);
+ IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
+ BufferUtil.readBytes(channel, buffer, -1);
+ });
+ assertEquals("The number of bytes to read must be non-negative", thrown.getMessage());
+ }
+
+}
diff --git a/baremaps-flatgeobuf/src/test/java/org/apache/baremaps/flatgeobuf/FlatGeoBufTest.java b/baremaps-flatgeobuf/src/test/java/org/apache/baremaps/flatgeobuf/FlatGeoBufTest.java
new file mode 100644
index 00000000..03401dd5
--- /dev/null
+++ b/baremaps-flatgeobuf/src/test/java/org/apache/baremaps/flatgeobuf/FlatGeoBufTest.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you 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 org.apache.baremaps.flatgeobuf;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.FileChannel;
+import java.nio.file.StandardOpenOption;
+import org.apache.baremaps.flatgeobuf.generated.Feature;
+import org.apache.baremaps.flatgeobuf.generated.Header;
+import org.apache.baremaps.testing.TestFiles;
+import org.junit.jupiter.api.Test;
+
+public class FlatGeoBufTest {
+
+ @Test
+ void readHeader() throws IOException {
+ var file = TestFiles.resolve("baremaps-testing/data/samples/countries.fgb");
+ try (var channel = FileChannel.open(file, StandardOpenOption.READ)) {
+ Header header = FlatGeoBufReader.readHeader(channel);
+ assertNotNull(header);
+ assertEquals(179, header.featuresCount());
+ }
+ }
+
+ @Test
+ void readFeature() throws IOException {
+ var file = TestFiles.resolve("baremaps-testing/data/samples/countries.fgb");
+ try (var channel = FileChannel.open(file, StandardOpenOption.READ)) {
+
+ // Read the header
+ Header header = FlatGeoBufReader.readHeader(channel);
+ assertNotNull(header);
+ assertEquals(179, header.featuresCount());
+
+ // Read the index
+ FlatGeoBufReader.skipIndex(channel, header);
+
+ // Read the first feature
+ ByteBuffer buffer = BufferUtil.createByteBuffer(1 << 16, ByteOrder.LITTLE_ENDIAN);
+ for (int i = 0; i < header.featuresCount(); i++) {
+ Feature feature = FlatGeoBufReader.readFeature(channel, buffer);
+
+ System.out.println(FlatGeoBuf.asFeatureRecord(header, feature));
+
+ assertNotNull(feature);
+ }
+ }
+ }
+
+
+ public static void main(String... args) {
+ System.out.println(Long.MAX_VALUE);
+ System.out.println(Long.MAX_VALUE >> 32);
+ }
+
+}
diff --git a/baremaps-testing/pom.xml b/baremaps-testing/pom.xml
index c2578470..ac8075f4 100644
--- a/baremaps-testing/pom.xml
+++ b/baremaps-testing/pom.xml
@@ -10,4 +10,10 @@
<properties>
<maven.deploy.skip>true</maven.deploy.skip>
</properties>
+ <dependencies>
+ <dependency>
+ <groupId>org.locationtech.jts</groupId>
+ <artifactId>jts-core</artifactId>
+ </dependency>
+ </dependencies>
</project>
diff --git a/pom.xml b/pom.xml
index eb1e3bd5..4d25e7c4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -52,6 +52,7 @@ limitations under the License.
<module>baremaps-cli</module>
<module>baremaps-core</module>
<module>baremaps-data</module>
+ <module>baremaps-flatgeobuf</module>
<module>baremaps-geoparquet</module>
<module>baremaps-maplibre</module>
<module>baremaps-openstreetmap</module>
@@ -526,10 +527,6 @@ limitations under the License.
<groupId>org.testcontainers</groupId>
<artifactId>testcontainers</artifactId>
</dependency>
- <dependency>
- <groupId>org.wololo</groupId>
- <artifactId>flatgeobuf</artifactId>
- </dependency>
</dependencies>
<build>
diff --git a/scripts/generate-flatgeobuf.sh b/scripts/generate-flatgeobuf.sh
new file mode 100755
index 00000000..ea5317da
--- /dev/null
+++ b/scripts/generate-flatgeobuf.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+flatc --java --gen-all \
+ --java-package-prefix org.apache.baremaps.flatgeobuf.generated \
+ -o baremaps-flatgeobuf/src/main/java \
+ baremaps-flatgeobuf/src/main/resources/fbs/*.fbs