Showing preview only (6,229K chars total). Download the full file or copy to clipboard to get everything.
Repository: maplibre/maplibre-tile-spec
Branch: main
Commit: ad5e4b051edc
Files: 1794
Total size: 71.3 MB
Directory structure:
gitextract_0pgzvh0v/
├── .clang-format
├── .cursor/
│ └── rules/
│ └── karpathy-guidelines.mdc
├── .gitattributes
├── .github/
│ ├── FUNDING.yml
│ ├── actions/
│ │ ├── mlt-setup-java/
│ │ │ └── action.yml
│ │ ├── mlt-setup-node/
│ │ │ └── action.yml
│ │ └── mlt-setup-rust/
│ │ └── action.yml
│ ├── dependabot.yml
│ └── workflows/
│ ├── autofix.yml
│ ├── ci.yml
│ ├── cpp.yml
│ ├── dependabot.yml
│ ├── gh-pages.yml
│ ├── hotpath-comment.yml
│ ├── hotpath-profile.yml
│ ├── java-release.yml
│ ├── java.yml
│ ├── python-release.yml
│ ├── rust.yml
│ ├── ts-bump-version.yml
│ ├── ts-release.yml
│ └── ts.yml
├── .gitignore
├── .gitmodules
├── .pre-commit-config.yaml
├── CODE_OF_CONDUCT.md
├── LICENSE-APACHE
├── LICENSE-CC0
├── LICENSE-MIT
├── MODULE.bazel
├── README.md
├── SECURITY_POLICY.txt
├── biome.json
├── cpp/
│ ├── .clang-tidy
│ ├── .gitignore
│ ├── .nvmrc
│ ├── BUILD.bazel
│ ├── CMakeLists.txt
│ ├── CTestCustom.cmake
│ ├── README.md
│ ├── bazel/
│ │ └── check/
│ │ ├── BUILD.bazel
│ │ ├── avx.c
│ │ ├── avx2.c
│ │ └── sse42.c
│ ├── cmake/
│ │ └── AddCXXCompilerFlag.cmake
│ ├── include/
│ │ └── mlt/
│ │ ├── common.hpp
│ │ ├── coordinate.hpp
│ │ ├── decoder.hpp
│ │ ├── feature.hpp
│ │ ├── geometry.hpp
│ │ ├── geometry_vector.hpp
│ │ ├── json.hpp
│ │ ├── layer.hpp
│ │ ├── metadata/
│ │ │ ├── stream.hpp
│ │ │ ├── tileset.hpp
│ │ │ └── type_map.hpp
│ │ ├── polyfill.hpp
│ │ ├── projection.hpp
│ │ ├── properties.hpp
│ │ ├── tile.hpp
│ │ └── util/
│ │ ├── buffer_stream.hpp
│ │ ├── noncopyable.hpp
│ │ ├── packed_bitset.hpp
│ │ ├── stl.hpp
│ │ └── varint.hpp
│ ├── mod.just
│ ├── package.json
│ ├── src/
│ │ └── mlt/
│ │ ├── decode/
│ │ │ ├── geometry.hpp
│ │ │ ├── int.cpp
│ │ │ ├── int.hpp
│ │ │ ├── int_template.hpp
│ │ │ ├── property.hpp
│ │ │ └── string.hpp
│ │ ├── decoder.cpp
│ │ ├── feature.cpp
│ │ ├── geometry_vector.cpp
│ │ ├── layer.cpp
│ │ ├── metadata/
│ │ │ ├── stream.cpp
│ │ │ └── tileset.cpp
│ │ ├── properties.cpp
│ │ └── util/
│ │ ├── json_diff.hpp
│ │ ├── morton_curve.hpp
│ │ ├── raw.hpp
│ │ ├── rle.cpp
│ │ ├── rle.hpp
│ │ ├── space_filling_curve.hpp
│ │ ├── vectorized.hpp
│ │ └── zigzag.hpp
│ ├── test/
│ │ ├── CMakeLists.txt
│ │ ├── test_decode.cpp
│ │ ├── test_fastpfor.cpp
│ │ ├── test_fsst.cpp
│ │ ├── test_packed_bitset.cpp
│ │ ├── test_util.cpp
│ │ └── test_varint.cpp
│ ├── tool/
│ │ ├── CMakeLists.txt
│ │ ├── mlt-json.cpp
│ │ ├── synthetic-geojson.cpp
│ │ ├── synthetic-geojson.hpp
│ │ └── synthetic.test.ts
│ └── vendor/
│ └── fastpfor.cmake
├── docs/
│ ├── assets/
│ │ ├── extra.css
│ │ └── spec/
│ │ ├── mlt_tileset_metadata.json
│ │ └── place_feature.json
│ ├── encodings.md
│ ├── implementation-status.md
│ ├── index.md
│ ├── snippets/
│ │ └── live-spec-note
│ └── specification.md
├── java/
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── README-Decode.md
│ ├── README-Encode.md
│ ├── README.MD
│ ├── encoding-server/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── config.json
│ │ ├── config.mjs
│ │ ├── convert.mjs
│ │ ├── eslint.config.mjs
│ │ ├── package.json
│ │ └── server.mjs
│ ├── gradle/
│ │ ├── libs.versions.toml
│ │ └── wrapper/
│ │ ├── gradle-wrapper.jar
│ │ └── gradle-wrapper.properties
│ ├── gradlew
│ ├── gradlew.bat
│ ├── lombok.config
│ ├── mlt-cli/
│ │ ├── build.gradle
│ │ └── src/
│ │ ├── main/
│ │ │ ├── kotlin/
│ │ │ │ └── org/
│ │ │ │ └── maplibre/
│ │ │ │ └── mlt/
│ │ │ │ └── cli/
│ │ │ │ ├── Conversion.kt
│ │ │ │ ├── Decode.kt
│ │ │ │ ├── Encode.kt
│ │ │ │ ├── EncodeCommandLine.kt
│ │ │ │ ├── EncodeConfig.kt
│ │ │ │ ├── Environment.kt
│ │ │ │ ├── Json.kt
│ │ │ │ ├── Logging.kt
│ │ │ │ ├── MBTiles.kt
│ │ │ │ ├── OfflineDB.kt
│ │ │ │ ├── PMTiles.kt
│ │ │ │ ├── ReadablePmtiles.kt
│ │ │ │ ├── SerialTaskRunner.kt
│ │ │ │ ├── Server.kt
│ │ │ │ ├── TaskRunner.kt
│ │ │ │ ├── ThreadPoolTaskRunner.kt
│ │ │ │ └── Timer.kt
│ │ │ └── resources/
│ │ │ └── log4j2.json
│ │ └── test/
│ │ └── kotlin/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ └── cli/
│ │ ├── EncodeCommandLineTest.kt
│ │ ├── EnvironmentResolverTest.kt
│ │ ├── LoggingTest.kt
│ │ ├── ReadablePmtilesMapDirectoryTest.kt
│ │ ├── TaskRunnerTest.kt
│ │ ├── TestUtil.kt
│ │ └── TileCoordRangeTest.kt
│ ├── mlt-core/
│ │ ├── build.gradle
│ │ └── src/
│ │ ├── jmh/
│ │ │ └── java/
│ │ │ └── org/
│ │ │ └── maplibre/
│ │ │ └── mlt/
│ │ │ ├── BenchmarkUtils.java
│ │ │ ├── OmtDecoderBenchmark.java
│ │ │ ├── converter/
│ │ │ │ └── encodings/
│ │ │ │ └── fsst/
│ │ │ │ └── FsstBenchmark.java
│ │ │ └── data/
│ │ │ ├── rle_PartOffsets.csv
│ │ │ ├── rle_class_ratio17.csv
│ │ │ └── rle_id_ratio22_45k.csv
│ │ ├── main/
│ │ │ └── java/
│ │ │ ├── org/
│ │ │ │ └── maplibre/
│ │ │ │ └── mlt/
│ │ │ │ ├── compare/
│ │ │ │ │ └── CompareHelper.java
│ │ │ │ ├── converter/
│ │ │ │ │ ├── CollectionUtils.java
│ │ │ │ │ ├── ColumnMapping.java
│ │ │ │ │ ├── ColumnMappingConfig.java
│ │ │ │ │ ├── ConversionConfig.java
│ │ │ │ │ ├── FeatureTableOptimizations.java
│ │ │ │ │ ├── MltConverter.java
│ │ │ │ │ ├── MortonSettings.java
│ │ │ │ │ ├── encodings/
│ │ │ │ │ │ ├── BooleanEncoder.java
│ │ │ │ │ │ ├── ByteRleEncoder.java
│ │ │ │ │ │ ├── DoubleEncoder.java
│ │ │ │ │ │ ├── EncodingUtils.java
│ │ │ │ │ │ ├── FloatEncoder.java
│ │ │ │ │ │ ├── GeometryEncoder.java
│ │ │ │ │ │ ├── IntegerEncoder.java
│ │ │ │ │ │ ├── LinearRegression.java
│ │ │ │ │ │ ├── MltTypeMap.java
│ │ │ │ │ │ ├── PropertyEncoder.java
│ │ │ │ │ │ ├── StringEncoder.java
│ │ │ │ │ │ └── fsst/
│ │ │ │ │ │ ├── Fsst.java
│ │ │ │ │ │ ├── FsstDebug.java
│ │ │ │ │ │ ├── FsstEncoder.java
│ │ │ │ │ │ ├── FsstJava.java
│ │ │ │ │ │ ├── FsstJni.java
│ │ │ │ │ │ ├── Symbol.java
│ │ │ │ │ │ ├── SymbolTable.java
│ │ │ │ │ │ └── SymbolTableBuilder.java
│ │ │ │ │ ├── geometry/
│ │ │ │ │ │ ├── GeometryType.java
│ │ │ │ │ │ ├── GeometryUtils.java
│ │ │ │ │ │ ├── Hilbert.java
│ │ │ │ │ │ ├── HilbertCurve.java
│ │ │ │ │ │ ├── SpaceFillingCurve.java
│ │ │ │ │ │ ├── Vertex.java
│ │ │ │ │ │ └── ZOrderCurve.java
│ │ │ │ │ ├── mvt/
│ │ │ │ │ │ └── MvtUtils.java
│ │ │ │ │ └── tessellation/
│ │ │ │ │ ├── TessellatedPolygon.java
│ │ │ │ │ └── TessellationUtils.java
│ │ │ │ ├── data/
│ │ │ │ │ ├── Feature.java
│ │ │ │ │ ├── FeatureInterface.java
│ │ │ │ │ ├── IndexedProperty.java
│ │ │ │ │ ├── Layer.java
│ │ │ │ │ ├── LayerSource.java
│ │ │ │ │ ├── MLTFeature.java
│ │ │ │ │ ├── MVTFeature.java
│ │ │ │ │ ├── MapLibreTile.java
│ │ │ │ │ ├── MapboxVectorTile.java
│ │ │ │ │ ├── Property.java
│ │ │ │ │ └── unsigned/
│ │ │ │ │ ├── U32.java
│ │ │ │ │ ├── U64.java
│ │ │ │ │ ├── U8.java
│ │ │ │ │ └── Unsigned.java
│ │ │ │ ├── decoder/
│ │ │ │ │ ├── ByteRleDecoder.java
│ │ │ │ │ ├── DecodingUtils.java
│ │ │ │ │ ├── DoubleDecoder.java
│ │ │ │ │ ├── FloatDecoder.java
│ │ │ │ │ ├── GeometryDecoder.java
│ │ │ │ │ ├── IntegerDecoder.java
│ │ │ │ │ ├── MltDecoder.java
│ │ │ │ │ ├── PropertyDecoder.java
│ │ │ │ │ ├── StringDecoder.java
│ │ │ │ │ └── vectorized/
│ │ │ │ │ └── VectorizedDecodingUtils.java
│ │ │ │ ├── json/
│ │ │ │ │ └── Json.java
│ │ │ │ ├── metadata/
│ │ │ │ │ ├── stream/
│ │ │ │ │ │ ├── DictionaryType.java
│ │ │ │ │ │ ├── LengthType.java
│ │ │ │ │ │ ├── LogicalLevelTechnique.java
│ │ │ │ │ │ ├── LogicalStreamType.java
│ │ │ │ │ │ ├── MortonEncodedStreamMetadata.java
│ │ │ │ │ │ ├── OffsetType.java
│ │ │ │ │ │ ├── PhysicalLevelTechnique.java
│ │ │ │ │ │ ├── PhysicalStreamType.java
│ │ │ │ │ │ ├── RleEncodedStreamMetadata.java
│ │ │ │ │ │ ├── StreamMetadata.java
│ │ │ │ │ │ └── StreamMetadataDecoder.java
│ │ │ │ │ └── tileset/
│ │ │ │ │ └── MltMetadata.java
│ │ │ │ └── util/
│ │ │ │ ├── ByteArrayUtil.java
│ │ │ │ ├── ExceptionUtil.java
│ │ │ │ ├── OptionalUtil.java
│ │ │ │ └── StreamUtil.java
│ │ │ └── springmeyer/
│ │ │ ├── Pbf.java
│ │ │ ├── Point.java
│ │ │ ├── VectorTile.java
│ │ │ ├── VectorTileFeature.java
│ │ │ └── VectorTileLayer.java
│ │ └── test/
│ │ └── java/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ ├── MltGenerator.java
│ │ ├── TestSettings.java
│ │ ├── TestUtils.java
│ │ ├── benchmarks/
│ │ │ ├── CompressionBenchmarksTest.java
│ │ │ └── MltDecoderBenchmarkTest.java
│ │ ├── compare/
│ │ │ └── CompareHelperTest.java
│ │ ├── converter/
│ │ │ ├── ConversionConfigTest.java
│ │ │ ├── MltConverterTest.java
│ │ │ ├── encodings/
│ │ │ │ ├── EncodingUtilsTest.java
│ │ │ │ ├── LinearRegressionTest.java
│ │ │ │ ├── MltTypeMapTest.java
│ │ │ │ ├── VarintTest.java
│ │ │ │ └── fsst/
│ │ │ │ ├── FsstTest.java
│ │ │ │ └── SymbolTest.java
│ │ │ ├── geometry/
│ │ │ │ ├── HilbertCurveTest.java
│ │ │ │ ├── SpaceFillingCurveTest.java
│ │ │ │ └── ZOrderCurveTest.java
│ │ │ └── tessellation/
│ │ │ └── TessellationUtilsTest.java
│ │ ├── data/
│ │ │ └── unsigned/
│ │ │ └── UnsignedTest.java
│ │ ├── decoder/
│ │ │ ├── ByteRleTest.java
│ │ │ ├── DecodingUtilsTest.java
│ │ │ ├── DoubleDecoderTest.java
│ │ │ ├── IntegerDecoderTest.java
│ │ │ ├── MltDecoderTest.java
│ │ │ ├── MltDecoderTest2.java
│ │ │ └── StringDecoderTest.java
│ │ ├── json/
│ │ │ └── JsonTest.java
│ │ ├── metadata/
│ │ │ └── tileset/
│ │ │ └── MltMetadataColumnTest.java
│ │ ├── synthetics/
│ │ │ └── SyntheticsTest.java
│ │ └── util/
│ │ ├── OptionalUtilTest.java
│ │ └── StreamUtilTest.java
│ ├── mlt-tools/
│ │ ├── build.gradle
│ │ └── src/
│ │ └── main/
│ │ └── java/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ └── tools/
│ │ ├── SyntheticMltGenerator.java
│ │ └── SyntheticMltUtil.java
│ ├── mod.just
│ ├── resources/
│ │ ├── CMakeLists.txt
│ │ ├── FsstWrapper.cpp
│ │ ├── FsstWrapper.h
│ │ ├── compile
│ │ └── compile-windows.bat
│ ├── settings.gradle
│ └── tessellation/
│ ├── index.mjs
│ └── package.json
├── justfile
├── mkdocs.yml
├── qgis/
│ ├── .gitignore
│ ├── README.md
│ └── mlt_plugin/
│ ├── __init__.py
│ ├── loader.py
│ ├── metadata.txt
│ ├── plugin.py
│ └── tile_coords.py
├── release-plz.toml
├── rust/
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── bench_param.sh
│ ├── clippy.toml
│ ├── mlt/
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ └── src/
│ │ ├── convert/
│ │ │ ├── files.rs
│ │ │ ├── mod.rs
│ │ │ └── tileset.rs
│ │ ├── dump.rs
│ │ ├── ls.rs
│ │ ├── main.rs
│ │ └── ui/
│ │ ├── mbt.rs
│ │ ├── mod.rs
│ │ ├── rendering/
│ │ │ ├── files.rs
│ │ │ ├── help.rs
│ │ │ ├── layers.rs
│ │ │ ├── map.rs
│ │ │ └── mod.rs
│ │ └── state.rs
│ ├── mlt-core/
│ │ ├── .gitignore
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── benches/
│ │ │ ├── bench_utils.rs
│ │ │ ├── decoding_e2e.rs
│ │ │ ├── decoding_strings.rs
│ │ │ ├── decoding_utils.rs
│ │ │ ├── encoding_e2e.rs
│ │ │ └── encoding_from_mvt.rs
│ │ ├── fuzz/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── fuzz_targets/
│ │ │ │ ├── decoded_layer.rs
│ │ │ │ └── layer.rs
│ │ │ ├── src/
│ │ │ │ ├── decoded_layer.rs
│ │ │ │ ├── layer.rs
│ │ │ │ └── lib.rs
│ │ │ └── tests/
│ │ │ └── reproduce.rs
│ │ ├── src/
│ │ │ ├── codecs/
│ │ │ │ ├── bytes.rs
│ │ │ │ ├── fastpfor.rs
│ │ │ │ ├── fsst.rs
│ │ │ │ ├── hilbert.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── morton.rs
│ │ │ │ ├── rle.rs
│ │ │ │ ├── varint.rs
│ │ │ │ └── zigzag.rs
│ │ │ ├── convert/
│ │ │ │ ├── geojson.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── mvt.rs
│ │ │ ├── decoder/
│ │ │ │ ├── analyze.rs
│ │ │ │ ├── column.rs
│ │ │ │ ├── fuzzing.rs
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── geotype.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── model.rs
│ │ │ │ ├── id/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── model.rs
│ │ │ │ ├── iterators.rs
│ │ │ │ ├── layer.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── model.rs
│ │ │ │ ├── property/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── geojson.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ └── strings.rs
│ │ │ │ ├── root.rs
│ │ │ │ ├── stream/
│ │ │ │ │ ├── analyze.rs
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── logical.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── parse.rs
│ │ │ │ │ └── physical.rs
│ │ │ │ └── tile.rs
│ │ │ ├── encoder/
│ │ │ │ ├── analyze.rs
│ │ │ │ ├── fuzzing.rs
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── encode.rs
│ │ │ │ │ ├── geotype.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ └── tests.rs
│ │ │ │ ├── id/
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── staged_id.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── model.rs
│ │ │ │ ├── optimizer.rs
│ │ │ │ ├── property/
│ │ │ │ │ ├── encode.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── shared_dict.rs
│ │ │ │ │ ├── strings.rs
│ │ │ │ │ └── tests.rs
│ │ │ │ ├── sort.rs
│ │ │ │ ├── stream/
│ │ │ │ │ ├── codecs.rs
│ │ │ │ │ ├── encode_stream.rs
│ │ │ │ │ ├── encoder.rs
│ │ │ │ │ ├── logical.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── optimizer.rs
│ │ │ │ │ ├── physical.rs
│ │ │ │ │ ├── tests.rs
│ │ │ │ │ └── write.rs
│ │ │ │ ├── tests.rs
│ │ │ │ ├── tile.rs
│ │ │ │ ├── unknown.rs
│ │ │ │ └── writer.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ └── utils/
│ │ │ ├── analyze.rs
│ │ │ ├── extensions.rs
│ │ │ ├── formatter.rs
│ │ │ ├── lazy_state.rs
│ │ │ ├── mod.rs
│ │ │ ├── parse.rs
│ │ │ ├── presence.rs
│ │ │ ├── serialize.rs
│ │ │ └── test_helpers.rs
│ │ └── tests/
│ │ ├── geojson.rs
│ │ ├── snapshots.rs
│ │ └── unknown_layer.rs
│ ├── mlt-py/
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── maplibre_tiles.pyi
│ │ ├── pyproject.toml
│ │ └── src/
│ │ ├── bins/
│ │ │ └── stub_gen.rs
│ │ ├── feature.rs
│ │ ├── lib.rs
│ │ └── tile_transform.rs
│ ├── mlt-synthetics/
│ │ ├── Cargo.toml
│ │ └── src/
│ │ ├── layer.rs
│ │ ├── main.rs
│ │ └── writer.rs
│ ├── mlt-wasm/
│ │ ├── .gitignore
│ │ ├── .nvmrc
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── js/
│ │ │ ├── decoder.bench.ts
│ │ │ ├── index.ts
│ │ │ ├── synthetic.spec.ts
│ │ │ └── vectorTile.ts
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── geometry.rs
│ │ │ ├── layer.rs
│ │ │ ├── lib.rs
│ │ │ ├── properties.rs
│ │ │ └── tile.rs
│ │ ├── tsconfig.json
│ │ └── vitest.config.ts
│ ├── mod.just
│ └── tomlfmt.toml
├── spec/
│ └── schema/
│ └── mlt_tileset_metadata.proto
├── test/
│ ├── .gitignore
│ ├── .java-version
│ ├── convert_tiles
│ ├── expected/
│ │ └── tag0x01/
│ │ ├── amazon/
│ │ │ ├── 10_518_352.mlt
│ │ │ ├── 11_1037_704.mlt
│ │ │ ├── 5_16_11.mlt
│ │ │ ├── 5_5_11.mlt
│ │ │ ├── 5_6_21.mlt
│ │ │ ├── 5_8_12.mlt
│ │ │ ├── 6_33_21.mlt
│ │ │ ├── 6_33_22.mlt
│ │ │ ├── 7_68_44.mlt
│ │ │ ├── 8_136_89.mlt
│ │ │ └── 9_259_176.mlt
│ │ ├── amazon_here/
│ │ │ ├── 4_8_5.mlt
│ │ │ ├── 4_9_4.mlt
│ │ │ ├── 5_16_10.mlt
│ │ │ ├── 6_33_22.mlt
│ │ │ └── 8_132_85.mlt
│ │ ├── bing/
│ │ │ ├── 4-12-6.mlt
│ │ │ ├── 4-13-6.mlt
│ │ │ ├── 4-8-5.mlt
│ │ │ ├── 4-9-5.mlt
│ │ │ ├── 5-15-10.mlt
│ │ │ ├── 5-16-11.mlt
│ │ │ ├── 5-16-9.mlt
│ │ │ ├── 5-17-10.mlt
│ │ │ ├── 5-17-11.mlt
│ │ │ ├── 6-32-21.mlt
│ │ │ ├── 6-32-22.mlt
│ │ │ ├── 6-32-23.mlt
│ │ │ ├── 6-33-22.mlt
│ │ │ ├── 7-65-42.mlt
│ │ │ ├── 7-66-42.mlt
│ │ │ ├── 7-66-43.mlt
│ │ │ └── 7-66-44.mlt
│ │ ├── omt/
│ │ │ ├── 0_0_0.mlt
│ │ │ ├── 10_530_682.mlt
│ │ │ ├── 10_530_683.mlt
│ │ │ ├── 10_530_684.mlt
│ │ │ ├── 10_531_682.mlt
│ │ │ ├── 10_531_683.mlt
│ │ │ ├── 10_531_684.mlt
│ │ │ ├── 10_532_682.mlt
│ │ │ ├── 10_532_683.mlt
│ │ │ ├── 10_532_684.mlt
│ │ │ ├── 10_533_682.mlt
│ │ │ ├── 10_533_683.mlt
│ │ │ ├── 10_533_684.mlt
│ │ │ ├── 11_1062_1366.mlt
│ │ │ ├── 11_1062_1367.mlt
│ │ │ ├── 11_1062_1368.mlt
│ │ │ ├── 11_1063_1366.mlt
│ │ │ ├── 11_1063_1367.mlt
│ │ │ ├── 11_1063_1368.mlt
│ │ │ ├── 11_1064_1366.mlt
│ │ │ ├── 11_1064_1367.mlt
│ │ │ ├── 11_1064_1368.mlt
│ │ │ ├── 11_1065_1366.mlt
│ │ │ ├── 11_1065_1367.mlt
│ │ │ ├── 11_1065_1368.mlt
│ │ │ ├── 12_2130_2733.mlt
│ │ │ ├── 12_2130_2734.mlt
│ │ │ ├── 12_2131_2733.mlt
│ │ │ ├── 12_2131_2734.mlt
│ │ │ ├── 12_2132_2733.mlt
│ │ │ ├── 12_2132_2734.mlt
│ │ │ ├── 12_2133_2733.mlt
│ │ │ ├── 12_2133_2734.mlt
│ │ │ ├── 12_2134_2733.mlt
│ │ │ ├── 12_2134_2734.mlt
│ │ │ ├── 13_4264_5467.mlt
│ │ │ ├── 13_4264_5468.mlt
│ │ │ ├── 13_4265_5467.mlt
│ │ │ ├── 13_4265_5468.mlt
│ │ │ ├── 13_4266_5467.mlt
│ │ │ ├── 13_4266_5468.mlt
│ │ │ ├── 13_4267_5467.mlt
│ │ │ ├── 13_4267_5468.mlt
│ │ │ ├── 14_8296_10748.mlt
│ │ │ ├── 14_8296_10749.mlt
│ │ │ ├── 14_8297_10748.mlt
│ │ │ ├── 14_8297_10749.mlt
│ │ │ ├── 14_8298_10748.mlt
│ │ │ ├── 14_8298_10749.mlt
│ │ │ ├── 14_8299_10748.mlt
│ │ │ ├── 14_8299_10749.mlt
│ │ │ ├── 14_8300_10748.mlt
│ │ │ ├── 14_8300_10749.mlt
│ │ │ ├── 1_1_1.mlt
│ │ │ ├── 2_2_2.mlt
│ │ │ ├── 3_4_5.mlt
│ │ │ ├── 4_3_9.mlt
│ │ │ ├── 4_8_10.mlt
│ │ │ ├── 5_16_11.mlt
│ │ │ ├── 5_16_20.mlt
│ │ │ ├── 5_16_21.mlt
│ │ │ ├── 5_17_20.mlt
│ │ │ ├── 5_17_21.mlt
│ │ │ ├── 6_32_41.mlt
│ │ │ ├── 6_32_42.mlt
│ │ │ ├── 6_33_41.mlt
│ │ │ ├── 6_33_42.mlt
│ │ │ ├── 6_34_41.mlt
│ │ │ ├── 6_34_42.mlt
│ │ │ ├── 7_66_83.mlt
│ │ │ ├── 7_66_84.mlt
│ │ │ ├── 7_66_85.mlt
│ │ │ ├── 7_67_83.mlt
│ │ │ ├── 7_67_84.mlt
│ │ │ ├── 7_67_85.mlt
│ │ │ ├── 7_68_83.mlt
│ │ │ ├── 7_68_84.mlt
│ │ │ ├── 7_68_85.mlt
│ │ │ ├── 8_132_170.mlt
│ │ │ ├── 8_132_171.mlt
│ │ │ ├── 8_133_170.mlt
│ │ │ ├── 8_133_171.mlt
│ │ │ ├── 8_134_170.mlt
│ │ │ ├── 8_134_171.mlt
│ │ │ ├── 8_135_170.mlt
│ │ │ ├── 8_135_171.mlt
│ │ │ ├── 9_264_340.mlt
│ │ │ ├── 9_264_341.mlt
│ │ │ ├── 9_264_342.mlt
│ │ │ ├── 9_265_340.mlt
│ │ │ ├── 9_265_341.mlt
│ │ │ ├── 9_265_342.mlt
│ │ │ ├── 9_266_340.mlt
│ │ │ ├── 9_266_341.mlt
│ │ │ └── 9_266_342.mlt
│ │ └── simple/
│ │ ├── LICENSE
│ │ ├── line-boolean.mlt
│ │ ├── line-boolean.mlt.geojson
│ │ ├── multiline-boolean.mlt
│ │ ├── multiline-boolean.mlt.geojson
│ │ ├── multipoint-boolean.mlt
│ │ ├── multipoint-boolean.mlt.geojson
│ │ ├── multipolygon-boolean.mlt
│ │ ├── multipolygon-boolean.mlt.geojson
│ │ ├── point-boolean.mlt
│ │ ├── point-boolean.mlt.geojson
│ │ ├── polygon-boolean.mlt
│ │ └── polygon-boolean.mlt.geojson
│ ├── fixtures/
│ │ ├── amazon/
│ │ │ ├── 10_518_352.mvt
│ │ │ ├── 11_1037_704.mvt
│ │ │ ├── 5_16_11.mvt
│ │ │ ├── 5_5_11.mvt
│ │ │ ├── 5_6_21.mvt
│ │ │ ├── 5_8_12.mvt
│ │ │ ├── 6_33_21.mvt
│ │ │ ├── 6_33_22.mvt
│ │ │ ├── 7_68_44.mvt
│ │ │ ├── 8_136_89.mvt
│ │ │ └── 9_259_176.mvt
│ │ ├── amazon_here/
│ │ │ ├── 4_8_5.mvt
│ │ │ ├── 4_9_4.mvt
│ │ │ ├── 5_16_10.mvt
│ │ │ ├── 6_33_22.mvt
│ │ │ └── 8_132_85.mvt
│ │ ├── bing/
│ │ │ ├── 4-12-6.mvt
│ │ │ ├── 4-13-6.mvt
│ │ │ ├── 4-8-5.mvt
│ │ │ ├── 4-9-5.mvt
│ │ │ ├── 5-15-10.mvt
│ │ │ ├── 5-16-11.mvt
│ │ │ ├── 5-16-9.mvt
│ │ │ ├── 5-17-10.mvt
│ │ │ ├── 5-17-11.mvt
│ │ │ ├── 6-32-21.mvt
│ │ │ ├── 6-32-22.mvt
│ │ │ ├── 6-32-23.mvt
│ │ │ ├── 6-33-22.mvt
│ │ │ ├── 7-65-42.mvt
│ │ │ ├── 7-66-42.mvt
│ │ │ ├── 7-66-43.mvt
│ │ │ └── 7-66-44.mvt
│ │ ├── fastpfor/
│ │ │ └── README.md
│ │ ├── omt/
│ │ │ ├── 0_0_0.mvt
│ │ │ ├── 10_530_682.mvt
│ │ │ ├── 10_530_683.mvt
│ │ │ ├── 10_530_684.mvt
│ │ │ ├── 10_531_682.mvt
│ │ │ ├── 10_531_683.mvt
│ │ │ ├── 10_531_684.mvt
│ │ │ ├── 10_532_682.mvt
│ │ │ ├── 10_532_683.mvt
│ │ │ ├── 10_532_684.mvt
│ │ │ ├── 10_533_682.mvt
│ │ │ ├── 10_533_683.mvt
│ │ │ ├── 10_533_684.mvt
│ │ │ ├── 11_1062_1366.mvt
│ │ │ ├── 11_1062_1367.mvt
│ │ │ ├── 11_1062_1368.mvt
│ │ │ ├── 11_1063_1366.mvt
│ │ │ ├── 11_1063_1367.mvt
│ │ │ ├── 11_1063_1368.mvt
│ │ │ ├── 11_1064_1366.mvt
│ │ │ ├── 11_1064_1367.mvt
│ │ │ ├── 11_1064_1368.mvt
│ │ │ ├── 11_1065_1366.mvt
│ │ │ ├── 11_1065_1367.mvt
│ │ │ ├── 11_1065_1368.mvt
│ │ │ ├── 12_2130_2733.mvt
│ │ │ ├── 12_2130_2734.mvt
│ │ │ ├── 12_2131_2733.mvt
│ │ │ ├── 12_2131_2734.mvt
│ │ │ ├── 12_2132_2733.mvt
│ │ │ ├── 12_2132_2734.mvt
│ │ │ ├── 12_2133_2733.mvt
│ │ │ ├── 12_2133_2734.mvt
│ │ │ ├── 12_2134_2733.mvt
│ │ │ ├── 12_2134_2734.mvt
│ │ │ ├── 13_4264_5467.mvt
│ │ │ ├── 13_4264_5468.mvt
│ │ │ ├── 13_4265_5467.mvt
│ │ │ ├── 13_4265_5468.mvt
│ │ │ ├── 13_4266_5467.mvt
│ │ │ ├── 13_4266_5468.mvt
│ │ │ ├── 13_4267_5467.mvt
│ │ │ ├── 13_4267_5468.mvt
│ │ │ ├── 14_8296_10748.mvt
│ │ │ ├── 14_8296_10749.mvt
│ │ │ ├── 14_8297_10748.mvt
│ │ │ ├── 14_8297_10749.mvt
│ │ │ ├── 14_8298_10748.mvt
│ │ │ ├── 14_8298_10749.mvt
│ │ │ ├── 14_8299_10748.mvt
│ │ │ ├── 14_8299_10749.mvt
│ │ │ ├── 14_8300_10748.mvt
│ │ │ ├── 14_8300_10749.mvt
│ │ │ ├── 1_1_1.mvt
│ │ │ ├── 2_2_2.mvt
│ │ │ ├── 3_4_5.mvt
│ │ │ ├── 4_3_9.mvt
│ │ │ ├── 4_8_10.mvt
│ │ │ ├── 5_16_11.mvt
│ │ │ ├── 5_16_20.mvt
│ │ │ ├── 5_16_21.mvt
│ │ │ ├── 5_17_20.mvt
│ │ │ ├── 5_17_21.mvt
│ │ │ ├── 6_32_41.mvt
│ │ │ ├── 6_32_42.mvt
│ │ │ ├── 6_33_41.mvt
│ │ │ ├── 6_33_42.mvt
│ │ │ ├── 6_34_41.mvt
│ │ │ ├── 6_34_42.mvt
│ │ │ ├── 7_66_83.mvt
│ │ │ ├── 7_66_84.mvt
│ │ │ ├── 7_66_85.mvt
│ │ │ ├── 7_67_83.mvt
│ │ │ ├── 7_67_84.mvt
│ │ │ ├── 7_67_85.mvt
│ │ │ ├── 7_68_83.mvt
│ │ │ ├── 7_68_84.mvt
│ │ │ ├── 7_68_85.mvt
│ │ │ ├── 8_132_170.mvt
│ │ │ ├── 8_132_171.mvt
│ │ │ ├── 8_133_170.mvt
│ │ │ ├── 8_133_171.mvt
│ │ │ ├── 8_134_170.mvt
│ │ │ ├── 8_134_171.mvt
│ │ │ ├── 8_135_170.mvt
│ │ │ ├── 8_135_171.mvt
│ │ │ ├── 9_264_340.mvt
│ │ │ ├── 9_264_341.mvt
│ │ │ ├── 9_264_342.mvt
│ │ │ ├── 9_265_340.mvt
│ │ │ ├── 9_265_341.mvt
│ │ │ ├── 9_265_342.mvt
│ │ │ ├── 9_266_340.mvt
│ │ │ ├── 9_266_341.mvt
│ │ │ └── 9_266_342.mvt
│ │ ├── omt-planet-20260112.mvt.max1.pmtiles
│ │ ├── omt-planet-20260112.mvt.max1.pmtiles.txt
│ │ ├── omt.max1.mbtiles
│ │ └── simple/
│ │ ├── LICENSE
│ │ ├── line-boolean.mvt
│ │ ├── multiline-boolean.mvt
│ │ ├── multipoint-boolean.mvt
│ │ ├── multipolygon-boolean.mvt
│ │ ├── point-boolean.mvt
│ │ └── polygon-boolean.mvt
│ ├── omt-advanced-mlt.mbtiles
│ ├── omt-basic-mlt.mbtiles
│ ├── omt-ref.mbtiles
│ └── synthetic/
│ ├── 0x01/
│ │ ├── extent_1073741824.json
│ │ ├── extent_1073741824.mlt
│ │ ├── extent_131072.json
│ │ ├── extent_131072.mlt
│ │ ├── extent_4096.json
│ │ ├── extent_4096.mlt
│ │ ├── extent_512.json
│ │ ├── extent_512.mlt
│ │ ├── extent_buf_1073741824.json
│ │ ├── extent_buf_1073741824.mlt
│ │ ├── extent_buf_131072.json
│ │ ├── extent_buf_131072.mlt
│ │ ├── extent_buf_4096.json
│ │ ├── extent_buf_4096.mlt
│ │ ├── extent_buf_512.json
│ │ ├── extent_buf_512.mlt
│ │ ├── fpf_align_1.json
│ │ ├── fpf_align_1.mlt
│ │ ├── fpf_align_2.json
│ │ ├── fpf_align_2.mlt
│ │ ├── fpf_align_3.json
│ │ ├── fpf_align_3.mlt
│ │ ├── fpf_align_4.json
│ │ ├── fpf_align_4.mlt
│ │ ├── fpf_align_5.json
│ │ ├── fpf_align_5.mlt
│ │ ├── fpf_align_6.json
│ │ ├── fpf_align_6.mlt
│ │ ├── fpf_align_7.json
│ │ ├── fpf_align_7.mlt
│ │ ├── fpf_align_8.json
│ │ ├── fpf_align_8.mlt
│ │ ├── id.json
│ │ ├── id.mlt
│ │ ├── id64.json
│ │ ├── id64.mlt
│ │ ├── id_min.json
│ │ ├── id_min.mlt
│ │ ├── ids.json
│ │ ├── ids.mlt
│ │ ├── ids64.json
│ │ ├── ids64.mlt
│ │ ├── ids64_delta.json
│ │ ├── ids64_delta.mlt
│ │ ├── ids64_delta_rle.json
│ │ ├── ids64_delta_rle.mlt
│ │ ├── ids64_opt.json
│ │ ├── ids64_opt.mlt
│ │ ├── ids64_opt_delta.json
│ │ ├── ids64_opt_delta.mlt
│ │ ├── ids64_rle.json
│ │ ├── ids64_rle.mlt
│ │ ├── ids_delta.json
│ │ ├── ids_delta.mlt
│ │ ├── ids_delta_rle.json
│ │ ├── ids_delta_rle.mlt
│ │ ├── ids_opt.json
│ │ ├── ids_opt.mlt
│ │ ├── ids_opt_delta.json
│ │ ├── ids_opt_delta.mlt
│ │ ├── ids_rle.json
│ │ ├── ids_rle.mlt
│ │ ├── line.json
│ │ ├── line.mlt
│ │ ├── line_morton_curve_morton.json
│ │ ├── line_morton_curve_morton.mlt
│ │ ├── line_morton_curve_no_morton.json
│ │ ├── line_morton_curve_no_morton.mlt
│ │ ├── line_zero_length.json
│ │ ├── line_zero_length.mlt
│ │ ├── mix_2_line_line.json
│ │ ├── mix_2_line_line.mlt
│ │ ├── mix_2_line_mline.json
│ │ ├── mix_2_line_mline.mlt
│ │ ├── mix_2_line_mpoly.json
│ │ ├── mix_2_line_mpoly.mlt
│ │ ├── mix_2_line_mpt.json
│ │ ├── mix_2_line_mpt.mlt
│ │ ├── mix_2_line_poly.json
│ │ ├── mix_2_line_poly.mlt
│ │ ├── mix_2_line_polyh.json
│ │ ├── mix_2_line_polyh.mlt
│ │ ├── mix_2_mline_mline.json
│ │ ├── mix_2_mline_mline.mlt
│ │ ├── mix_2_mline_mpoly.json
│ │ ├── mix_2_mline_mpoly.mlt
│ │ ├── mix_2_mpoly_mpoly.json
│ │ ├── mix_2_mpoly_mpoly.mlt
│ │ ├── mix_2_mpoly_mpoly_tes.json
│ │ ├── mix_2_mpoly_mpoly_tes.mlt
│ │ ├── mix_2_mpt_mline.json
│ │ ├── mix_2_mpt_mline.mlt
│ │ ├── mix_2_mpt_mpoly.json
│ │ ├── mix_2_mpt_mpoly.mlt
│ │ ├── mix_2_mpt_mpt.json
│ │ ├── mix_2_mpt_mpt.mlt
│ │ ├── mix_2_poly_mline.json
│ │ ├── mix_2_poly_mline.mlt
│ │ ├── mix_2_poly_mpoly.json
│ │ ├── mix_2_poly_mpoly.mlt
│ │ ├── mix_2_poly_mpoly_tes.json
│ │ ├── mix_2_poly_mpoly_tes.mlt
│ │ ├── mix_2_poly_mpt.json
│ │ ├── mix_2_poly_mpt.mlt
│ │ ├── mix_2_poly_poly.json
│ │ ├── mix_2_poly_poly.mlt
│ │ ├── mix_2_poly_poly_tes.json
│ │ ├── mix_2_poly_poly_tes.mlt
│ │ ├── mix_2_poly_polyh.json
│ │ ├── mix_2_poly_polyh.mlt
│ │ ├── mix_2_poly_polyh_tes.json
│ │ ├── mix_2_poly_polyh_tes.mlt
│ │ ├── mix_2_polyh_mline.json
│ │ ├── mix_2_polyh_mline.mlt
│ │ ├── mix_2_polyh_mpoly.json
│ │ ├── mix_2_polyh_mpoly.mlt
│ │ ├── mix_2_polyh_mpoly_tes.json
│ │ ├── mix_2_polyh_mpoly_tes.mlt
│ │ ├── mix_2_polyh_mpt.json
│ │ ├── mix_2_polyh_mpt.mlt
│ │ ├── mix_2_polyh_polyh.json
│ │ ├── mix_2_polyh_polyh.mlt
│ │ ├── mix_2_polyh_polyh_tes.json
│ │ ├── mix_2_polyh_polyh_tes.mlt
│ │ ├── mix_2_pt_line.json
│ │ ├── mix_2_pt_line.mlt
│ │ ├── mix_2_pt_mline.json
│ │ ├── mix_2_pt_mline.mlt
│ │ ├── mix_2_pt_mpoly.json
│ │ ├── mix_2_pt_mpoly.mlt
│ │ ├── mix_2_pt_mpt.json
│ │ ├── mix_2_pt_mpt.mlt
│ │ ├── mix_2_pt_poly.json
│ │ ├── mix_2_pt_poly.mlt
│ │ ├── mix_2_pt_polyh.json
│ │ ├── mix_2_pt_polyh.mlt
│ │ ├── mix_2_pt_pt.json
│ │ ├── mix_2_pt_pt.mlt
│ │ ├── mix_3_line_mline_line.json
│ │ ├── mix_3_line_mline_line.mlt
│ │ ├── mix_3_line_mline_mpoly.json
│ │ ├── mix_3_line_mline_mpoly.mlt
│ │ ├── mix_3_line_mpoly_line.json
│ │ ├── mix_3_line_mpoly_line.mlt
│ │ ├── mix_3_line_mpt_line.json
│ │ ├── mix_3_line_mpt_line.mlt
│ │ ├── mix_3_line_mpt_mline.json
│ │ ├── mix_3_line_mpt_mline.mlt
│ │ ├── mix_3_line_mpt_mpoly.json
│ │ ├── mix_3_line_mpt_mpoly.mlt
│ │ ├── mix_3_line_poly_line.json
│ │ ├── mix_3_line_poly_line.mlt
│ │ ├── mix_3_line_poly_mline.json
│ │ ├── mix_3_line_poly_mline.mlt
│ │ ├── mix_3_line_poly_mpoly.json
│ │ ├── mix_3_line_poly_mpoly.mlt
│ │ ├── mix_3_line_poly_mpt.json
│ │ ├── mix_3_line_poly_mpt.mlt
│ │ ├── mix_3_line_poly_polyh.json
│ │ ├── mix_3_line_poly_polyh.mlt
│ │ ├── mix_3_line_polyh_line.json
│ │ ├── mix_3_line_polyh_line.mlt
│ │ ├── mix_3_line_polyh_mline.json
│ │ ├── mix_3_line_polyh_mline.mlt
│ │ ├── mix_3_line_polyh_mpoly.json
│ │ ├── mix_3_line_polyh_mpoly.mlt
│ │ ├── mix_3_line_polyh_mpt.json
│ │ ├── mix_3_line_polyh_mpt.mlt
│ │ ├── mix_3_line_pt_line.json
│ │ ├── mix_3_line_pt_line.mlt
│ │ ├── mix_3_mline_line_mline.json
│ │ ├── mix_3_mline_line_mline.mlt
│ │ ├── mix_3_mline_mpoly_mline.json
│ │ ├── mix_3_mline_mpoly_mline.mlt
│ │ ├── mix_3_mline_mpt_mline.json
│ │ ├── mix_3_mline_mpt_mline.mlt
│ │ ├── mix_3_mline_poly_mline.json
│ │ ├── mix_3_mline_poly_mline.mlt
│ │ ├── mix_3_mline_polyh_mline.json
│ │ ├── mix_3_mline_polyh_mline.mlt
│ │ ├── mix_3_mline_pt_mline.json
│ │ ├── mix_3_mline_pt_mline.mlt
│ │ ├── mix_3_mpoly_line_mpoly.json
│ │ ├── mix_3_mpoly_line_mpoly.mlt
│ │ ├── mix_3_mpoly_mline_mpoly.json
│ │ ├── mix_3_mpoly_mline_mpoly.mlt
│ │ ├── mix_3_mpoly_mpt_mpoly.json
│ │ ├── mix_3_mpoly_mpt_mpoly.mlt
│ │ ├── mix_3_mpoly_poly_mpoly.json
│ │ ├── mix_3_mpoly_poly_mpoly.mlt
│ │ ├── mix_3_mpoly_poly_mpoly_tes.json
│ │ ├── mix_3_mpoly_poly_mpoly_tes.mlt
│ │ ├── mix_3_mpoly_polyh_mpoly.json
│ │ ├── mix_3_mpoly_polyh_mpoly.mlt
│ │ ├── mix_3_mpoly_polyh_mpoly_tes.json
│ │ ├── mix_3_mpoly_polyh_mpoly_tes.mlt
│ │ ├── mix_3_mpoly_pt_mpoly.json
│ │ ├── mix_3_mpoly_pt_mpoly.mlt
│ │ ├── mix_3_mpt_line_mpt.json
│ │ ├── mix_3_mpt_line_mpt.mlt
│ │ ├── mix_3_mpt_mline_mpoly.json
│ │ ├── mix_3_mpt_mline_mpoly.mlt
│ │ ├── mix_3_mpt_mline_mpt.json
│ │ ├── mix_3_mpt_mline_mpt.mlt
│ │ ├── mix_3_mpt_mpoly_mpt.json
│ │ ├── mix_3_mpt_mpoly_mpt.mlt
│ │ ├── mix_3_mpt_poly_mpt.json
│ │ ├── mix_3_mpt_poly_mpt.mlt
│ │ ├── mix_3_mpt_polyh_mpt.json
│ │ ├── mix_3_mpt_polyh_mpt.mlt
│ │ ├── mix_3_mpt_pt_mpt.json
│ │ ├── mix_3_mpt_pt_mpt.mlt
│ │ ├── mix_3_poly_line_poly.json
│ │ ├── mix_3_poly_line_poly.mlt
│ │ ├── mix_3_poly_mline_mpoly.json
│ │ ├── mix_3_poly_mline_mpoly.mlt
│ │ ├── mix_3_poly_mline_poly.json
│ │ ├── mix_3_poly_mline_poly.mlt
│ │ ├── mix_3_poly_mpoly_poly.json
│ │ ├── mix_3_poly_mpoly_poly.mlt
│ │ ├── mix_3_poly_mpoly_poly_tes.json
│ │ ├── mix_3_poly_mpoly_poly_tes.mlt
│ │ ├── mix_3_poly_mpt_mline.json
│ │ ├── mix_3_poly_mpt_mline.mlt
│ │ ├── mix_3_poly_mpt_mpoly.json
│ │ ├── mix_3_poly_mpt_mpoly.mlt
│ │ ├── mix_3_poly_mpt_poly.json
│ │ ├── mix_3_poly_mpt_poly.mlt
│ │ ├── mix_3_poly_polyh_mline.json
│ │ ├── mix_3_poly_polyh_mline.mlt
│ │ ├── mix_3_poly_polyh_mpoly.json
│ │ ├── mix_3_poly_polyh_mpoly.mlt
│ │ ├── mix_3_poly_polyh_mpoly_tes.json
│ │ ├── mix_3_poly_polyh_mpoly_tes.mlt
│ │ ├── mix_3_poly_polyh_mpt.json
│ │ ├── mix_3_poly_polyh_mpt.mlt
│ │ ├── mix_3_poly_polyh_poly.json
│ │ ├── mix_3_poly_polyh_poly.mlt
│ │ ├── mix_3_poly_polyh_poly_tes.json
│ │ ├── mix_3_poly_polyh_poly_tes.mlt
│ │ ├── mix_3_poly_pt_poly.json
│ │ ├── mix_3_poly_pt_poly.mlt
│ │ ├── mix_3_polyh_line_polyh.json
│ │ ├── mix_3_polyh_line_polyh.mlt
│ │ ├── mix_3_polyh_mline_mpoly.json
│ │ ├── mix_3_polyh_mline_mpoly.mlt
│ │ ├── mix_3_polyh_mline_polyh.json
│ │ ├── mix_3_polyh_mline_polyh.mlt
│ │ ├── mix_3_polyh_mpoly_polyh.json
│ │ ├── mix_3_polyh_mpoly_polyh.mlt
│ │ ├── mix_3_polyh_mpoly_polyh_tes.json
│ │ ├── mix_3_polyh_mpoly_polyh_tes.mlt
│ │ ├── mix_3_polyh_mpt_mline.json
│ │ ├── mix_3_polyh_mpt_mline.mlt
│ │ ├── mix_3_polyh_mpt_mpoly.json
│ │ ├── mix_3_polyh_mpt_mpoly.mlt
│ │ ├── mix_3_polyh_mpt_polyh.json
│ │ ├── mix_3_polyh_mpt_polyh.mlt
│ │ ├── mix_3_polyh_poly_polyh.json
│ │ ├── mix_3_polyh_poly_polyh.mlt
│ │ ├── mix_3_polyh_poly_polyh_tes.json
│ │ ├── mix_3_polyh_poly_polyh_tes.mlt
│ │ ├── mix_3_polyh_pt_polyh.json
│ │ ├── mix_3_polyh_pt_polyh.mlt
│ │ ├── mix_3_pt_line_mline.json
│ │ ├── mix_3_pt_line_mline.mlt
│ │ ├── mix_3_pt_line_mpoly.json
│ │ ├── mix_3_pt_line_mpoly.mlt
│ │ ├── mix_3_pt_line_mpt.json
│ │ ├── mix_3_pt_line_mpt.mlt
│ │ ├── mix_3_pt_line_poly.json
│ │ ├── mix_3_pt_line_poly.mlt
│ │ ├── mix_3_pt_line_polyh.json
│ │ ├── mix_3_pt_line_polyh.mlt
│ │ ├── mix_3_pt_line_pt.json
│ │ ├── mix_3_pt_line_pt.mlt
│ │ ├── mix_3_pt_mline_mpoly.json
│ │ ├── mix_3_pt_mline_mpoly.mlt
│ │ ├── mix_3_pt_mline_pt.json
│ │ ├── mix_3_pt_mline_pt.mlt
│ │ ├── mix_3_pt_mpoly_pt.json
│ │ ├── mix_3_pt_mpoly_pt.mlt
│ │ ├── mix_3_pt_mpt_mline.json
│ │ ├── mix_3_pt_mpt_mline.mlt
│ │ ├── mix_3_pt_mpt_mpoly.json
│ │ ├── mix_3_pt_mpt_mpoly.mlt
│ │ ├── mix_3_pt_mpt_pt.json
│ │ ├── mix_3_pt_mpt_pt.mlt
│ │ ├── mix_3_pt_poly_mline.json
│ │ ├── mix_3_pt_poly_mline.mlt
│ │ ├── mix_3_pt_poly_mpoly.json
│ │ ├── mix_3_pt_poly_mpoly.mlt
│ │ ├── mix_3_pt_poly_mpt.json
│ │ ├── mix_3_pt_poly_mpt.mlt
│ │ ├── mix_3_pt_poly_polyh.json
│ │ ├── mix_3_pt_poly_polyh.mlt
│ │ ├── mix_3_pt_poly_pt.json
│ │ ├── mix_3_pt_poly_pt.mlt
│ │ ├── mix_3_pt_polyh_mline.json
│ │ ├── mix_3_pt_polyh_mline.mlt
│ │ ├── mix_3_pt_polyh_mpoly.json
│ │ ├── mix_3_pt_polyh_mpoly.mlt
│ │ ├── mix_3_pt_polyh_mpt.json
│ │ ├── mix_3_pt_polyh_mpt.mlt
│ │ ├── mix_3_pt_polyh_pt.json
│ │ ├── mix_3_pt_polyh_pt.mlt
│ │ ├── mix_4_line_mpt_mline_mpoly.json
│ │ ├── mix_4_line_mpt_mline_mpoly.mlt
│ │ ├── mix_4_line_poly_mline_mpoly.json
│ │ ├── mix_4_line_poly_mline_mpoly.mlt
│ │ ├── mix_4_line_poly_mpt_mline.json
│ │ ├── mix_4_line_poly_mpt_mline.mlt
│ │ ├── mix_4_line_poly_mpt_mpoly.json
│ │ ├── mix_4_line_poly_mpt_mpoly.mlt
│ │ ├── mix_4_line_poly_polyh_mline.json
│ │ ├── mix_4_line_poly_polyh_mline.mlt
│ │ ├── mix_4_line_poly_polyh_mpoly.json
│ │ ├── mix_4_line_poly_polyh_mpoly.mlt
│ │ ├── mix_4_line_poly_polyh_mpt.json
│ │ ├── mix_4_line_poly_polyh_mpt.mlt
│ │ ├── mix_4_line_polyh_mline_mpoly.json
│ │ ├── mix_4_line_polyh_mline_mpoly.mlt
│ │ ├── mix_4_line_polyh_mpt_mline.json
│ │ ├── mix_4_line_polyh_mpt_mline.mlt
│ │ ├── mix_4_line_polyh_mpt_mpoly.json
│ │ ├── mix_4_line_polyh_mpt_mpoly.mlt
│ │ ├── mix_4_poly_mpt_mline_mpoly.json
│ │ ├── mix_4_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_4_poly_polyh_mline_mpoly.json
│ │ ├── mix_4_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_4_poly_polyh_mpt_mline.json
│ │ ├── mix_4_poly_polyh_mpt_mline.mlt
│ │ ├── mix_4_poly_polyh_mpt_mpoly.json
│ │ ├── mix_4_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_4_polyh_mpt_mline_mpoly.json
│ │ ├── mix_4_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_4_pt_line_mline_mpoly.json
│ │ ├── mix_4_pt_line_mline_mpoly.mlt
│ │ ├── mix_4_pt_line_mpt_mline.json
│ │ ├── mix_4_pt_line_mpt_mline.mlt
│ │ ├── mix_4_pt_line_mpt_mpoly.json
│ │ ├── mix_4_pt_line_mpt_mpoly.mlt
│ │ ├── mix_4_pt_line_poly_mline.json
│ │ ├── mix_4_pt_line_poly_mline.mlt
│ │ ├── mix_4_pt_line_poly_mpoly.json
│ │ ├── mix_4_pt_line_poly_mpoly.mlt
│ │ ├── mix_4_pt_line_poly_mpt.json
│ │ ├── mix_4_pt_line_poly_mpt.mlt
│ │ ├── mix_4_pt_line_poly_polyh.json
│ │ ├── mix_4_pt_line_poly_polyh.mlt
│ │ ├── mix_4_pt_line_polyh_mline.json
│ │ ├── mix_4_pt_line_polyh_mline.mlt
│ │ ├── mix_4_pt_line_polyh_mpoly.json
│ │ ├── mix_4_pt_line_polyh_mpoly.mlt
│ │ ├── mix_4_pt_line_polyh_mpt.json
│ │ ├── mix_4_pt_line_polyh_mpt.mlt
│ │ ├── mix_4_pt_mpt_mline_mpoly.json
│ │ ├── mix_4_pt_mpt_mline_mpoly.mlt
│ │ ├── mix_4_pt_poly_mline_mpoly.json
│ │ ├── mix_4_pt_poly_mline_mpoly.mlt
│ │ ├── mix_4_pt_poly_mpt_mline.json
│ │ ├── mix_4_pt_poly_mpt_mline.mlt
│ │ ├── mix_4_pt_poly_mpt_mpoly.json
│ │ ├── mix_4_pt_poly_mpt_mpoly.mlt
│ │ ├── mix_4_pt_poly_polyh_mline.json
│ │ ├── mix_4_pt_poly_polyh_mline.mlt
│ │ ├── mix_4_pt_poly_polyh_mpoly.json
│ │ ├── mix_4_pt_poly_polyh_mpoly.mlt
│ │ ├── mix_4_pt_poly_polyh_mpt.json
│ │ ├── mix_4_pt_poly_polyh_mpt.mlt
│ │ ├── mix_4_pt_polyh_mline_mpoly.json
│ │ ├── mix_4_pt_polyh_mline_mpoly.mlt
│ │ ├── mix_4_pt_polyh_mpt_mline.json
│ │ ├── mix_4_pt_polyh_mpt_mline.mlt
│ │ ├── mix_4_pt_polyh_mpt_mpoly.json
│ │ ├── mix_4_pt_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_line_poly_mpt_mline_mpoly.json
│ │ ├── mix_5_line_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_5_line_poly_polyh_mline_mpoly.json
│ │ ├── mix_5_line_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_5_line_poly_polyh_mpt_mline.json
│ │ ├── mix_5_line_poly_polyh_mpt_mline.mlt
│ │ ├── mix_5_line_poly_polyh_mpt_mpoly.json
│ │ ├── mix_5_line_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_line_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_line_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_5_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_line_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_mline_mpoly.json
│ │ ├── mix_5_pt_line_poly_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_mpt_mline.json
│ │ ├── mix_5_pt_line_poly_mpt_mline.mlt
│ │ ├── mix_5_pt_line_poly_mpt_mpoly.json
│ │ ├── mix_5_pt_line_poly_mpt_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mline.json
│ │ ├── mix_5_pt_line_poly_polyh_mline.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mpoly.json
│ │ ├── mix_5_pt_line_poly_polyh_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mpt.json
│ │ ├── mix_5_pt_line_poly_polyh_mpt.mlt
│ │ ├── mix_5_pt_line_polyh_mline_mpoly.json
│ │ ├── mix_5_pt_line_polyh_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_polyh_mpt_mline.json
│ │ ├── mix_5_pt_line_polyh_mpt_mline.mlt
│ │ ├── mix_5_pt_line_polyh_mpt_mpoly.json
│ │ ├── mix_5_pt_line_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_pt_poly_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_poly_polyh_mline_mpoly.json
│ │ ├── mix_5_pt_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_5_pt_poly_polyh_mpt_mline.json
│ │ ├── mix_5_pt_poly_polyh_mpt_mline.mlt
│ │ ├── mix_5_pt_poly_polyh_mpt_mpoly.json
│ │ ├── mix_5_pt_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_pt_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_line_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_line_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_line_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mline_mpoly.json
│ │ ├── mix_6_pt_line_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mline.json
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mline.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mpoly.json
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_6_pt_line_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_line_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_7_pt_line_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_7_pt_line_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── multiline.json
│ │ ├── multiline.mlt
│ │ ├── multiline_morton.json
│ │ ├── multiline_morton.mlt
│ │ ├── multipoint.json
│ │ ├── multipoint.mlt
│ │ ├── multipoint_morton.json
│ │ ├── multipoint_morton.mlt
│ │ ├── point.json
│ │ ├── point.mlt
│ │ ├── poly.json
│ │ ├── poly.mlt
│ │ ├── poly_collinear.json
│ │ ├── poly_collinear.mlt
│ │ ├── poly_collinear_fpf.json
│ │ ├── poly_collinear_fpf.mlt
│ │ ├── poly_collinear_fpf_tes.json
│ │ ├── poly_collinear_fpf_tes.mlt
│ │ ├── poly_collinear_tes.json
│ │ ├── poly_collinear_tes.mlt
│ │ ├── poly_fpf.json
│ │ ├── poly_fpf.mlt
│ │ ├── poly_fpf_tes.json
│ │ ├── poly_fpf_tes.mlt
│ │ ├── poly_hole.json
│ │ ├── poly_hole.mlt
│ │ ├── poly_hole_fpf.json
│ │ ├── poly_hole_fpf.mlt
│ │ ├── poly_hole_fpf_tes.json
│ │ ├── poly_hole_fpf_tes.mlt
│ │ ├── poly_hole_tes.json
│ │ ├── poly_hole_tes.mlt
│ │ ├── poly_hole_touching.json
│ │ ├── poly_hole_touching.mlt
│ │ ├── poly_hole_touching_fpf.json
│ │ ├── poly_hole_touching_fpf.mlt
│ │ ├── poly_hole_touching_fpf_tes.json
│ │ ├── poly_hole_touching_fpf_tes.mlt
│ │ ├── poly_hole_touching_tes.json
│ │ ├── poly_hole_touching_tes.mlt
│ │ ├── poly_morton_hole_morton.json
│ │ ├── poly_morton_hole_morton.mlt
│ │ ├── poly_morton_ring_morton.json
│ │ ├── poly_morton_ring_morton.mlt
│ │ ├── poly_morton_ring_no_morton.json
│ │ ├── poly_morton_ring_no_morton.mlt
│ │ ├── poly_multi.json
│ │ ├── poly_multi.mlt
│ │ ├── poly_multi_fpf.json
│ │ ├── poly_multi_fpf.mlt
│ │ ├── poly_multi_fpf_tes.json
│ │ ├── poly_multi_fpf_tes.mlt
│ │ ├── poly_multi_morton_hole_morton.json
│ │ ├── poly_multi_morton_hole_morton.mlt
│ │ ├── poly_multi_morton_ring_morton.json
│ │ ├── poly_multi_morton_ring_morton.mlt
│ │ ├── poly_multi_morton_ring_no_morton.json
│ │ ├── poly_multi_morton_ring_no_morton.mlt
│ │ ├── poly_multi_tes.json
│ │ ├── poly_multi_tes.mlt
│ │ ├── poly_self_intersect.json
│ │ ├── poly_self_intersect.mlt
│ │ ├── poly_self_intersect_fpf.json
│ │ ├── poly_self_intersect_fpf.mlt
│ │ ├── poly_self_intersect_fpf_tes.json
│ │ ├── poly_self_intersect_fpf_tes.mlt
│ │ ├── poly_self_intersect_tes.json
│ │ ├── poly_self_intersect_tes.mlt
│ │ ├── poly_tes.json
│ │ ├── poly_tes.mlt
│ │ ├── prop_bool.json
│ │ ├── prop_bool.mlt
│ │ ├── prop_bool_false.json
│ │ ├── prop_bool_false.mlt
│ │ ├── prop_bool_false_null.json
│ │ ├── prop_bool_false_null.mlt
│ │ ├── prop_bool_null_false.json
│ │ ├── prop_bool_null_false.mlt
│ │ ├── prop_bool_null_true.json
│ │ ├── prop_bool_null_true.mlt
│ │ ├── prop_bool_true_null.json
│ │ ├── prop_bool_true_null.mlt
│ │ ├── prop_empty_name.json
│ │ ├── prop_empty_name.mlt
│ │ ├── prop_f32.json
│ │ ├── prop_f32.mlt
│ │ ├── prop_f32_max.json
│ │ ├── prop_f32_max.mlt
│ │ ├── prop_f32_min_norm.json
│ │ ├── prop_f32_min_norm.mlt
│ │ ├── prop_f32_min_val.json
│ │ ├── prop_f32_min_val.mlt
│ │ ├── prop_f32_nan.json
│ │ ├── prop_f32_nan.mlt
│ │ ├── prop_f32_neg_inf.json
│ │ ├── prop_f32_neg_inf.mlt
│ │ ├── prop_f32_neg_zero.json
│ │ ├── prop_f32_neg_zero.mlt
│ │ ├── prop_f32_null_val.json
│ │ ├── prop_f32_null_val.mlt
│ │ ├── prop_f32_pos_inf.json
│ │ ├── prop_f32_pos_inf.mlt
│ │ ├── prop_f32_val_null.json
│ │ ├── prop_f32_val_null.mlt
│ │ ├── prop_f32_zero.json
│ │ ├── prop_f32_zero.mlt
│ │ ├── prop_f64.json
│ │ ├── prop_f64.mlt
│ │ ├── prop_f64_max.json
│ │ ├── prop_f64_max.mlt
│ │ ├── prop_f64_min_norm.json
│ │ ├── prop_f64_min_norm.mlt
│ │ ├── prop_f64_min_val.json
│ │ ├── prop_f64_min_val.mlt
│ │ ├── prop_f64_nan.json
│ │ ├── prop_f64_nan.mlt
│ │ ├── prop_f64_neg_inf.json
│ │ ├── prop_f64_neg_inf.mlt
│ │ ├── prop_f64_neg_zero.json
│ │ ├── prop_f64_neg_zero.mlt
│ │ ├── prop_f64_null_val.json
│ │ ├── prop_f64_null_val.mlt
│ │ ├── prop_f64_pos_inf.json
│ │ ├── prop_f64_pos_inf.mlt
│ │ ├── prop_f64_val_null.json
│ │ ├── prop_f64_val_null.mlt
│ │ ├── prop_f64_zero.json
│ │ ├── prop_f64_zero.mlt
│ │ ├── prop_i32.json
│ │ ├── prop_i32.mlt
│ │ ├── prop_i32_max.json
│ │ ├── prop_i32_max.mlt
│ │ ├── prop_i32_min.json
│ │ ├── prop_i32_min.mlt
│ │ ├── prop_i32_neg.json
│ │ ├── prop_i32_neg.mlt
│ │ ├── prop_i32_null_val.json
│ │ ├── prop_i32_null_val.mlt
│ │ ├── prop_i32_val_null.json
│ │ ├── prop_i32_val_null.mlt
│ │ ├── prop_i64.json
│ │ ├── prop_i64.mlt
│ │ ├── prop_i64_max.json
│ │ ├── prop_i64_max.mlt
│ │ ├── prop_i64_min.json
│ │ ├── prop_i64_min.mlt
│ │ ├── prop_i64_neg.json
│ │ ├── prop_i64_neg.mlt
│ │ ├── prop_i64_null_val.json
│ │ ├── prop_i64_null_val.mlt
│ │ ├── prop_i64_val_null.json
│ │ ├── prop_i64_val_null.mlt
│ │ ├── prop_special_name.json
│ │ ├── prop_special_name.mlt
│ │ ├── prop_str_ascii.json
│ │ ├── prop_str_ascii.mlt
│ │ ├── prop_str_empty.json
│ │ ├── prop_str_empty.mlt
│ │ ├── prop_str_empty_val.json
│ │ ├── prop_str_empty_val.mlt
│ │ ├── prop_str_escape.json
│ │ ├── prop_str_escape.mlt
│ │ ├── prop_str_null_val.json
│ │ ├── prop_str_null_val.mlt
│ │ ├── prop_str_special.json
│ │ ├── prop_str_special.mlt
│ │ ├── prop_str_unicode.json
│ │ ├── prop_str_unicode.mlt
│ │ ├── prop_str_val_empty.json
│ │ ├── prop_str_val_empty.mlt
│ │ ├── prop_str_val_null.json
│ │ ├── prop_str_val_null.mlt
│ │ ├── prop_u32.json
│ │ ├── prop_u32.mlt
│ │ ├── prop_u32_max.json
│ │ ├── prop_u32_max.mlt
│ │ ├── prop_u32_min.json
│ │ ├── prop_u32_min.mlt
│ │ ├── prop_u32_null_val.json
│ │ ├── prop_u32_null_val.mlt
│ │ ├── prop_u32_val_null.json
│ │ ├── prop_u32_val_null.mlt
│ │ ├── prop_u64.json
│ │ ├── prop_u64.mlt
│ │ ├── prop_u64_max.json
│ │ ├── prop_u64_max.mlt
│ │ ├── prop_u64_min.json
│ │ ├── prop_u64_min.mlt
│ │ ├── prop_u64_null_val.json
│ │ ├── prop_u64_null_val.mlt
│ │ ├── prop_u64_val_null.json
│ │ ├── prop_u64_val_null.mlt
│ │ ├── props_i32.json
│ │ ├── props_i32.mlt
│ │ ├── props_i32_delta.json
│ │ ├── props_i32_delta.mlt
│ │ ├── props_i32_delta_rle.json
│ │ ├── props_i32_delta_rle.mlt
│ │ ├── props_i32_rle.json
│ │ ├── props_i32_rle.mlt
│ │ ├── props_i64.json
│ │ ├── props_i64.mlt
│ │ ├── props_i64_delta.json
│ │ ├── props_i64_delta.mlt
│ │ ├── props_i64_delta_rle.json
│ │ ├── props_i64_delta_rle.mlt
│ │ ├── props_i64_rle.json
│ │ ├── props_i64_rle.mlt
│ │ ├── props_mixed.json
│ │ ├── props_mixed.mlt
│ │ ├── props_no_shared_dict.json
│ │ ├── props_no_shared_dict.mlt
│ │ ├── props_offset_str.json
│ │ ├── props_offset_str.mlt
│ │ ├── props_offset_str_fsst.json
│ │ ├── props_offset_str_fsst.mlt
│ │ ├── props_shared_dict.json
│ │ ├── props_shared_dict.mlt
│ │ ├── props_shared_dict_2_same_prefix.json
│ │ ├── props_shared_dict_2_same_prefix.mlt
│ │ ├── props_shared_dict_fsst.json
│ │ ├── props_shared_dict_fsst.mlt
│ │ ├── props_shared_dict_no_child_name.json
│ │ ├── props_shared_dict_no_child_name.mlt
│ │ ├── props_shared_dict_no_child_name_fsst.json
│ │ ├── props_shared_dict_no_child_name_fsst.mlt
│ │ ├── props_shared_dict_no_struct_name.json
│ │ ├── props_shared_dict_no_struct_name.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst.json
│ │ ├── props_shared_dict_no_struct_name_fsst.mlt
│ │ ├── props_shared_dict_one_child.json
│ │ ├── props_shared_dict_one_child.mlt
│ │ ├── props_shared_dict_one_child_fsst.json
│ │ ├── props_shared_dict_one_child_fsst.mlt
│ │ ├── props_str.json
│ │ ├── props_str.mlt
│ │ ├── props_str_fsst.json
│ │ ├── props_str_fsst.mlt
│ │ ├── props_u32.json
│ │ ├── props_u32.mlt
│ │ ├── props_u32_delta.json
│ │ ├── props_u32_delta.mlt
│ │ ├── props_u32_delta_rle.json
│ │ ├── props_u32_delta_rle.mlt
│ │ ├── props_u32_fpf_127.json
│ │ ├── props_u32_fpf_127.mlt
│ │ ├── props_u32_fpf_128.json
│ │ ├── props_u32_fpf_128.mlt
│ │ ├── props_u32_fpf_129.json
│ │ ├── props_u32_fpf_129.mlt
│ │ ├── props_u32_fpf_255.json
│ │ ├── props_u32_fpf_255.mlt
│ │ ├── props_u32_fpf_256.json
│ │ ├── props_u32_fpf_256.mlt
│ │ ├── props_u32_fpf_257.json
│ │ ├── props_u32_fpf_257.mlt
│ │ ├── props_u32_fpf_383.json
│ │ ├── props_u32_fpf_383.mlt
│ │ ├── props_u32_fpf_384.json
│ │ ├── props_u32_fpf_384.mlt
│ │ ├── props_u32_fpf_385.json
│ │ ├── props_u32_fpf_385.mlt
│ │ ├── props_u32_fpf_511.json
│ │ ├── props_u32_fpf_511.mlt
│ │ ├── props_u32_fpf_512.json
│ │ ├── props_u32_fpf_512.mlt
│ │ ├── props_u32_fpf_513.json
│ │ ├── props_u32_fpf_513.mlt
│ │ ├── props_u32_rle.json
│ │ ├── props_u32_rle.mlt
│ │ ├── props_u64.json
│ │ ├── props_u64.mlt
│ │ ├── props_u64_delta.json
│ │ ├── props_u64_delta.mlt
│ │ ├── props_u64_delta_rle.json
│ │ ├── props_u64_delta_rle.mlt
│ │ ├── props_u64_rle.json
│ │ └── props_u64_rle.mlt
│ ├── 0x01-rust/
│ │ ├── id64_max.json
│ │ ├── id64_max.mlt
│ │ ├── id_max.json
│ │ ├── id_max.mlt
│ │ ├── ids64_minmax.json
│ │ ├── ids64_minmax.mlt
│ │ ├── ids64_minmax_delta.json
│ │ ├── ids64_minmax_delta.mlt
│ │ ├── ids_delta_fpf.json
│ │ ├── ids_delta_fpf.mlt
│ │ ├── ids_fpf.json
│ │ ├── ids_fpf.mlt
│ │ ├── mix_2_poly_poly_tes_ns.json
│ │ ├── mix_2_poly_poly_tes_ns.mlt
│ │ ├── mix_2_poly_polyh_tes_ns.json
│ │ ├── mix_2_poly_polyh_tes_ns.mlt
│ │ ├── mix_2_polyh_polyh_tes_ns.json
│ │ ├── mix_2_polyh_polyh_tes_ns.mlt
│ │ ├── mix_3_poly_polyh_poly_tes_ns.json
│ │ ├── mix_3_poly_polyh_poly_tes_ns.mlt
│ │ ├── mix_3_polyh_poly_polyh_tes_ns.json
│ │ ├── mix_3_polyh_poly_polyh_tes_ns.mlt
│ │ ├── poly_collinear_fpf_tes_ns.json
│ │ ├── poly_collinear_fpf_tes_ns.mlt
│ │ ├── poly_collinear_tes_ns.json
│ │ ├── poly_collinear_tes_ns.mlt
│ │ ├── poly_fpf_tes_ns.json
│ │ ├── poly_fpf_tes_ns.mlt
│ │ ├── poly_hole_fpf_tes_ns.json
│ │ ├── poly_hole_fpf_tes_ns.mlt
│ │ ├── poly_hole_tes_ns.json
│ │ ├── poly_hole_tes_ns.mlt
│ │ ├── poly_hole_touching_fpf_tes_ns.json
│ │ ├── poly_hole_touching_fpf_tes_ns.mlt
│ │ ├── poly_hole_touching_tes_ns.json
│ │ ├── poly_hole_touching_tes_ns.mlt
│ │ ├── poly_self_intersect_fpf_tes_ns.json
│ │ ├── poly_self_intersect_fpf_tes_ns.mlt
│ │ ├── poly_self_intersect_tes_ns.json
│ │ ├── poly_self_intersect_tes_ns.mlt
│ │ ├── poly_tes_ns.json
│ │ ├── poly_tes_ns.mlt
│ │ ├── prop_bool_false_np.json
│ │ ├── prop_bool_false_np.mlt
│ │ ├── prop_bool_np.json
│ │ ├── prop_bool_np.mlt
│ │ ├── prop_empty_name_np.json
│ │ ├── prop_empty_name_np.mlt
│ │ ├── prop_f32_max_np.json
│ │ ├── prop_f32_max_np.mlt
│ │ ├── prop_f32_min_norm_np.json
│ │ ├── prop_f32_min_norm_np.mlt
│ │ ├── prop_f32_min_val_np.json
│ │ ├── prop_f32_min_val_np.mlt
│ │ ├── prop_f32_nan_np.json
│ │ ├── prop_f32_nan_np.mlt
│ │ ├── prop_f32_neg_inf_np.json
│ │ ├── prop_f32_neg_inf_np.mlt
│ │ ├── prop_f32_neg_zero_np.json
│ │ ├── prop_f32_neg_zero_np.mlt
│ │ ├── prop_f32_np.json
│ │ ├── prop_f32_np.mlt
│ │ ├── prop_f32_pos_inf_np.json
│ │ ├── prop_f32_pos_inf_np.mlt
│ │ ├── prop_f32_zero_np.json
│ │ ├── prop_f32_zero_np.mlt
│ │ ├── prop_f64_max_np.json
│ │ ├── prop_f64_max_np.mlt
│ │ ├── prop_f64_min_norm_np.json
│ │ ├── prop_f64_min_norm_np.mlt
│ │ ├── prop_f64_min_val_np.json
│ │ ├── prop_f64_min_val_np.mlt
│ │ ├── prop_f64_nan_np.json
│ │ ├── prop_f64_nan_np.mlt
│ │ ├── prop_f64_neg_inf_np.json
│ │ ├── prop_f64_neg_inf_np.mlt
│ │ ├── prop_f64_neg_zero_np.json
│ │ ├── prop_f64_neg_zero_np.mlt
│ │ ├── prop_f64_np.json
│ │ ├── prop_f64_np.mlt
│ │ ├── prop_f64_pos_inf_np.json
│ │ ├── prop_f64_pos_inf_np.mlt
│ │ ├── prop_f64_zero_np.json
│ │ ├── prop_f64_zero_np.mlt
│ │ ├── prop_i32_max_np.json
│ │ ├── prop_i32_max_np.mlt
│ │ ├── prop_i32_min_np.json
│ │ ├── prop_i32_min_np.mlt
│ │ ├── prop_i32_neg_np.json
│ │ ├── prop_i32_neg_np.mlt
│ │ ├── prop_i32_np.json
│ │ ├── prop_i32_np.mlt
│ │ ├── prop_i64_max_np.json
│ │ ├── prop_i64_max_np.mlt
│ │ ├── prop_i64_min_np.json
│ │ ├── prop_i64_min_np.mlt
│ │ ├── prop_i64_neg_np.json
│ │ ├── prop_i64_neg_np.mlt
│ │ ├── prop_i64_np.json
│ │ ├── prop_i64_np.mlt
│ │ ├── prop_special_name_np.json
│ │ ├── prop_special_name_np.mlt
│ │ ├── prop_str_ascii_np.json
│ │ ├── prop_str_ascii_np.mlt
│ │ ├── prop_str_empty_np.json
│ │ ├── prop_str_empty_np.mlt
│ │ ├── prop_str_escape_np.json
│ │ ├── prop_str_escape_np.mlt
│ │ ├── prop_str_special_np.json
│ │ ├── prop_str_special_np.mlt
│ │ ├── prop_str_unicode_np.json
│ │ ├── prop_str_unicode_np.mlt
│ │ ├── prop_u32_max_np.json
│ │ ├── prop_u32_max_np.mlt
│ │ ├── prop_u32_min_np.json
│ │ ├── prop_u32_min_np.mlt
│ │ ├── prop_u32_np.json
│ │ ├── prop_u32_np.mlt
│ │ ├── prop_u64_max_np.json
│ │ ├── prop_u64_max_np.mlt
│ │ ├── prop_u64_min_np.json
│ │ ├── prop_u64_min_np.mlt
│ │ ├── prop_u64_np.json
│ │ ├── prop_u64_np.mlt
│ │ ├── props_i32_delta_np.json
│ │ ├── props_i32_delta_np.mlt
│ │ ├── props_i32_delta_rle_np.json
│ │ ├── props_i32_delta_rle_np.mlt
│ │ ├── props_i32_np.json
│ │ ├── props_i32_np.mlt
│ │ ├── props_i32_rle_np.json
│ │ ├── props_i32_rle_np.mlt
│ │ ├── props_mixed_np.json
│ │ ├── props_mixed_np.mlt
│ │ ├── props_no_shared_dict_np.json
│ │ ├── props_no_shared_dict_np.mlt
│ │ ├── props_offset_str_fsst.json
│ │ ├── props_offset_str_fsst.mlt
│ │ ├── props_offset_str_fsst_np.json
│ │ ├── props_offset_str_fsst_np.mlt
│ │ ├── props_offset_str_np.json
│ │ ├── props_offset_str_np.mlt
│ │ ├── props_shared_dict_2_same_prefix_np.json
│ │ ├── props_shared_dict_2_same_prefix_np.mlt
│ │ ├── props_shared_dict_fsst.json
│ │ ├── props_shared_dict_fsst.mlt
│ │ ├── props_shared_dict_fsst_np.json
│ │ ├── props_shared_dict_fsst_np.mlt
│ │ ├── props_shared_dict_no_child_name_fsst.json
│ │ ├── props_shared_dict_no_child_name_fsst.mlt
│ │ ├── props_shared_dict_no_child_name_fsst_np.json
│ │ ├── props_shared_dict_no_child_name_fsst_np.mlt
│ │ ├── props_shared_dict_no_child_name_np.json
│ │ ├── props_shared_dict_no_child_name_np.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst.json
│ │ ├── props_shared_dict_no_struct_name_fsst.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst_np.json
│ │ ├── props_shared_dict_no_struct_name_fsst_np.mlt
│ │ ├── props_shared_dict_no_struct_name_np.json
│ │ ├── props_shared_dict_no_struct_name_np.mlt
│ │ ├── props_shared_dict_np.json
│ │ ├── props_shared_dict_np.mlt
│ │ ├── props_shared_dict_one_child_fsst.json
│ │ ├── props_shared_dict_one_child_fsst.mlt
│ │ ├── props_shared_dict_one_child_fsst_np.json
│ │ ├── props_shared_dict_one_child_fsst_np.mlt
│ │ ├── props_shared_dict_one_child_np.json
│ │ ├── props_shared_dict_one_child_np.mlt
│ │ ├── props_shared_dict_presence_variants.json
│ │ ├── props_shared_dict_presence_variants.mlt
│ │ ├── props_shared_dict_presence_variants_np.json
│ │ ├── props_shared_dict_presence_variants_np.mlt
│ │ ├── props_str_fsst.json
│ │ ├── props_str_fsst.mlt
│ │ ├── props_str_fsst_np.json
│ │ ├── props_str_fsst_np.mlt
│ │ ├── props_str_np.json
│ │ ├── props_str_np.mlt
│ │ ├── props_u32_delta_np.json
│ │ ├── props_u32_delta_np.mlt
│ │ ├── props_u32_delta_rle_np.json
│ │ ├── props_u32_delta_rle_np.mlt
│ │ ├── props_u32_fpf_127_np.json
│ │ ├── props_u32_fpf_127_np.mlt
│ │ ├── props_u32_fpf_128_np.json
│ │ ├── props_u32_fpf_128_np.mlt
│ │ ├── props_u32_fpf_129_np.json
│ │ ├── props_u32_fpf_129_np.mlt
│ │ ├── props_u32_fpf_255_np.json
│ │ ├── props_u32_fpf_255_np.mlt
│ │ ├── props_u32_fpf_256_np.json
│ │ ├── props_u32_fpf_256_np.mlt
│ │ ├── props_u32_fpf_257_np.json
│ │ ├── props_u32_fpf_257_np.mlt
│ │ ├── props_u32_fpf_383_np.json
│ │ ├── props_u32_fpf_383_np.mlt
│ │ ├── props_u32_fpf_384_np.json
│ │ ├── props_u32_fpf_384_np.mlt
│ │ ├── props_u32_fpf_385_np.json
│ │ ├── props_u32_fpf_385_np.mlt
│ │ ├── props_u32_fpf_511_np.json
│ │ ├── props_u32_fpf_511_np.mlt
│ │ ├── props_u32_fpf_512_np.json
│ │ ├── props_u32_fpf_512_np.mlt
│ │ ├── props_u32_fpf_513_np.json
│ │ ├── props_u32_fpf_513_np.mlt
│ │ ├── props_u32_np.json
│ │ ├── props_u32_np.mlt
│ │ ├── props_u32_rle_np.json
│ │ ├── props_u32_rle_np.mlt
│ │ ├── props_u64_delta_np.json
│ │ ├── props_u64_delta_np.mlt
│ │ ├── props_u64_delta_rle_np.json
│ │ ├── props_u64_delta_rle_np.mlt
│ │ ├── props_u64_np.json
│ │ ├── props_u64_np.mlt
│ │ ├── props_u64_rle_np.json
│ │ └── props_u64_rle_np.mlt
│ ├── java.txt
│ ├── rust.txt
│ └── synthetic-test-utils/
│ ├── index.ts
│ └── package.json
└── ts/
├── .gitignore
├── .nvmrc
├── README.md
├── RELEASE.md
├── biome.json
├── buf.gen.yaml
├── eslint.config.mjs
├── mod.just
├── package.json
├── src/
│ ├── decoding/
│ │ ├── bigEndianDecode.spec.ts
│ │ ├── bigEndianDecode.ts
│ │ ├── decodingTestUtils.ts
│ │ ├── decodingUtils.spec.ts
│ │ ├── decodingUtils.ts
│ │ ├── fastPforCrossLanguage.spec.ts
│ │ ├── fastPforDecoder.spec.ts
│ │ ├── fastPforDecoder.ts
│ │ ├── fastPforShared.spec.ts
│ │ ├── fastPforShared.ts
│ │ ├── fastPforUnpack.spec.ts
│ │ ├── fastPforUnpack.ts
│ │ ├── fsstDecoder.spec.ts
│ │ ├── fsstDecoder.ts
│ │ ├── geometryDecoder.ts
│ │ ├── geometryScaling.ts
│ │ ├── intWrapper.ts
│ │ ├── integerDecodingUtils.spec.ts
│ │ ├── integerDecodingUtils.ts
│ │ ├── integerStreamDecoder.spec.ts
│ │ ├── integerStreamDecoder.ts
│ │ ├── propertyDecoder.spec.ts
│ │ ├── propertyDecoder.ts
│ │ ├── stringDecoder.spec.ts
│ │ ├── stringDecoder.ts
│ │ ├── unpackNullableUtils.spec.ts
│ │ └── unpackNullableUtils.ts
│ ├── encoding/
│ │ ├── bigEndianEncode.ts
│ │ ├── constGeometryVectorEncoder.ts
│ │ ├── embeddedTilesetMetadataEncoder.ts
│ │ ├── encodingUtils.ts
│ │ ├── fastPforEncoder.spec.ts
│ │ ├── fastPforEncoder.ts
│ │ ├── fsstEncoder.ts
│ │ ├── integerEncodingUtils.ts
│ │ ├── integerStreamEncoder.ts
│ │ ├── packNullableUtils.ts
│ │ ├── propertyEncoder.ts
│ │ ├── stringEncoder.ts
│ │ └── zOrderCurveEncoder.ts
│ ├── index.ts
│ ├── metadata/
│ │ ├── tile/
│ │ │ ├── dictionaryType.ts
│ │ │ ├── lengthType.ts
│ │ │ ├── logicalLevelTechnique.ts
│ │ │ ├── logicalStreamType.ts
│ │ │ ├── offsetType.ts
│ │ │ ├── physicalLevelTechnique.ts
│ │ │ ├── physicalStreamType.ts
│ │ │ ├── scalarType.ts
│ │ │ └── streamMetadataDecoder.ts
│ │ └── tileset/
│ │ ├── embeddedTilesetMetadataDecoder.spec.ts
│ │ ├── embeddedTilesetMetadataDecoder.ts
│ │ ├── tilesetMetadata.ts
│ │ ├── typeMap.spec.ts
│ │ └── typeMap.ts
│ ├── mltDecoder.spec.ts
│ ├── mltDecoder.ts
│ ├── mltMetadata.ts
│ ├── synthetic.spec.ts
│ └── vector/
│ ├── constant/
│ │ ├── int32ConstVector.ts
│ │ └── int64ConstVector.ts
│ ├── dictionary/
│ │ └── stringDictionaryVector.ts
│ ├── featureTable.ts
│ ├── filter/
│ │ ├── flatSelectionVector.spec.ts
│ │ ├── flatSelectionVector.ts
│ │ ├── selectionVector.ts
│ │ ├── selectionVectorUtil.spec.ts
│ │ ├── selectionVectorUtils.ts
│ │ ├── sequenceSelectionVector.spec.ts
│ │ └── sequenceSelectionVector.ts
│ ├── fixedSizeVector.ts
│ ├── flat/
│ │ ├── bitVector.ts
│ │ ├── booleanFlatVector.ts
│ │ ├── doubleFlatVector.ts
│ │ ├── floatFlatVector.spec.ts
│ │ ├── floatFlatVector.ts
│ │ ├── int32FlatVector.spec.ts
│ │ ├── int32FlatVector.ts
│ │ ├── int64FlatVector.spec.ts
│ │ ├── int64FlatVector.ts
│ │ └── stringFlatVector.ts
│ ├── fsst-dictionary/
│ │ ├── stringFsstDictionaryVector.spec.ts
│ │ └── stringFsstDictionaryVector.ts
│ ├── geometry/
│ │ ├── constGeometryVector.ts
│ │ ├── constGpuVector.ts
│ │ ├── flatGeometryVector.ts
│ │ ├── flatGpuVector.ts
│ │ ├── geometryType.ts
│ │ ├── geometryVector.ts
│ │ ├── geometryVectorConverter.spec.ts
│ │ ├── geometryVectorConverter.ts
│ │ ├── gpuVector.ts
│ │ ├── topologyVector.ts
│ │ ├── vertexBufferType.ts
│ │ ├── zOrderCurve.spec.ts
│ │ └── zOrderCurve.ts
│ ├── idVector.ts
│ ├── sequence/
│ │ ├── int32SequenceVector.ts
│ │ ├── int64SequenceVector.spec.ts
│ │ ├── int64SequenceVector.ts
│ │ └── sequenceVector.ts
│ ├── variableSizeVector.ts
│ ├── vector.ts
│ └── vectorType.ts
├── tsconfig.json
└── tsconfig.lint.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
BasedOnStyle: Google
AccessModifierOffset: -4
AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Inline
AllowShortLambdasOnASingleLine: Inline
BinPackArguments: false
BinPackParameters: false
ColumnLimit: 120
IncludeBlocks: Preserve
IndentWidth: 4
PackConstructorInitializers: Never
PenaltyBreakAssignment: 80
SortIncludes: false
SpacesBeforeTrailingComments: 1
Standard: c++20
---
Language: Cpp
---
Language: ObjC
BasedOnStyle: Google
ObjCSpaceAfterProperty: true
...
================================================
FILE: .cursor/rules/karpathy-guidelines.mdc
================================================
---
description:
alwaysApply: true
---
# Karpathy behavioral guidelines
Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
## 1. Think Before Coding
**Don't assume. Don't hide confusion. Surface tradeoffs.**
Before implementing:
- State your assumptions explicitly. If uncertain, ask.
- If multiple interpretations exist, present them - don't pick silently.
- If a simpler approach exists, say so. Push back when warranted.
- If something is unclear, stop. Name what's confusing. Ask.
## 2. Simplicity First
**Minimum code that solves the problem. Nothing speculative.**
- No features beyond what was asked.
- No abstractions for single-use code.
- No "flexibility" or "configurability" that wasn't requested.
- No error handling for impossible scenarios.
- If you write 200 lines and it could be 50, rewrite it.
Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
## 3. Surgical Changes
**Touch only what you must. Clean up only your own mess.**
When editing existing code:
- Don't "improve" adjacent code, comments, or formatting.
- Don't refactor things that aren't broken.
- Match existing style, even if you'd do it differently.
- If you notice unrelated dead code, mention it - don't delete it.
When your changes create orphans:
- Remove imports/variables/functions that YOUR changes made unused.
- Don't remove pre-existing dead code unless asked.
The test: Every changed line should trace directly to the user's request.
## 4. Goal-Driven Execution
**Define success criteria. Loop until verified.**
Transform tasks into verifiable goals:
- "Add validation" → "Write tests for invalid inputs, then make them pass"
- "Fix the bug" → "Write a test that reproduces it, then make it pass"
- "Refactor X" → "Ensure tests pass before and after"
For multi-step tasks, state a brief plan:
```
1. [Step] → verify: [check]
2. [Step] → verify: [check]
3. [Step] → verify: [check]
```
Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
---
**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
================================================
FILE: .gitattributes
================================================
* text=auto eol=lf
================================================
FILE: .github/FUNDING.yml
================================================
github: [maplibre]
open_collective: maplibre
================================================
FILE: .github/actions/mlt-setup-java/action.yml
================================================
name: mlt-setup-java
description: Setup Java requirements
inputs: {}
runs:
using: "composite"
steps:
- name: Setup Java
uses: actions/setup-java@v5
with:
distribution: 'temurin'
java-version: '21'
- name: Setup Java Gradle
uses: gradle/actions/setup-gradle@v5
================================================
FILE: .github/actions/mlt-setup-node/action.yml
================================================
name: mlt-setup-node
description: Setup Node-JS requirements
inputs: {}
runs:
using: "composite"
steps:
- name: Setup Node.js
uses: actions/setup-node@v5
with:
node-version-file: 'ts/.nvmrc'
cache: 'npm'
cache-dependency-path: 'ts/package-lock.json'
registry-url: 'https://registry.npmjs.org'
================================================
FILE: .github/actions/mlt-setup-rust/action.yml
================================================
name: mlt-setup-rust
description: Setup Rust requirements
inputs:
toolchain:
description: 'Rust toolchain to install: stable (default), nightly, or msrv'
required: false
default: 'stable'
runs:
using: "composite"
steps:
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall,cargo-hack,fd-find,cargo-insta,cargo-sort,git-delta' }
# Install the requested toolchain (stable, nightly, or msrv)
- if: ${{ inputs.toolchain == 'stable' }}
name: Install Rust stable
uses: dtolnay/rust-toolchain@stable
- if: ${{ inputs.toolchain == 'nightly' }}
name: Install Rust nightly
uses: dtolnay/rust-toolchain@nightly
- if: ${{ inputs.toolchain == 'msrv' }}
name: Read MSRV
id: msrv
shell: bash
run: echo "value=$(just rust::get-msrv)" >> $GITHUB_OUTPUT
- if: ${{ inputs.toolchain == 'msrv' }}
name: Install Rust MSRV ${{ steps.msrv.outputs.value }}
uses: dtolnay/rust-toolchain@stable
with:
toolchain: ${{ steps.msrv.outputs.value }}
- name: Cache Cargo registry and build artifacts
if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
uses: Swatinem/rust-cache@v2
with: { workspaces: rust }
================================================
FILE: .github/dependabot.yml
================================================
# To get started with Dependabot version updates, you'll need to specify which
# package ecosystems to update and where the package manifests are located.
# Please see the documentation for all configuration options:
# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
#
# Config file spec:
# https://docs.github.com/en/enterprise-cloud@latest/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem
version: 2
updates:
# Maintain dependencies for GitHub Actions
- package-ecosystem: github-actions
directory: "/"
schedule:
interval: weekly
groups:
all-actions-version-updates:
applies-to: version-updates
patterns:
- "*"
all-actions-security-updates:
applies-to: security-updates
patterns:
- "*"
- package-ecosystem: gradle # should this be "maven" or "gradle"?
directory: "/java"
schedule:
interval: daily
time: "02:00"
groups:
all-gradle-version-updates:
applies-to: version-updates
patterns:
- "*"
all-gradle-security-updates:
applies-to: security-updates
patterns:
- "*"
- package-ecosystem: "npm"
directory: "/ts"
schedule:
interval: daily
versioning-strategy: increase
groups:
all-npm-version-updates:
applies-to: version-updates
patterns:
- "*"
all-npm-security-updates:
applies-to: security-updates
patterns:
- "*"
# Update Rust dependencies
- package-ecosystem: cargo
directory: "/rust"
schedule:
interval: daily
time: "02:00"
open-pull-requests-limit: 10
groups:
all-cargo-version-updates:
applies-to: version-updates
patterns:
- "*"
all-cargo-security-updates:
applies-to: security-updates
patterns:
- "*"
================================================
FILE: .github/workflows/autofix.yml
================================================
name: autofix.ci # See https://autofix.ci/security why this name
on:
pull_request:
types: [labeled, opened, synchronize, reopened]
workflow_dispatch:
permissions: {}
jobs:
rust-fmt-toml:
name: Format Cargo.toml
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'opened' ||
github.event.action == 'synchronize' ||
github.event.action == 'reopened'
steps:
- name: Checkout sources
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- uses: taiki-e/install-action@763e3324d4fd026c9bd284c504378585777a87d5 # v2.62.57
with: { tool: 'just,cargo-sort' }
- name: Format Cargo.toml
run: just rust::fmt-toml
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a # v1.3.4
with: { commit-message: "chore: sort Cargo.toml" }
rust-sync-versions:
name: Sync Rust-provided bindings version indicators
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'opened' ||
github.event.action == 'synchronize' ||
github.event.action == 'reopened'
steps:
- name: Checkout sources
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- name: Setup Rust
run: rustup update stable && rustup default stable
- uses: taiki-e/install-action@763e3324d4fd026c9bd284c504378585777a87d5 # v2.62.57
with: { tool: 'just' }
- run: sudo apt update && sudo apt install -y jq
- name: Sync package.json version from Cargo.toml
working-directory: rust
run: just rust::sync-wasm-version
- name: Sync pyproject.toml version from Cargo.toml
working-directory: rust
run: just rust::sync-pyo3-version
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a # v1.3.4
with: {commit-message: "chore: sync secondary version indicators"}
rust-gen-pyo3-stubs:
name: Regenerate maplibre_tiles.pyi stub
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'opened' ||
github.event.action == 'synchronize' ||
github.event.action == 'reopened'
steps:
- uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- uses: taiki-e/install-action@v2
with: { tool: 'just' }
- uses: ./.github/actions/mlt-setup-rust
- name: Regenerate stub
run: just rust::sync-pyo3-stubs
# run pre-commit as a formatting tiebreaker
- name: Install uv
uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7.1.6
- run: uvx pre-commit run --all-files
continue-on-error: true
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a
with: {commit-message: "chore: regenerate maplibre_tiles.pyi stub"}
bless:
name: Bless test output
runs-on: ubuntu-latest
permissions:
contents: read
if: |
github.event.action == 'labeled' &&
github.event.label.name == 'bless'
steps:
- name: Checkout sources
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with: { persist-credentials: false }
- uses: BRAINSia/free-disk-space@7048ffbf50819342ac964ef3998a51c2564a8a75 # v2.1.3
with:
tool-cache: false
mandb: false
android: true
dotnet: true
haskell: true
large-packages: false
docker-images: false
swap-storage: true
- name: Setup Rust
run: rustup update stable && rustup default stable
- name: Install just
uses: taiki-e/install-action@cc33365ec7e3350bc47bf935f247582cc6f68344 # v2.65.12
with:
tool: just,cargo-binstall
- name: Setup Node.js
uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
- run: just bless
continue-on-error: true
# run pre-commit as a formatting tiebreaker
- name: Install uv
uses: astral-sh/setup-uv@681c641aba71e4a1c380be3ab5e12ad51f415867 # v7.1.6
- run: uvx pre-commit run --all-files
continue-on-error: true
- uses: autofix-ci/action@c5b2d67aa2274e7b5a18224e8171550871fc7e4a # v1.3.4
with: {commit-message: "chore: update blessed test snapshots across all components"}
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on:
pull_request:
push:
branches: [main]
workflow_dispatch:
jobs:
changes:
runs-on: ubuntu-latest
outputs:
rust: ${{ steps.filter.outputs.rust }}
java: ${{ steps.filter.outputs.java }}
ts: ${{ steps.filter.outputs.ts }}
cpp: ${{ steps.filter.outputs.cpp }}
steps:
- uses: actions/checkout@v6.0.2
- uses: dorny/paths-filter@v4
id: filter
with:
filters: |
rust:
- 'justfile'
- 'rust/mod.just'
- '.github/**'
- 'rust/**'
- 'test/**'
java:
- 'justfile'
- 'java/mod.just'
- '.github/**'
- 'java/**'
- 'test/**'
ts:
- 'justfile'
- 'ts/mod.just'
- '.github/**'
- 'ts/**'
- 'test/**'
cpp:
- 'justfile'
- 'cpp/mod.just'
- '.github/**'
- 'cpp/**'
- 'test/**'
rust:
needs: changes
if: needs.changes.outputs.rust == 'true'
uses: ./.github/workflows/rust.yml
with:
run-release: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
secrets: inherit
permissions:
contents: write
id-token: write
java:
needs: changes
if: needs.changes.outputs.java == 'true'
uses: ./.github/workflows/java.yml
permissions:
id-token: write
contents: read
ts:
needs: changes
if: needs.changes.outputs.ts == 'true'
uses: ./.github/workflows/ts.yml
permissions:
contents: read
cpp:
needs: changes
if: needs.changes.outputs.cpp == 'true'
uses: ./.github/workflows/cpp.yml
permissions:
id-token: write
contents: read
docs:
uses: ./.github/workflows/gh-pages.yml
permissions:
contents: write
ci-passed:
needs: [rust, java, ts, cpp, docs]
if: always()
runs-on: ubuntu-latest
steps:
- run: echo "${{ toJSON(needs) }}"
- if: contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled')
run: exit 1
================================================
FILE: .github/workflows/cpp.yml
================================================
name: C++ CI
on:
workflow_call:
workflow_dispatch:
jobs:
cpp-build:
permissions:
id-token: write # for OIDC Codecov
strategy:
matrix:
os: [macos-15, ubuntu-24.04]
runs-on: ${{ matrix.os }}
steps:
- name: Checkout repository
uses: actions/checkout@v6.0.2
with:
submodules: recursive
fetch-depth: 1
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version-file: 'cpp/.nvmrc'
- name: install gcovr (macOS)
if: runner.os == 'macOS'
run: brew install gcovr
- name: install gcovr (Linux)
if: runner.os == 'Linux'
run: pip3 install gcovr
- name: Build, test and generate coverage report
run: just -v cpp::coverage
- name: Upload coverage to Codecov
if: github.repository_owner == 'maplibre'
uses: codecov/codecov-action@v6
with:
use_oidc: true
fail_ci_if_error: true
disable_file_fixes: true
disable_search: true
files: cpp/build/coverage.xml
- name: Sanity test for mlt-cpp-json tool
run: just -v cpp::test-json
- name: Build with Bazel
run: just -v cpp::bazel-build
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/dependabot.yml
================================================
name: Dependabot auto-merge
on: pull_request
permissions: write-all
jobs:
dependabot:
runs-on: ubuntu-latest
if: github.actor == 'dependabot[bot]'
steps:
- name: Dependabot metadata
id: metadata
uses: dependabot/fetch-metadata@v3
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
- name: Approve Dependabot PRs
if: steps.metadata.outputs.update-type == 'version-update:semver-patch'
run: gh pr review --approve "$PR_URL"
env:
PR_URL: ${{ github.event.pull_request.html_url }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: Enable auto-merge for Dependabot PRs
if: steps.metadata.outputs.update-type == 'version-update:semver-patch'
run: gh pr merge --auto --squash "$PR_URL"
env:
PR_URL: ${{ github.event.pull_request.html_url }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
================================================
FILE: .github/workflows/gh-pages.yml
================================================
name: Publish docs
on:
workflow_call:
workflow_dispatch:
jobs:
gh-pages:
runs-on: ubuntu-latest
steps:
- name: Checkout 🛎️
uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v4
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Build MLT documentation
run: just -v docs-build
- name: Deploy 🚀
if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' && github.repository_owner == 'maplibre'
uses: JamesIves/github-pages-deploy-action@d92aa235d04922e8f08b40ce78cc5442fcfbfa2f # v4.8.0
with: { branch: gh-pages, folder: site }
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/hotpath-comment.yml
================================================
name: Rust Hotpath Comment
on:
workflow_run:
workflows: ["Rust Hotpath Profile"]
types:
- completed
permissions:
contents: read
pull-requests: write
jobs:
comment:
runs-on: ubuntu-latest
if: ${{ github.event.workflow_run.conclusion == 'success' }}
steps:
- uses: actions/checkout@v6.0.2
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- uses: actions/download-artifact@v8
with:
name: profile-metrics
path: /tmp/metrics/
github-token: ${{ secrets.GITHUB_TOKEN }}
run-id: ${{ github.event.workflow_run.id }}
- name: Install hotpath-utils CLI
run: cargo install hotpath --bin hotpath-utils --features=utils
- name: Post PR comment
env:
GH_TOKEN: ${{ github.token }}
run: |
set -euo pipefail
GITHUB_BASE_REF=$(cat /tmp/metrics/base_ref.txt)
export GITHUB_BASE_REF
GITHUB_HEAD_REF=$(cat /tmp/metrics/head_ref.txt)
export GITHUB_HEAD_REF
hotpath-utils profile-pr \
--head-metrics /tmp/metrics/head_timing.json \
--base-metrics /tmp/metrics/base_timing.json \
--github-token "$GH_TOKEN" \
--pr-number "$(cat /tmp/metrics/pr_number.txt)" \
--benchmark-id "mlt-convert"
================================================
FILE: .github/workflows/hotpath-profile.yml
================================================
name: Rust Hotpath Profile
on:
pull_request:
paths:
- "rust/**"
permissions:
contents: read
jobs:
profile:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
with:
fetch-depth: 0
- uses: ./.github/actions/mlt-setup-rust
- name: Create metrics directory
run: mkdir -p /tmp/metrics
# ── Download benchmark tiles (cached) ──────────────────────────────
# 95 fixture tiles are too few for stable hotpath numbers.
# See `just rust::download-benchmark-tiles` for details.
- name: Cache benchmark tiles
id: cache-tiles
uses: actions/cache@v5
with:
path: /tmp/benchmark-tiles
key: hotpath-tiles-protomaps-z6-v1
- name: Download benchmark tiles
if: steps.cache-tiles.outputs.cache-hit != 'true'
env:
GITHUB_TOKEN: ${{ github.token }}
run: just rust::download-benchmark-tiles
- name: Head benchmark (timing + alloc)
working-directory: rust
env:
HOTPATH_OUTPUT_FORMAT: json
HOTPATH_OUTPUT_PATH: /tmp/metrics/head_timing.json
run: |
cargo run --release -p mlt --features='__hotpath,__hotpath-alloc' -- \
convert /tmp/benchmark-tiles/ /tmp/mlt-head-out/
- name: Checkout base
run: git checkout ${{ github.event.pull_request.base.sha }}
- name: Base benchmark (timing + alloc)
working-directory: rust
env:
HOTPATH_OUTPUT_FORMAT: json
HOTPATH_OUTPUT_PATH: /tmp/metrics/base_timing.json
run: |
cargo run --release -p mlt --features='__hotpath,__hotpath-alloc' -- \
convert /tmp/benchmark-tiles/ /tmp/mlt-base-out/
- name: Save PR metadata
env:
PR_NUMBER: ${{ github.event.pull_request.number }}
BASE_REF: ${{ github.base_ref }}
HEAD_REF: ${{ github.head_ref }}
run: |
echo "$PR_NUMBER" > /tmp/metrics/pr_number.txt
echo "$BASE_REF" > /tmp/metrics/base_ref.txt
echo "$HEAD_REF" > /tmp/metrics/head_ref.txt
- uses: actions/upload-artifact@v7
with:
name: profile-metrics
path: /tmp/metrics/
retention-days: 1
================================================
FILE: .github/workflows/java-release.yml
================================================
name: Java - Release
on:
push:
tags:
- 'java-v*.*.*'
workflow_dispatch:
jobs:
release:
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- name: Checkout code
uses: actions/checkout@v6.0.2
- name: Set up JDK
uses: actions/setup-java@v5
with:
java-version: '21'
distribution: 'temurin'
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Get version from tag
id: get_version
run: |
version="$(just ci-extract-version java ${{ github.ref_name }})"
echo version="$version" >> "$GITHUB_ENV"
- name: Make gradlew executable
run: chmod +x ./java/gradlew
- name: Publish to Maven Central
working-directory: java
run: ./gradlew publishToMavenCentral -Pversion=${{ env.version }}
env:
ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.SIGNING_PRIVATE_KEY }}
ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
- name: Build CLI tool
working-directory: java
run: ./gradlew cli
- run: just -v assert-git-is-clean
- name: Rename CLI artifacts
run: |
cp java/mlt-cli/build/libs/encode.jar mlt-encode.jar
cp java/mlt-cli/build/libs/decode.jar mlt-decode.jar
- name: Add CLI artifacts to GitHub release
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: java-v${{ env.version }}
fail_on_unmatched_files: true
name: java-v${{ env.version }}
files: |
mlt-encode.jar
mlt-decode.jar
================================================
FILE: .github/workflows/java.yml
================================================
name: Java CI
on:
workflow_call:
workflow_dispatch:
defaults:
run:
shell: bash
jobs:
test-java:
permissions:
id-token: write # for OIDC Codecov
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- uses: ./.github/actions/mlt-setup-java
- run: just -v java::env-info
- if: matrix.os == 'ubuntu-latest'
name: Lint Java code. If fails, run `just java::fmt` to reformat, and `just java::lint` to see issues locally
run: just -v java::lint
- run: just -v java::test-coverage
- run: just -v java::test-cli
- name: Test Maven local publishing
run: just -v java::test-publish
- run: npm ci
working-directory: java/encoding-server
- run: npm run lint
working-directory: java/encoding-server
- run: just -v assert-git-is-clean
- name: Upload coverage to Codecov
if: github.repository_owner == 'maplibre'
uses: codecov/codecov-action@v6
with:
use_oidc: true
directory: java
- name: Test synthetic MLT generation
run: just -v java::ci-check-synthetic-mlts
================================================
FILE: .github/workflows/python-release.yml
================================================
# This file is autogenerated by maturin v1.12.4
# To update, run the following command, but make sure to keep the adjustments that we did.
# maturin generate-ci github
name: Python Release
on:
push:
branches:
- main
tags:
- 'python-mlt-v*'
pull_request:
paths:
- 'justfile'
- 'rust/mod.just'
- '.github/**'
- 'rust/**'
- 'test/**'
workflow_dispatch:
permissions:
contents: read
jobs:
linux:
runs-on: ${{ matrix.platform.runner }}
strategy:
fail-fast: false
matrix:
platform:
- runner: ubuntu-22.04
target: x86_64
# FIXME: FSST does not seem to support 32bit targets
#- runner: ubuntu-22.04
# target: x86
# FIXME: Python::initialize not avaliable for linking
#- runner: ubuntu-22.04
# target: aarch64
# FIXME: error: unknown type name '__m128i' and related
#- runner: ubuntu-22.04
# target: armv7
# FIXME: cpp standard mismatch
#- runner: ubuntu-22.04
# target: s390x
# FIXME: error: unknown type name '__m128i' and related
#- runner: ubuntu-22.04
# target: ppc64le
steps:
- uses: actions/checkout@v6
- uses: ./.github/actions/mlt-setup-rust
- uses: actions/setup-python@v6
with: { python-version: '3.x' }
- name: Build wheels
uses: PyO3/maturin-action@v1
with:
target: ${{ matrix.platform.target }}
args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
sccache: false
manylinux: auto
- name: Upload wheels
uses: actions/upload-artifact@v7
with:
name: wheels-linux-${{ matrix.platform.target }}
path: dist
# FIXME: our --bin bins/stub-gen requires pyo3::Python::initialize, but unsure how to do that on musllinux. We don't need it for the library!
#musllinux:
# runs-on: ${{ matrix.platform.runner }}
# strategy:
# fail-fast: false
# matrix:
# platform:
# - runner: ubuntu-22.04
# target: x86_64
# - runner: ubuntu-22.04
# target: x86
# - runner: ubuntu-22.04
# target: aarch64
# - runner: ubuntu-22.04
# # FIXME: FSST does not seem to support 32bit targets
# #- runner: ubuntu-22.04
# # target: x86
# # FIXME: Python::initialize not avaliable for linking
# #- runner: ubuntu-22.04
# # target: aarch64
# # FIXME: error: unknown type name '__m128i' and related
# #- runner: ubuntu-22.04
# # target: armv7
# steps:
# - uses: actions/checkout@v6
# - uses: ./.github/actions/mlt-setup-rust
# - uses: actions/setup-python@v6
# with: { python-version: '3.x' }
# - name: Build wheels
# uses: PyO3/maturin-action@v1
# with:
# target: ${{ matrix.platform.target }}
# args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
# sccache: false
# manylinux: musllinux_1_2
# - name: Upload wheels
# uses: actions/upload-artifact@v7
# with:
# name: wheels-musllinux-${{ matrix.platform.target }}
# path: dist
# FIXME: Failed to run `zig cc -v` with status exit code: 1: error: unable to create compilation: LibCStdLibHeaderNotFound
#windows:
# runs-on: ${{ matrix.platform.runner }}
# strategy:
# fail-fast: false
# matrix:
# platform:
# - runner: windows-latest
# target: x64
# python_arch: x64
# - runner: windows-latest
# target: x86
# python_arch: x86
# - runner: windows-11-arm
# target: aarch64
# python_arch: arm64
# steps:
# - uses: actions/checkout@v6
# - uses: ./.github/actions/mlt-setup-rust
# - uses: actions/setup-python@v6
# with:
# python-version: 3.13
# architecture: ${{ matrix.platform.python_arch }}
# - name: Build wheels
# uses: PyO3/maturin-action@v1
# with:
# target: ${{ matrix.platform.target }}
# args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
# sccache: false
# - name: Upload wheels
# uses: actions/upload-artifact@v7
# with:
# name: wheels-windows-${{ matrix.platform.target }}
# path: dist
macos:
runs-on: ${{ matrix.platform.runner }}
strategy:
fail-fast: false
matrix:
platform:
- runner: macos-15-intel
target: x86_64
- runner: macos-latest
target: aarch64
steps:
- uses: actions/checkout@v6
- uses: ./.github/actions/mlt-setup-rust
- uses: actions/setup-python@v6
with: { python-version: '3.x' }
- name: Build wheels
uses: PyO3/maturin-action@v1
with:
target: ${{ matrix.platform.target }}
args: --release --zig --out dist --find-interpreter --locked --compatibility pypi --future-incompat-report --manifest-path rust/mlt-py/Cargo.toml
sccache: false
- name: Upload wheels
uses: actions/upload-artifact@v7
with:
name: wheels-macos-${{ matrix.platform.target }}
path: dist
sdist:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- name: Build sdist
uses: PyO3/maturin-action@v1
with:
command: sdist
args: --out dist --manifest-path rust/mlt-py/Cargo.toml
- name: Upload sdist
uses: actions/upload-artifact@v7
with: { name: 'wheels-sdist', path: 'dist' }
release:
name: Release
runs-on: ubuntu-latest
if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
needs:
- linux
# FIXME: does seem to require dev-only dependencys
#- musllinux
# FIXME: Failed to run `zig cc -v` with status exit code: 1: error: unable to create compilation: LibCStdLibHeaderNotFound
#- windows
- macos
- sdist
permissions:
# Use to sign the release artifacts
id-token: write
# Used to upload release artifacts
contents: write
# Used to generate artifact attestation
attestations: write
steps:
- uses: actions/download-artifact@v8
- name: Generate artifact attestation
uses: actions/attest-build-provenance@v4
with: { subject-path: 'wheels-*/*' }
- name: Install uv
if: ${{ startsWith(github.ref, 'refs/tags/') }}
uses: astral-sh/setup-uv@v7
- name: Publish to PyPI
if: ${{ startsWith(github.ref, 'refs/tags/') }}
run: uv publish 'wheels-*/*'
================================================
FILE: .github/workflows/rust.yml
================================================
name: Rust CI
on:
workflow_call:
inputs:
run-release:
type: boolean
default: false
workflow_dispatch:
jobs:
lint:
name: Lint
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- run: just -v rust::ci-check
- run: just -v rust::ci-lint
coverage:
name: Coverage
permissions:
id-token: write # for OIDC Codecov
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
with: { toolchain: nightly } # because of covs --doctests
- uses: taiki-e/install-action@v2
with: { tool: "cargo-llvm-cov" }
- run: just -v rust::ci-coverage
- name: Upload coverage to Codecov
if: github.repository_owner == 'maplibre'
uses: codecov/codecov-action@v6
with:
use_oidc: true
fail_ci_if_error: true
disable_search: true
files: rust/target/llvm-cov/lcov.info
- run: just -v assert-git-is-clean
test-wasm:
name: Test wasm
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- run: rustup component add rust-src --toolchain nightly-x86_64-unknown-linux-gnu
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version-file: "rust/mlt-wasm/.nvmrc"
cache: "npm"
cache-dependency-path: "rust/mlt-wasm/package-lock.json"
- run: just -v rust::ci-test-wasm
fuzz:
name: Fuzz ${{ matrix.target }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
include:
- target: layer
- target: decoded_layer
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
with: { toolchain: nightly }
- run: just -v rust::ci-fuzz-build ${{ matrix.target }}
- if: matrix.target == 'layer'
run: just -v rust::fuzz-seed ${{ matrix.target }}
- run: just -v rust::ci-fuzz-run ${{ matrix.target }}
- name: Generate fuzz coverage
if: github.repository_owner == 'maplibre'
run: just -v rust::ci-fuzz-cov ${{ matrix.target }}
- name: Upload fuzz coverage artifact
if: github.repository_owner == 'maplibre'
uses: actions/upload-artifact@v7
with:
name: fuzz-coverage-${{ matrix.target }}
path: rust/target/llvm-cov/fuzz-${{ matrix.target }}.lcov
# MSRV Testing is not really needed at this stage of code completeness
# test-msrv:
# name: Test MSRV
# runs-on: ubuntu-latest
# steps:
# - uses: actions/checkout@v6.0.2
# - uses: ./.github/actions/mlt-setup-rust
# with: { toolchain: msrv }
# - run: just -v rust::ci-test-msrv
test-publish:
name: Test workspace publishing using --dry-run
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- name: Test workspace publishing
run: just -v rust::test-publish
- run: just -v assert-git-is-clean
build-release-binaries:
name: Build release binaries for ${{ matrix.target }}
strategy:
fail-fast: false
matrix:
include:
- os: ubuntu-latest
target: x86_64-unknown-linux-gnu
artifact_name: mlt-x86_64-unknown-linux-gnu.tar.gz
- os: ubuntu-24.04-arm
target: aarch64-unknown-linux-gnu
artifact_name: mlt-aarch64-unknown-linux-gnu.tar.gz
- os: macos-latest
target: aarch64-apple-darwin
artifact_name: mlt-aarch64-apple-darwin.tar.gz
- os: windows-latest
target: x86_64-pc-windows-msvc
artifact_name: mlt-x86_64-pc-windows-msvc.zip
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
- run: just -v rust::ci-build-release ${{ matrix.target }} ${{ matrix.artifact_name }}
- name: Upload artifacts
uses: actions/upload-artifact@v7
with:
name: ${{ matrix.artifact_name }}
path: ${{ matrix.artifact_name }}
build-wasm-npm:
name: Build @maplibre/mlt-wasm npm package
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: ./.github/actions/mlt-setup-rust
with: { toolchain: nightly }
- run: rustup component add rust-src --toolchain nightly-x86_64-unknown-linux-gnu
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version-file: "rust/mlt-wasm/.nvmrc"
cache: "npm"
cache-dependency-path: "rust/mlt-wasm/package-lock.json"
- name: Build
run: just -v rust::wasm-build
- name: Merge license files into LICENSE.txt
working-directory: rust/mlt-wasm
run: |
{
echo "===== MIT License ====="
cat ../../LICENSE-MIT
echo
echo "===== Apache License 2.0 ====="
cat ../../LICENSE-APACHE
} > LICENSE.txt
- name: Pack
working-directory: rust/mlt-wasm
run: npm pack
- name: Upload npm package artifact
uses: actions/upload-artifact@v7
with:
name: mlt-wasm-npm
path: rust/mlt-wasm/maplibre-mlt-wasm-*.tgz
# This job checks if any of the previous jobs failed or were canceled.
# This approach also allows some jobs to be skipped if they are not needed.
ci-passed-rust:
needs:
- lint
- coverage
# re-enable once we have stability guarantees regarding MSRV
# - test-msrv
- test-wasm
- build-release-binaries
- test-publish
- build-wasm-npm
if: always()
runs-on: ubuntu-latest
steps:
- name: Result of the needed steps
run: echo "${{ toJSON(needs) }}"
- if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}
run: exit 1
# Release unpublished packages or create a PR with changes
release-plz:
needs: [ci-passed-rust]
if: |
always()
&& needs.ci-passed-rust.result == 'success'
&& inputs.run-release
&& github.repository_owner == 'maplibre'
runs-on: ubuntu-latest
permissions:
contents: read
id-token: write
concurrency:
group: release-plz-${{ github.ref }}
cancel-in-progress: false
steps:
- run: rustup update stable && rustup default stable
- uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
with: { fetch-depth: 0, persist-credentials: false }
- uses: ./.github/actions/mlt-setup-rust
- name: Publish to crates.io if crate's version is newer
uses: release-plz/action@1528104d2ca23787631a1c1f022abb64b34c1e11 # v0.5.128
id: release
with: { command: release, manifest_path: ./rust/Cargo.toml }
env:
GITHUB_TOKEN: ${{ secrets.RELEASE_PLZ_TOKEN }}
- if: ${{ steps.release.outputs.releases_created == 'false' }}
name: If version is the same, create a PR proposing new version and changelog for the next release
uses: release-plz/action@1528104d2ca23787631a1c1f022abb64b34c1e11 # v0.5.128
with: { command: release-pr, manifest_path: ./rust/Cargo.toml }
env:
GITHUB_TOKEN: ${{ secrets.RELEASE_PLZ_TOKEN }}
outputs:
releases_created: ${{ steps.release.outputs.releases_created }}
releases: ${{ steps.release.outputs.releases }}
upload-release-binaries:
name: Upload release binaries to GitHub releases
needs: [release-plz]
if: ${{ needs.release-plz.outputs.releases_created == 'true' }}
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: "just" }
- name: Get mlt version for release tag
id: get_version
shell: bash
run: just -v rust::ci-get-release-info mlt >> $GITHUB_OUTPUT
- name: Download all artifacts
uses: actions/download-artifact@v8
with: { path: artifacts }
- name: Add binaries to GitHub release
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: ${{ steps.get_version.outputs.tag }}
files: |
artifacts/**/*.tar.gz
artifacts/**/*.zip
fail_on_unmatched_files: true
# Publish @maplibre/mlt-wasm to npm after mlt-wasm is released to crates.io.
# The npm package tarball was already built and uploaded as an artifact by build-wasm-npm.
publish-wasm-npm:
name: Publish @maplibre/mlt-wasm to npm
needs: [release-plz]
if: |
needs.release-plz.outputs.releases_created == 'true'
&& contains(fromJSON(needs.release-plz.outputs.releases || '[]').*.package_name, 'mlt-wasm')
runs-on: ubuntu-latest
permissions:
contents: write
id-token: write
steps:
- name: Get mlt-wasm release version
id: version
env:
RELEASES: ${{ needs.release-plz.outputs.releases }}
run: |
echo "value=$(echo "$RELEASES" | jq -r '.[] | select(.package_name == "mlt-wasm") | .version')" >> $GITHUB_OUTPUT
- name: Set prerelease flag
run: |
version="${{ steps.version.outputs.value }}"
echo version="$version" >> "$GITHUB_ENV"
if [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
echo prerelease=false >> "$GITHUB_ENV"
else
echo prerelease=true >> "$GITHUB_ENV"
fi
- name: Setup Node.js
uses: actions/setup-node@v6
with:
node-version: "24"
registry-url: "https://registry.npmjs.org"
- name: Download npm package artifact
uses: actions/download-artifact@v8
with:
name: mlt-wasm-npm
path: mlt-wasm-pkg
- name: Release (GitHub) - Create Draft
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
name: mlt-wasm-js-v${{ env.version }}
tag_name: mlt-wasm-js-v${{ env.version }}
prerelease: ${{ env.prerelease }}
draft: true
- name: Publish npm package
run: |
package_tgz="$(find mlt-wasm-pkg -type f -name 'maplibre-mlt-wasm-*.tgz' -print -quit)"
test -n "$package_tgz" || { echo "::error::Package file not found in mlt-wasm-pkg"; exit 1; }
npm publish "$package_tgz" --access=public
- name: Publish GitHub release (remove draft)
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: mlt-wasm-js-v${{ env.version }}
name: mlt-wasm-js-v${{ env.version }}
draft: false
================================================
FILE: .github/workflows/ts-bump-version.yml
================================================
name: Manual TypeScript Version Bump
on:
workflow_dispatch:
inputs:
release_type:
type: choice
description: 'Type of version bump'
options:
- major
- minor
- patch
- premajor
- preminor
- prepatch
- prerelease
jobs:
js-bump-version:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Update version, commit, and create tag
working-directory: ts
run: |
npm version ${{ github.event.inputs.release_type }} --no-git-tag-version
echo version="$(node -p "require('./package.json').version")" >> "$GITHUB_ENV"
- name: Create Pull Request
uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1
with:
commit-message: bump @maplibre/mlt version to ${{ env.version }}
branch: mlt-js-version-${{ env.version }}
title: bump @maplibre/mlt version to ${{ env.version }}
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/ts-release.yml
================================================
name: TypeScript - Release
permissions:
id-token: write # Required for trusted publishing
contents: write
on:
push:
branches:
- main
workflow_dispatch:
jobs:
release-check:
name: Check if version changed
runs-on: ubuntu-latest
defaults:
run:
shell: bash
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- name: Check if version has been updated
id: check
uses: EndBug/version-check@095362f3cd50f690c8fa0e6afeea81834bd8d320
with:
file-name: ts/package.json
- run: just -v assert-git-is-clean
outputs:
publish: ${{ steps.check.outputs.changed }}
release:
name: Release
needs: release-check
if: ${{ needs.release-check.outputs.publish == 'true' }}
runs-on: ubuntu-latest
defaults:
run:
working-directory: ts
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- uses: ./.github/actions/mlt-setup-node
- name: Get version
run: |
version="$(node -p "require('./package.json').version")"
echo version="$version" >> "$GITHUB_ENV"
if [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
echo prerelease=false >> "$GITHUB_ENV"
else
echo prerelease=true >> "$GITHUB_ENV"
fi
- name: Install
run: npm ci
- name: Build
run: npm run build
- name: Merge license files into LICENSE.txt
run: |
{
echo "===== MIT License ====="
cat ../LICENSE-MIT
echo
echo "===== Apache License 2.0 ====="
cat ../LICENSE-APACHE
} > LICENSE.txt
- name: Release (GitHub) - Create Draft
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
name: js-v${{ env.version }}
tag_name: js-v${{ env.version }}
prerelease: ${{ env.prerelease }}
draft: true
- if: github.repository_owner == 'maplibre'
name: Publish npm package
run: npm publish --access=public
- name: Publish GitHub release (remove draft)
uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
with:
tag_name: js-v${{ env.version }}
name: js-v${{ env.version }}
draft: false
- run: just -v assert-git-is-clean
================================================
FILE: .github/workflows/ts.yml
================================================
name: TypeScript CI
on:
workflow_call:
workflow_dispatch:
defaults:
run:
shell: bash
jobs:
test-js:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6.0.2
- uses: taiki-e/install-action@v2
with: { tool: 'just,cargo-binstall' }
- uses: ./.github/actions/mlt-setup-node
- name: Lint JS code. If fails, run `just ts::fmt` to reformat, and `just ts::lint` to see issues locally
run: just -v ts::lint
- run: just -v ts::test
- run: just -v ts::build
- name: Codecov upload
if: "github.repository_owner == 'maplibre' && !cancelled()"
uses: codecov/codecov-action@v6
with:
files: ts/coverage/coverage-final.json
- run: just -v assert-git-is-clean
================================================
FILE: .gitignore
================================================
*.class
*.diff.geojson
*.gcov
*.log
*.new.geojson
*.actual.json
.DS_Store
.cache/
.idea/
.kotlin
.venv
.vscode/
MODULE.bazel.lock
bazel-*
bin/
codecov*
coverage/
dist/
site/
tmp/
node_modules
================================================
FILE: .gitmodules
================================================
[submodule "cpp/vendor/googletest"]
path = cpp/vendor/googletest
url = https://github.com/google/googletest.git
[submodule "cpp/vendor/simde"]
path = cpp/vendor/simde
url = https://github.com/simd-everywhere/simde.git
[submodule "cpp/vendor/fastpfor"]
path = cpp/vendor/fastpfor
url = https://github.com/fast-pack/FastPFor.git
[submodule "cpp/vendor/json"]
path = cpp/vendor/json
url = https://github.com/nlohmann/json.git
================================================
FILE: .pre-commit-config.yaml
================================================
# See https://pre-commit.com for more information
# See https://pre-commit.com/hooks.html for more hooks
# exclusions should be separated with a pipe (|) character and a newline
exclude: |
(?x)^(
test/expected/.*
|java/gradlew(\.bat)?
|\.cursor/rules/.*
)$
ci:
autoupdate_schedule: monthly
# sometimes fails https://github.com/keith/pre-commit-buildifier/issues/13
skip: [ buildifier ]
repos:
- repo: https://github.com/pre-commit/pre-commit-hooks
rev: v6.0.0
hooks:
- id: check-added-large-files
args: ['--maxkb=553']
- id: check-executables-have-shebangs
- id: check-json
exclude: '.+/tsconfig.json'
- id: check-shebang-scripts-are-executable
exclude: '.+\.rs' # would be triggered by #![some_attribute]
- id: check-symlinks
- id: check-toml
- id: check-yaml
args: [ --allow-multiple-documents ]
exclude: mkdocs.yml
- id: destroyed-symlinks
- id: end-of-file-fixer
- id: mixed-line-ending
args: [ --fix=lf ]
- id: trailing-whitespace
- repo: https://github.com/pre-commit/mirrors-clang-format
rev: v22.1.2
hooks:
- id: clang-format
types: [ c++ ]
args: ["-style=file:.clang-format"]
- repo: https://github.com/Mateusz-Grzelinski/actionlint-py
rev: v1.7.12.24
hooks:
- id: actionlint
additional_dependencies: [ shellcheck-py ]
exclude: '\.github/workflows/rust(-legacy)?\.yml'
- repo: local
hooks:
- id: cargo-fmt
name: Rust Format
description: "Automatically format Rust code with cargo fmt"
entry: sh -c "cd rust && cargo fmt --all"
language: rust
pass_filenames: false
- repo: https://github.com/keith/pre-commit-buildifier
rev: 8.5.1.1
hooks:
- id: buildifier
- repo: https://github.com/biomejs/pre-commit
rev: v2.4.10
hooks:
- id: biome-check
args: [--unsafe]
exclude: '.*\.json$'
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Code of conduct
[](https://github.com/maplibre/maplibre/blob/main/CODE_OF_CONDUCT.md)
================================================
FILE: LICENSE-APACHE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2024 MapLibre contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: LICENSE-CC0
================================================
Creative Commons Legal Code
CC0 1.0 Universal
CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
HEREUNDER.
Statement of Purpose
The laws of most jurisdictions throughout the world automatically confer
exclusive Copyright and Related Rights (defined below) upon the creator
and subsequent owner(s) (each and all, an "owner") of an original work of
authorship and/or a database (each, a "Work").
Certain owners wish to permanently relinquish those rights to a Work for
the purpose of contributing to a commons of creative, cultural and
scientific works ("Commons") that the public can reliably and without fear
of later claims of infringement build upon, modify, incorporate in other
works, reuse and redistribute as freely as possible in any form whatsoever
and for any purposes, including without limitation commercial purposes.
These owners may contribute to the Commons to promote the ideal of a free
culture and the further production of creative, cultural and scientific
works, or to gain reputation or greater distribution for their Work in
part through the use and efforts of others.
For these and/or other purposes and motivations, and without any
expectation of additional consideration or compensation, the person
associating CC0 with a Work (the "Affirmer"), to the extent that he or she
is an owner of Copyright and Related Rights in the Work, voluntarily
elects to apply CC0 to the Work and publicly distribute the Work under its
terms, with knowledge of his or her Copyright and Related Rights in the
Work and the meaning and intended legal effect of CC0 on those rights.
1. Copyright and Related Rights. A Work made available under CC0 may be
protected by copyright and related or neighboring rights ("Copyright and
Related Rights"). Copyright and Related Rights include, but are not
limited to, the following:
i. the right to reproduce, adapt, distribute, perform, display,
communicate, and translate a Work;
ii. moral rights retained by the original author(s) and/or performer(s);
iii. publicity and privacy rights pertaining to a person's image or
likeness depicted in a Work;
iv. rights protecting against unfair competition in regards to a Work,
subject to the limitations in paragraph 4(a), below;
v. rights protecting the extraction, dissemination, use and reuse of data
in a Work;
vi. database rights (such as those arising under Directive 96/9/EC of the
European Parliament and of the Council of 11 March 1996 on the legal
protection of databases, and under any national implementation
thereof, including any amended or successor version of such
directive); and
vii. other similar, equivalent or corresponding rights throughout the
world based on applicable law or treaty, and any national
implementations thereof.
2. Waiver. To the greatest extent permitted by, but not in contravention
of, applicable law, Affirmer hereby overtly, fully, permanently,
irrevocably and unconditionally waives, abandons, and surrenders all of
Affirmer's Copyright and Related Rights and associated claims and causes
of action, whether now known or unknown (including existing as well as
future claims and causes of action), in the Work (i) in all territories
worldwide, (ii) for the maximum duration provided by applicable law or
treaty (including future time extensions), (iii) in any current or future
medium and for any number of copies, and (iv) for any purpose whatsoever,
including without limitation commercial, advertising or promotional
purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
member of the public at large and to the detriment of Affirmer's heirs and
successors, fully intending that such Waiver shall not be subject to
revocation, rescission, cancellation, termination, or any other legal or
equitable action to disrupt the quiet enjoyment of the Work by the public
as contemplated by Affirmer's express Statement of Purpose.
3. Public License Fallback. Should any part of the Waiver for any reason
be judged legally invalid or ineffective under applicable law, then the
Waiver shall be preserved to the maximum extent permitted taking into
account Affirmer's express Statement of Purpose. In addition, to the
extent the Waiver is so judged Affirmer hereby grants to each affected
person a royalty-free, non transferable, non sublicensable, non exclusive,
irrevocable and unconditional license to exercise Affirmer's Copyright and
Related Rights in the Work (i) in all territories worldwide, (ii) for the
maximum duration provided by applicable law or treaty (including future
time extensions), (iii) in any current or future medium and for any number
of copies, and (iv) for any purpose whatsoever, including without
limitation commercial, advertising or promotional purposes (the
"License"). The License shall be deemed effective as of the date CC0 was
applied by Affirmer to the Work. Should any part of the License for any
reason be judged legally invalid or ineffective under applicable law, such
partial invalidity or ineffectiveness shall not invalidate the remainder
of the License, and in such case Affirmer hereby affirms that he or she
will not (i) exercise any of his or her remaining Copyright and Related
Rights in the Work or (ii) assert any associated claims and causes of
action with respect to the Work, in either case contrary to Affirmer's
express Statement of Purpose.
4. Limitations and Disclaimers.
a. No trademark or patent rights held by Affirmer are waived, abandoned,
surrendered, licensed or otherwise affected by this document.
b. Affirmer offers the Work as-is and makes no representations or
warranties of any kind concerning the Work, express, implied,
statutory or otherwise, including without limitation warranties of
title, merchantability, fitness for a particular purpose, non
infringement, or the absence of latent or other defects, accuracy, or
the present or absence of errors, whether or not discoverable, all to
the greatest extent permissible under applicable law.
c. Affirmer disclaims responsibility for clearing rights of other persons
that may apply to the Work or any use thereof, including without
limitation any person's Copyright and Related Rights in the Work.
Further, Affirmer disclaims responsibility for obtaining any necessary
consents, permissions or other rights required for any use of the
Work.
d. Affirmer understands and acknowledges that Creative Commons is not a
party to this document and has no duty or obligation with respect to
this CC0 or use of the Work.
================================================
FILE: LICENSE-MIT
================================================
MIT License
Copyright (c) 2024 MapLibre contributors
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: MODULE.bazel
================================================
module(name = "maplibre-tile-spec")
bazel_dep(name = "platforms", version = "1.0.0")
bazel_dep(name = "rules_cc", version = "0.2.8")
================================================
FILE: README.md
================================================
<p align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://maplibre.org/img/maplibre-logos/maplibre-logo-for-dark-bg.svg">
<source media="(prefers-color-scheme: light)" srcset="https://maplibre.org/img/maplibre-logos/maplibre-logo-for-light-bg.svg">
<img alt="MapLibre Logo" src="https://maplibre.org/img/maplibre-logos/maplibre-logo-for-light-bg.svg" width="200">
</picture>
</p>
# MapLibre Tile (MLT)
> [!NOTE]
> [The specification](https://maplibre.org/maplibre-tile-spec/specification/) is deemed stable as of October 2025. However, as a living standard, experimental features may continue to evolve. Implementations and integrations are being developed, refer to the [implementation status](https://maplibre.org/maplibre-tile-spec/implementation-status/) page for the current status.
The MapLibre Tile specification is mainly inspired by the [Mapbox Vector Tile (MVT)](https://github.com/mapbox/vector-tile-spec) specification,
but has been redesigned from the ground up to address the challenges of rapidly growing geospatial data volumes
and complex next-generation geospatial source formats as well as to leverage the capabilities of modern hardware and APIs.
MLT is specifically designed for modern and next generation graphics APIs to enable high-performance processing and rendering of
large (planet-scale) 2D and 2.5 basemaps. In particular, MLT offers the following features:
- **Improved compression ratio**: up to 6x on large encoded tiles, based on a column oriented layout with recursively applied (custom)
lightweight encodings. This leads to reduced latency, storage, and egress costs and, in particular, improved cache utilization
- **Better decoding performance**: fast lightweight encodings which can be used in combination with SIMD/vectorization instructions
- **Support for linear referencing and m-values** to efficiently support the upcoming next generation source formats such as Overture Maps (GeoParquet)
- **Support 3D coordinates**, i.e. elevation
- **Support complex types**, including nested properties, lists and maps
- **Improved processing performance**, based on storage and in-memory formats that are specifically designed for modern GL APIs,
allowing for efficient processing on both CPU and GPU. The formats are designed to be loaded into
GPU buffers with little or no additional processing
📝 For a more in-depth exploration of MLT have a look at the [following slides](https://github.com/mactrem/presentations/blob/main/FOSS4G_2024_Europe/FOSS4G_2024_Europe.pdf), watch
[this talk](https://www.youtube.com/watch?v=YHcoAFcsES0) or read [this paper](https://dl.acm.org/doi/10.1145/3748636.3763208) by MLT inventor Markus Tremmel.
## Directory Structure
- `/spec` MLT specification and related documentation
- `/test` Test MVT tiles and the expected MLT conversion results
- `/java` Java encoder for converting MVT to MLT, as well as a decoder parsing MLT to an in-memory representation.
- `/js` Javascript decoder
- `/rust` Rust decoder
## Getting Involved
Join the `#maplibre-tile-format` Slack channel at OSM US: get an invite at https://slack.openstreetmap.us/
### Development
* This project is easier to develop with [just](https://just.systems/man/en/), a modern alternative to `make`.
* To get a list of available commands, run `just`.
* To run tests, use `just test`.
## License
* All project documentation and specification content is licensed under [CC0 1.0 Universal](https://creativecommons.org/publicdomain/zero/1.0/) - Public Domain Dedication.
* All code is dual licensed under [Apache License v2.0](http://www.apache.org/licenses/LICENSE-2.0) and [MIT license](http://opensource.org/licenses/MIT), at your option.
* Tile test data in the `/test` directory has different licenses depending on the source of that data.
### Contribution
Unless you explicitly state otherwise, any code contribution intentionally
submitted for inclusion in the work by you, as defined in the
Apache-2.0 license, shall be dual licensed as above, without any
additional terms or conditions. Similarly, any documentation or specification
contributions shall be licensed under CC0 1.0 Universal.
## Citing
If you use MapLibre Tile in your research, please cite our paper:
```bibtex
@inproceedings{tremmel2025maplibretile,
title = {MapLibre Tile: A Next Generation Vector Tile Format},
author = {Tremmel, Markus and Zink, Roland},
booktitle = {Proceedings of the 33rd ACM International Conference on Advances in Geographic Information Systems},
series = {SIGSPATIAL '25},
year = {2025},
pages = {1118--1121},
doi = {10.1145/3748636.3763208},
url = {https://doi.org/10.1145/3748636.3763208}
}
```
================================================
FILE: SECURITY_POLICY.txt
================================================
For an up-to-date policy refer to
https://github.com/maplibre/maplibre/blob/main/SECURITY_POLICY.txt
================================================
FILE: biome.json
================================================
{
"$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
"css": {
"formatter": {
"indentWidth": 2,
"indentStyle": "space"
}
},
"javascript": {
"formatter": {
"indentWidth": 2,
"indentStyle": "space"
}
}
}
================================================
FILE: cpp/.clang-tidy
================================================
---
Checks: [
android-*,
boost-*,
bugprone-*,
clang-analyzer-core*,
clang-analyzer-cplusplus*,
clang-analyzer-deadcode*,
clang-analyzer-optin.cplusplus*,
clang-analyzer-optin.performance.Padding,
clang-analyzer-security*,
clang-diagnostic-*,
cppcoreguidelines-avoid-goto,
cppcoreguidelines-no-malloc,
google-*,
llvm-*,
misc-*,
modernize-*,
performance-*,
portability-*,
readability-*,
-bugprone-branch-clone,
-bugprone-easily-swappable-parameters,
-bugprone-exception-escape,
-bugprone-forward-declaration-namespace,
-bugprone-forwarding-reference-overload,
-bugprone-implicit-widening-of-multiplication-result,
-bugprone-macro-parentheses,
-bugprone-narrowing-conversions,
-bugprone-reserved-identifier,
-bugprone-signed-char-misuse,
-bugprone-sizeof-expression,
-bugprone-unchecked-optional-access,
-bugprone-unhandled-exception-at-new,
-bugprone-unhandled-self-assignment,
-clang-analyzer-optin.cplusplus.UninitializedObject,
-clang-analyzer-core.NonNullParamChecker,
-clang-analyzer-core.NullDereference,
-clang-analyzer-core.uninitialized.Assign,
-clang-analyzer-core.UndefinedBinaryOperatorResult,
-clang-analyzer-security.FloatLoopCounter,
-google-build-explicit-make-pair,
-google-build-namespaces,
-google-build-using-namespace,
-google-default-arguments,
-google-explicit-constructor,
-google-objc-global-variable-declaration,
-google-readability-braces-around-statements,
-google-readability-casting,
-google-readability-function-size,
-google-readability-function,
-google-readability-namespace-comments,
-google-readability-todo,
-google-runtime-int,
-google-runtime-references,
-llvm-else-after-return,
-llvm-header-guard,
-llvm-include-order,
-llvm-namespace-comment,
-llvm-qualified-auto,
-llvm-twine-local,
-misc-confusable-identifiers,
-misc-const-correctness,
-misc-no-recursion,
-misc-non-private-member-variables-in-classes,
-misc-static-assert,
-modernize-avoid-bind,
-modernize-avoid-c-arrays,
-modernize-concat-nested-namespaces,
-modernize-macro-to-enum,
-modernize-pass-by-value,
-modernize-return-braced-init-list,
-modernize-use-auto,
-modernize-use-default-member-init,
-modernize-use-emplace,
-modernize-use-equals-default,
-modernize-use-nodiscard,
-modernize-use-nullptr,
-modernize-use-trailing-return-type,
-performance-move-const-arg,
-performance-noexcept-move-constructor,
-performance-no-int-to-ptr,
-performance-unnecessary-value-param,
-readability-avoid-const-params-in-decls,
-readability-braces-around-statements,
-readability-const-return-type,
-readability-container-size-empty,
-readability-convert-member-functions-to-static,
-readability-else-after-return,
-readability-function-cognitive-complexity,
-readability-function-size,
-readability-identifier-length,
-readability-identifier-naming,
-readability-implicit-bool-conversion,
-readability-inconsistent-declaration-parameter-name,
-readability-isolate-declaration,
-readability-magic-numbers,
-readability-make-member-function-const,
-readability-named-parameter,
-readability-non-const-parameter,
-readability-qualified-auto,
-readability-redundant-access-specifiers,
-readability-redundant-declaration,
-readability-redundant-member-init,
-readability-redundant-string-init,
-readability-simplify-boolean-expr,
-readability-static-accessed-through-instance
-readability-static-definition-in-anonymous-namespace,
-readability-suspicious-call-argument,
-readability-uppercase-literal-suffix,
-readability-use-anyofallof,
-modernize-loop-convert, # since C++20 this complains about reverse loops with iterators, but good ranges support only landed in clang 15
-performance-enum-size,
-misc-include-cleaner,
-readability-redundant-inline-specifier,
-readability-avoid-nested-conditional-operator,
-cppcoreguidelines-pro-type-static-cast-downcast, # no RTTI
]
WarningsAsErrors: '*'
HeaderFilterRegex: '.*'
CheckOptions:
- key: performance-unnecessary-value-param.AllowedTypes
value: 'exception_ptr'
================================================
FILE: cpp/.gitignore
================================================
/build
/.cache
compile_commands.json
cmake_test_discovery*
================================================
FILE: cpp/.nvmrc
================================================
24.13
================================================
FILE: cpp/BUILD.bazel
================================================
load("@rules_cc//cc:cc_library.bzl", "cc_library")
cc_library(
name = "mlt_internal_headers",
hdrs = glob(["src/mlt/**/*.hpp"]),
include_prefix = "",
strip_include_prefix = "src",
visibility = ["//visibility:private"],
)
cc_library(
name = "mlt_cpp",
srcs = glob([
"src/mlt/**/*.cpp",
]),
hdrs = glob([
"include/mlt/**/*.hpp",
]),
copts = select({
"@platforms//os:windows": [
"/std:c++20",
],
"//conditions:default": [
"-std=c++20",
"-Wall",
"-Wextra",
],
}),
defines = [
"MLT_WITH_JSON=0",
"MLT_WITH_FASTPFOR=0",
],
implementation_deps = [":mlt_internal_headers"],
include_prefix = "",
strip_include_prefix = "include",
visibility = ["//visibility:public"],
)
================================================
FILE: cpp/CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.25)
project(mlt-cpp LANGUAGES CXX)
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
include(AddCXXCompilerFlag)
# generate compile_commands.json https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_CXX_STANDARD 20)
if(PROJECT_IS_TOP_LEVEL AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
set(CMAKE_CXX_FLAGS_COVERAGE "-g -O0 --coverage")
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
string(APPEND CMAKE_CXX_FLAGS_COVERAGE " -fprofile-abs-path")
endif()
set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "--coverage")
set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "--coverage")
set(CMAKE_MODULE_LINKER_FLAGS_COVERAGE "--coverage")
endif()
add_library(mlt-cpp STATIC)
option(MLT_WITH_JSON "Include JSON support" ON)
option(MLT_WITH_FASTPFOR "Include FastPFor support" ON)
option(MLT_WITH_FASTPFOR_SIMD "Include SIMD/NEON support in FastPFor decoding" ON)
option(MLT_WITH_TESTS "Include Tests" ON)
option(MLT_WITH_TOOLS "Include CLI tools" ON)
set_target_properties(
mlt-cpp
PROPERTIES
INTERFACE_MAPLIBRE_NAME "MapLibre Tile Format"
INTERFACE_MAPLIBRE_URL "https://github.com/maplibre/maplibre-tile-spec"
INTERFACE_MAPLIBRE_AUTHOR "MapLibre"
INTERFACE_MAPLIBRE_LICENSE "${PROJECT_SOURCE_DIR}/../LICENSE-APACHE"
)
add_cxx_compiler_flag(-Wall)
add_cxx_compiler_flag(-Werror)
add_cxx_compiler_flag(-Wextra)
add_cxx_compiler_flag(-Wdeprecated-declarations)
add_cxx_compiler_flag(-Winvalid-offsetof)
add_cxx_compiler_flag(-Wno-block-capture-autoreleasing)
add_cxx_compiler_flag(-Wno-bool-conversion)
add_cxx_compiler_flag(-Wno-c++11-extensions)
add_cxx_compiler_flag(-Wno-comma)
add_cxx_compiler_flag(-Wno-constant-conversion)
add_cxx_compiler_flag(-Wno-conversion)
add_cxx_compiler_flag(-Wno-empty-body)
add_cxx_compiler_flag(-Wno-enum-conversion)
add_cxx_compiler_flag(-Wno-exit-time-destructors)
add_cxx_compiler_flag(-Wno-float-conversion)
add_cxx_compiler_flag(-Wno-four-char-constants)
add_cxx_compiler_flag(-Wno-implicit-fallthrough)
add_cxx_compiler_flag(-Wno-infinite-recursion)
add_cxx_compiler_flag(-Wno-missing-braces)
add_cxx_compiler_flag(-Wno-missing-field-initializers)
add_cxx_compiler_flag(-Wno-move)
add_cxx_compiler_flag(-Wno-newline-eof)
add_cxx_compiler_flag(-Wno-non-literal-null-conversion)
add_cxx_compiler_flag(-Wno-non-virtual-dtor)
add_cxx_compiler_flag(-Wno-objc-literal-conversion)
add_cxx_compiler_flag(-Wno-overloaded-virtual)
add_cxx_compiler_flag(-Wno-range-loop-analysis)
add_cxx_compiler_flag(-Wno-return-type)
add_cxx_compiler_flag(-Wno-semicolon-before-method-body)
add_cxx_compiler_flag(-Wno-shadow)
add_cxx_compiler_flag(-Wno-sign-conversion)
add_cxx_compiler_flag(-Wno-trigraphs)
add_cxx_compiler_flag(-Wno-uninitialized)
add_cxx_compiler_flag(-Wno-unknown-pragmas)
add_cxx_compiler_flag(-Wno-unused-function)
add_cxx_compiler_flag(-Wno-unused-label)
add_cxx_compiler_flag(-Wno-unused-parameter)
add_cxx_compiler_flag(-Wno-unused-variable)
add_cxx_compiler_flag(-Wparentheses)
add_cxx_compiler_flag(-Wshorten-64-to-32)
add_cxx_compiler_flag(-Wswitch)
add_cxx_compiler_flag(-Wunused-value)
add_cxx_compiler_flag(-fstrict-aliasing)
add_cxx_compiler_flag(-wd4061) # MSVC: enum member not handled in switch
add_cxx_compiler_flag(-wd4514) # MSVC: unreferenced inline function has been removed
add_cxx_compiler_flag(-wd4710) # MSVC: function not inlined
add_cxx_compiler_flag(-wd4820) # MSVC: padding added after data member
target_include_directories(mlt-cpp
PUBLIC ${PROJECT_SOURCE_DIR}/include
PRIVATE ${PROJECT_SOURCE_DIR}/src
)
list(APPEND MLT_INCLUDE_FILES
${PROJECT_SOURCE_DIR}/include/mlt/common.hpp
${PROJECT_SOURCE_DIR}/include/mlt/decoder.hpp
${PROJECT_SOURCE_DIR}/include/mlt/feature.hpp
${PROJECT_SOURCE_DIR}/include/mlt/geometry.hpp
${PROJECT_SOURCE_DIR}/include/mlt/geometry_vector.hpp
${PROJECT_SOURCE_DIR}/include/mlt/layer.hpp
${PROJECT_SOURCE_DIR}/include/mlt/polyfill.hpp
${PROJECT_SOURCE_DIR}/include/mlt/projection.hpp
${PROJECT_SOURCE_DIR}/include/mlt/properties.hpp
${PROJECT_SOURCE_DIR}/include/mlt/tile.hpp
${PROJECT_SOURCE_DIR}/include/mlt/metadata/stream.hpp
${PROJECT_SOURCE_DIR}/include/mlt/metadata/tileset.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/buffer_stream.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/packed_bitset.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/noncopyable.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/stl.hpp
${PROJECT_SOURCE_DIR}/include/mlt/util/varint.hpp
)
list(APPEND MLT_SRC_FILES
${PROJECT_SOURCE_DIR}/src/mlt/decoder.cpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/geometry.hpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/int.cpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/int.hpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/property.hpp
${PROJECT_SOURCE_DIR}/src/mlt/decode/string.hpp
${PROJECT_SOURCE_DIR}/src/mlt/feature.cpp
${PROJECT_SOURCE_DIR}/src/mlt/geometry_vector.cpp
${PROJECT_SOURCE_DIR}/src/mlt/layer.cpp
${PROJECT_SOURCE_DIR}/src/mlt/metadata/stream.cpp
${PROJECT_SOURCE_DIR}/src/mlt/metadata/tileset.cpp
${PROJECT_SOURCE_DIR}/src/mlt/properties.cpp
${PROJECT_SOURCE_DIR}/src/mlt/util/morton_curve.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/raw.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/rle.cpp
${PROJECT_SOURCE_DIR}/src/mlt/util/rle.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/space_filling_curve.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/vectorized.hpp
${PROJECT_SOURCE_DIR}/src/mlt/util/zigzag.hpp
)
if(MLT_WITH_JSON)
list(APPEND MLT_INCLUDE_FILES ${PROJECT_SOURCE_DIR}/include/mlt/json.hpp)
endif(MLT_WITH_JSON)
target_sources(mlt-cpp PRIVATE
${MLT_INCLUDE_FILES}
${MLT_SRC_FILES}
)
include("${PROJECT_SOURCE_DIR}/vendor/fastpfor.cmake")
# json
if(MLT_WITH_JSON)
message(STATUS "[MLT] Including JSON support")
add_subdirectory("${PROJECT_SOURCE_DIR}/vendor/json" "${CMAKE_CURRENT_BINARY_DIR}/json" EXCLUDE_FROM_ALL SYSTEM)
set(json_SOURCE_DIR "${PROJECT_SOURCE_DIR}/vendor/json")
target_include_directories(mlt-cpp PUBLIC "${json_SOURCE_DIR}/include")
target_compile_definitions(mlt-cpp PUBLIC MLT_WITH_JSON=1)
else()
message(STATUS "[MLT] No JSON support")
endif(MLT_WITH_JSON)
if(MLT_WITH_TESTS)
include(CTest)
add_subdirectory(${PROJECT_SOURCE_DIR}/test EXCLUDE_FROM_ALL)
endif(MLT_WITH_TESTS)
if(MLT_WITH_TOOLS)
add_subdirectory(${PROJECT_SOURCE_DIR}/tool EXCLUDE_FROM_ALL)
endif(MLT_WITH_TOOLS)
export(TARGETS ${MLT_EXPORT_TARGETS} FILE MLTTargets.cmake)
================================================
FILE: cpp/CTestCustom.cmake
================================================
# Exclude vendor/third-party code from coverage reports
set(CTEST_CUSTOM_COVERAGE_EXCLUDE
${CTEST_CUSTOM_COVERAGE_EXCLUDE}
".*/vendor/.*"
".*/build/.*/_deps/.*"
".*/test/.*"
)
================================================
FILE: cpp/README.md
================================================
# maplibre-tile-spec/cpp
A C++ implementation of the MapLibre Tile (MLT) vector tile format.
## Status
Decoder only, partial support for encodings.
CMake and Bazel build support.
## Build
```bash
git submodule update --init --recursive
cmake -GNinja -Bbuild -S.
cmake --build build --target mlt-cpp-test mlt-cpp-json
```
## Test
```
build/test/mlt-cpp-test
```
## Use
To decode a tile:
- Deserialize the tileset metadata
- Create a `Decoder`
- Call `decode` with the metadata and a view on the raw tile data
To use the standard packing of metadata and data within a tile, use `decodeTile`.
```cpp
#include <mlt/decoder.hpp>
#include <mlt/metadata/tileset.hpp>
...
auto metadata = mlt::metadata::tileset::read({metadataBuffer.data(), metadataBuffer.size()});
mlt::Decoder decoder;
const auto tile = decoder.decode({mltBuffer.data(), mltBuffer.size()}, metadata);
const auto tile2 = decoder.decodeTile({tileData.data(), tileData.size()});
```
## Tools
A simple application which dumps a tile/metadata file pair to JSON format.
```bash
build/tool/mlt-cpp-json ../test/expected/tag0x01/bing/4-12-6.mlt
```
================================================
FILE: cpp/bazel/check/BUILD.bazel
================================================
load("@rules_cc//cc:cc_binary.bzl", "cc_binary")
cc_binary(
name = "sse42",
srcs = ["sse42.c"],
copts = select({
"@platforms//os:windows": [
"/EHsc",
"/arch:SSE2",
],
"//conditions:default": [
"-march=native",
"-msse4.2",
],
}),
)
cc_binary(
name = "avx",
srcs = ["avx.c"],
copts = select({
"@platforms//os:windows": [
"/EHsc",
"/arch:AVX",
],
"//conditions:default": [
"-march=native",
"-mavx",
],
}),
)
cc_binary(
name = "avx2",
srcs = ["avx2.c"],
copts = select({
"@platforms//os:windows": [
"/EHsc",
"/arch:AVX2",
],
"//conditions:default": [
"-march=native",
"-mavx2",
],
}),
)
================================================
FILE: cpp/bazel/check/avx.c
================================================
#include<immintrin.h>
int main(){
__m128 x=_mm_set1_ps(0.5);
x=_mm_permute_ps(x,1);
return _mm_movemask_ps(x);
}
================================================
FILE: cpp/bazel/check/avx2.c
================================================
#include<immintrin.h>
int main(){
__m256i x=_mm256_set1_epi32(5);
x=_mm256_add_epi32(x,x);
return _mm256_movemask_epi8(x);
}
================================================
FILE: cpp/bazel/check/sse42.c
================================================
#include<smmintrin.h>
int main(){
__m128 x=_mm_set1_ps(0.5);
x=_mm_dp_ps(x,x,0x77);
return _mm_movemask_ps(x);
}")
================================================
FILE: cpp/cmake/AddCXXCompilerFlag.cmake
================================================
# - Adds a compiler flag if it is supported by the compiler
#
# This function checks that the supplied compiler flag is supported and then
# adds it to the corresponding compiler flags
#
# add_cxx_compiler_flag(<FLAG> [<VARIANT>])
#
# - Example
#
# include(AddCXXCompilerFlag)
# add_cxx_compiler_flag(-Wall)
# add_cxx_compiler_flag(-no-strict-aliasing RELEASE)
# Requires CMake 2.6+
if(__add_cxx_compiler_flag)
return()
endif()
set(__add_cxx_compiler_flag INCLUDED)
include(CheckCXXCompilerFlag)
function(mangle_compiler_flag FLAG OUTPUT)
string(TOUPPER "HAVE_CXX_FLAG_${FLAG}" SANITIZED_FLAG)
string(REPLACE "+" "X" SANITIZED_FLAG ${SANITIZED_FLAG})
string(REGEX REPLACE "[^A-Za-z_0-9]" "_" SANITIZED_FLAG ${SANITIZED_FLAG})
string(REGEX REPLACE "_+" "_" SANITIZED_FLAG ${SANITIZED_FLAG})
set(${OUTPUT} "${SANITIZED_FLAG}" PARENT_SCOPE)
endfunction(mangle_compiler_flag)
function(add_cxx_compiler_flag FLAG)
mangle_compiler_flag("${FLAG}" MANGLED_FLAG)
set(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${FLAG}")
check_cxx_compiler_flag("${FLAG}" ${MANGLED_FLAG})
set(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
if(${MANGLED_FLAG})
set(VARIANT ${ARGV1})
if(ARGV1)
string(TOUPPER "_${VARIANT}" VARIANT)
endif()
set(CMAKE_CXX_FLAGS${VARIANT} "${CMAKE_CXX_FLAGS${VARIANT}} ${BENCHMARK_CXX_FLAGS${VARIANT}} ${FLAG}" PARENT_SCOPE)
endif()
endfunction()
function(add_required_cxx_compiler_flag FLAG)
mangle_compiler_flag("${FLAG}" MANGLED_FLAG)
set(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${FLAG}")
check_cxx_compiler_flag("${FLAG}" ${MANGLED_FLAG})
set(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
if(${MANGLED_FLAG})
set(VARIANT ${ARGV1})
if(ARGV1)
string(TOUPPER "_${VARIANT}" VARIANT)
endif()
set(CMAKE_CXX_FLAGS${VARIANT} "${CMAKE_CXX_FLAGS${VARIANT}} ${FLAG}" PARENT_SCOPE)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${FLAG}" PARENT_SCOPE)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${FLAG}" PARENT_SCOPE)
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${FLAG}" PARENT_SCOPE)
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${FLAG}" PARENT_SCOPE)
else()
message(FATAL_ERROR "Required flag '${FLAG}' is not supported by the compiler")
endif()
endfunction()
function(check_cxx_warning_flag FLAG)
mangle_compiler_flag("${FLAG}" MANGLED_FLAG)
set(OLD_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
# Add -Werror to ensure the compiler generates an error if the warning flag
# doesn't exist.
set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror ${FLAG}")
check_cxx_compiler_flag("${FLAG}" ${MANGLED_FLAG})
set(CMAKE_REQUIRED_FLAGS "${OLD_CMAKE_REQUIRED_FLAGS}")
endfunction()
================================================
FILE: cpp/include/mlt/common.hpp
================================================
#pragma once
#include <mlt/polyfill.hpp>
#include <string_view>
#include <type_traits>
namespace mlt {
using DataView = std::string_view;
template <typename T, std::size_t N>
constexpr std::size_t countof(T (&)[N]) {
return N;
}
/// `std::underlying_type` that doesn't fail when given a simple type
template <typename T, bool = std::is_enum_v<T>>
struct underlying_type {
using type = T;
};
template <typename T>
struct underlying_type<T, true> : ::std::underlying_type<T> {};
template <class T>
using underlying_type_t = typename underlying_type<T>::type;
} // namespace mlt
================================================
FILE: cpp/include/mlt/coordinate.hpp
================================================
#pragma once
#include <cstdint>
#include <vector>
namespace mlt {
struct Coordinate {
float x;
float y;
Coordinate(float x_, float y_) noexcept
: x(x_),
y(y_) {}
bool operator==(const Coordinate& other) const noexcept { return x == other.x && y == other.y; }
bool operator!=(const Coordinate& other) const noexcept { return !(*this == other); }
};
using CoordVec = std::vector<Coordinate>;
struct TileCoordinate {
std::uint32_t x;
std::uint32_t y;
std::uint32_t z;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/decoder.hpp
================================================
#pragma once
#include <mlt/common.hpp>
#include <mlt/tile.hpp>
#include <mlt/util/noncopyable.hpp>
#include <mlt/geometry.hpp>
#include <memory>
namespace mlt {
class Decoder : public util::noncopyable {
public:
using Geometry = geometry::Geometry;
using GeometryFactory = geometry::GeometryFactory;
Decoder(bool supportFastPFOR);
Decoder(std::unique_ptr<GeometryFactory>&&, bool supportFastPFOR);
~Decoder() noexcept;
Decoder(Decoder&&) = delete;
Decoder& operator=(Decoder&&) = delete;
/// Decode a tile
MapLibreTile decode(DataView);
MapLibreTile decode(BufferStream);
private:
struct Impl;
std::unique_ptr<Impl> impl;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/feature.hpp
================================================
#pragma once
#include <mlt/properties.hpp>
#include <mlt/util/noncopyable.hpp>
#include <memory>
#include <optional>
namespace mlt {
namespace geometry {
class Geometry;
}
class Layer;
class Feature : public util::noncopyable {
public:
using id_t = std::uint64_t;
using extent_t = std::uint32_t;
using Geometry = geometry::Geometry;
Feature() = delete;
Feature(Feature&&) noexcept = default;
Feature& operator=(Feature&&) = delete;
/// Construct a feature
/// @param id Feature identifier, or nullopt if the feature has no ID
/// @param geometry Feature geometry, required
/// @param index Index of the property in the layer
Feature(std::optional<id_t> id, std::unique_ptr<Geometry>&&, std::uint32_t index);
~Feature() noexcept;
std::optional<id_t> getID() const noexcept { return ident; }
std::uint32_t getIndex() const noexcept { return index; }
const Geometry& getGeometry() const noexcept { return *geometry; }
std::optional<Property> getProperty(const std::string& key, const Layer&) const;
private:
std::optional<id_t> ident;
std::uint32_t index; // index of the property in the layer
std::unique_ptr<Geometry> geometry;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/geometry.hpp
================================================
#pragma once
#include <mlt/coordinate.hpp>
#include <mlt/metadata/tileset.hpp>
#include <mlt/util/noncopyable.hpp>
#include <memory>
#include <span>
#include <vector>
namespace mlt::geometry {
class Geometry : public util::noncopyable {
public:
using GeometryType = metadata::tileset::GeometryType;
protected:
Geometry(GeometryType type_) noexcept
: type(type_) {}
public:
virtual ~Geometry() noexcept = default;
const auto& getTriangles() const { return triangles; }
void setTriangles(std::span<const std::uint32_t> triangles_) noexcept { triangles = triangles_; }
const metadata::tileset::GeometryType type;
private:
std::span<const std::uint32_t> triangles;
};
class Point : public Geometry {
public:
Point(const Coordinate& coord) noexcept
: Geometry(GeometryType::POINT),
coordinate(coord) {}
const Coordinate& getCoordinate() const noexcept { return coordinate; }
private:
const Coordinate coordinate;
};
class MultiPoint : public Geometry {
public:
MultiPoint(CoordVec coords) noexcept
: Geometry(GeometryType::MULTIPOINT),
coordinates(std::move(coords)) {}
const CoordVec& getCoordinates() const noexcept { return coordinates; }
protected:
MultiPoint(CoordVec coords, GeometryType type_) noexcept
: Geometry(type_),
coordinates(std::move(coords)) {}
private:
CoordVec coordinates;
};
class LineString : public MultiPoint {
public:
LineString(CoordVec coords) noexcept
: MultiPoint(std::move(coords), GeometryType::LINESTRING) {}
private:
};
class LinearRing : public MultiPoint {
public:
LinearRing(CoordVec coords) noexcept
: MultiPoint(std::move(coords)) {}
private:
};
class MultiLineString : public Geometry {
public:
MultiLineString(std::vector<CoordVec> lineStrings_) noexcept
: Geometry(GeometryType::MULTILINESTRING),
lineStrings(std::move(lineStrings_)) {}
const std::vector<CoordVec>& getLineStrings() const noexcept { return lineStrings; }
private:
std::vector<CoordVec> lineStrings;
};
class Polygon : public Geometry {
public:
using Ring = CoordVec;
using RingVec = std::vector<Ring>;
Polygon(RingVec rings_) noexcept
: Geometry(GeometryType::POLYGON),
rings(std::move(rings_)) {}
const RingVec& getRings() const noexcept { return rings; }
private:
RingVec rings;
};
class MultiPolygon : public Geometry {
public:
using Ring = CoordVec;
using RingVec = std::vector<CoordVec>;
MultiPolygon(std::vector<RingVec> polygons_) noexcept
: Geometry(GeometryType::MULTIPOLYGON),
polygons(std::move(polygons_)) {}
const std::vector<RingVec>& getPolygons() const noexcept { return polygons; }
private:
std::vector<RingVec> polygons;
};
class GeometryFactory {
public:
GeometryFactory() = default;
virtual ~GeometryFactory() = default;
virtual std::unique_ptr<Geometry> createPoint(const Coordinate& coord) const {
return std::make_unique<Point>(coord);
}
virtual std::unique_ptr<Geometry> createMultiPoint(CoordVec&& coords) const {
return std::make_unique<MultiPoint>(std::move(coords));
}
virtual std::unique_ptr<Geometry> createLineString(CoordVec&& coords) const {
return std::make_unique<LineString>(std::move(coords));
}
virtual std::unique_ptr<Geometry> createLinearRing(CoordVec&& coords) const {
return std::make_unique<LineString>(std::move(coords));
}
virtual std::unique_ptr<Geometry> createPolygon(std::vector<CoordVec>&& rings) const {
return std::make_unique<Polygon>(std::move(rings));
}
virtual std::unique_ptr<Geometry> createMultiLineString(std::vector<CoordVec>&& lineStrings) const {
return std::make_unique<MultiLineString>(std::move(lineStrings));
}
virtual std::unique_ptr<Geometry> createMultiPolygon(std::vector<MultiPolygon::RingVec>&& polys) const {
return std::make_unique<MultiPolygon>(std::move(polys));
}
};
} // namespace mlt::geometry
================================================
FILE: cpp/include/mlt/geometry_vector.hpp
================================================
#pragma once
#include <mlt/geometry.hpp>
#include <mlt/util/morton_curve.hpp>
#include <algorithm>
#include <cassert>
namespace mlt::geometry {
struct MortonSettings {
unsigned numBits;
unsigned coordinateShift;
};
enum class VertexBufferType : std::uint32_t {
MORTON,
VEC_2,
VEC_3
};
struct TopologyVector : public util::noncopyable {
TopologyVector(std::vector<std::uint32_t>&& geometryOffsets_,
std::vector<std::uint32_t>&& partOffsets_,
std::vector<std::uint32_t>&& ringOffsets_) noexcept
: geometryOffsets(geometryOffsets_),
partOffsets(partOffsets_),
ringOffsets(ringOffsets_) {}
const std::vector<std::uint32_t>& getGeometryOffsets() const noexcept { return geometryOffsets; }
const std::vector<std::uint32_t>& getPartOffsets() const noexcept { return partOffsets; }
const std::vector<std::uint32_t>& getRingOffsets() const noexcept { return ringOffsets; }
private:
std::vector<std::uint32_t> geometryOffsets;
std::vector<std::uint32_t> partOffsets;
std::vector<std::uint32_t> ringOffsets;
};
struct GeometryVector : public util::noncopyable {
using GeometryType = metadata::tileset::GeometryType;
virtual ~GeometryVector() = default;
std::uint32_t getNumGeometries() const noexcept { return numGeometries; }
bool isSingleGeometryType() const noexcept { return singleType; }
virtual GeometryType getGeometryType(std::size_t index) const noexcept = 0;
virtual bool containsPolygonGeometry() const noexcept = 0;
std::vector<std::unique_ptr<Geometry>> getGeometries(const GeometryFactory&) const;
protected:
GeometryVector(std::uint32_t numGeometries_,
bool singleType_,
std::vector<std::uint32_t>&& indexBuffer_,
std::vector<std::int32_t>&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::vector<std::uint32_t>&& vertexOffsets_,
std::vector<std::uint32_t>&& triangleCounts_,
std::optional<TopologyVector>&& topologyVector_,
std::optional<MortonSettings> mortonSettings_ = {}) noexcept
: numGeometries(numGeometries_),
scale(1.0f),
singleType(singleType_),
indexBuffer(std::move(indexBuffer_)),
vertexBuffer(std::move(vertexBuffer_)),
vertexBufferType(vertexBufferType_),
vertexOffsets(std::move(vertexOffsets_)),
triangleCounts(std::move(triangleCounts_)),
topologyVector(std::move(topologyVector_)),
mortonSettings(mortonSettings_) {}
void applyTriangles(Geometry&,
std::uint32_t& triangleOffset,
std::uint32_t& indexBufferOffset,
std::uint32_t totalVertices,
bool multiPolygon) const;
protected:
std::uint32_t numGeometries;
float scale;
bool singleType;
std::vector<std::uint32_t> indexBuffer;
std::vector<std::int32_t> vertexBuffer;
VertexBufferType vertexBufferType;
std::vector<std::uint32_t> vertexOffsets;
std::vector<std::uint32_t> triangleCounts;
std::optional<TopologyVector> topologyVector;
std::optional<MortonSettings> mortonSettings;
};
struct GpuVector : public GeometryVector {
GpuVector(std::uint32_t numGeometries_,
bool singleType_,
std::vector<std::uint32_t>&& triangleCounts_,
std::vector<std::uint32_t>&& indexBuffer_,
std::vector<std::int32_t>&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional<TopologyVector>&& topologyVector_) noexcept
: GeometryVector(numGeometries_,
singleType_,
std::move(indexBuffer_),
std::move(vertexBuffer_),
vertexBufferType_,
{},
std::move(triangleCounts_),
std::move(topologyVector_)) {}
private:
};
struct ConstGpuVector : public GpuVector {
ConstGpuVector(std::uint32_t numGeometries_,
GeometryType geometryType_,
std::vector<std::uint32_t>&& triangleCounts_,
std::vector<std::uint32_t>&& indexBuffer_,
std::vector<std::int32_t>&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional<TopologyVector>&& topologyVector_) noexcept
: GpuVector(numGeometries_,
/*singleType=*/true,
std::move(triangleCounts_),
std::move(indexBuffer_),
std::move(vertexBuffer_),
vertexBufferType_,
std::move(topologyVector_)),
geometryType(geometryType_) {}
GeometryType getGeometryType(std::size_t) const noexcept override { return geometryType; }
bool containsPolygonGeometry() const noexcept override {
return geometryType == GeometryType::POLYGON || geometryType == GeometryType::MULTIPOLYGON;
}
private:
GeometryType geometryType;
};
struct FlatGpuVector : public GpuVector {
FlatGpuVector(std::vector<GeometryType>&& geometryTypes_,
std::vector<std::uint32_t>&& triangleCounts_,
std::vector<std::uint32_t>&& indexBuffer_,
std::vector<std::int32_t>&& vertexBuffer_,
std::optional<TopologyVector>&& topologyVector_ = {}) noexcept
: GpuVector(static_cast<std::uint32_t>(geometryTypes_.size()),
/*singleType=*/false,
std::move(triangleCounts_),
std::move(indexBuffer_),
std::move(vertexBuffer_),
VertexBufferType::VEC_2,
std::move(topologyVector_)),
geometryTypes(std::move(geometryTypes_)) {}
GeometryType getGeometryType(std::size_t index) const noexcept override {
assert(index < geometryTypes.size());
return geometryTypes[index];
}
bool containsPolygonGeometry() const noexcept override {
// TODO: cache? types can't change
return std::ranges::any_of(geometryTypes, [](const auto type) {
return type == GeometryType::POLYGON || type == GeometryType::MULTIPOLYGON;
});
}
private:
std::vector<GeometryType> geometryTypes;
};
struct CpuVector : public GeometryVector {
CpuVector(std::uint32_t numGeometries_,
bool singleType_,
TopologyVector&& topologyVector_,
std::vector<std::uint32_t>&& vertexOffsets_,
std::vector<std::int32_t>&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional<MortonSettings> mortonSettings_) noexcept
: GeometryVector(numGeometries_,
singleType_,
/*indexBuffer=*/{},
std::move(vertexBuffer_),
vertexBufferType_,
std::move(vertexOffsets_),
{},
std::move(topologyVector_),
mortonSettings_) {}
Coordinate getVertex(std::size_t index) const {
if (!vertexOffsets.empty() && !mortonSettings) {
const auto vertexOffset = vertexOffsets[index] * 2;
return {static_cast<float>(vertexBuffer[vertexOffset]), static_cast<float>(vertexBuffer[vertexOffset + 1])};
}
if (!vertexOffsets.empty() && mortonSettings) {
// TODO: move decoding of the morton codes on the GPU in the vertex shader
const auto vertexOffset = vertexOffsets[index];
const auto mortonEncodedVertex = vertexBuffer[vertexOffset];
// TODO: improve performance -> inline calculation and move to decoding of VertexBuffer
return util::MortonCurve::decode(
mortonEncodedVertex, mortonSettings->numBits, mortonSettings->coordinateShift);
}
return {static_cast<float>(vertexBuffer[2 * index]), static_cast<float>(vertexBuffer[(2 * index) + 1])};
}
};
struct ConstGeometryVector : public CpuVector {
ConstGeometryVector(std::uint32_t numGeometries_,
GeometryType geometryType_,
VertexBufferType vertexBufferType_,
TopologyVector&& topologyVector_,
std::vector<std::uint32_t>&& vertexOffsets_,
std::vector<std::int32_t>&& vertexBuffer_,
std::optional<MortonSettings> mortonSettings_) noexcept
: CpuVector(numGeometries_,
/*singleType=*/true,
std::move(topologyVector_),
std::move(vertexOffsets_),
std::move(vertexBuffer_),
vertexBufferType_,
mortonSettings_),
geometryType(geometryType_) {}
GeometryType getGeometryType(std::size_t) const noexcept override { return geometryType; }
bool containsPolygonGeometry() const noexcept override {
return geometryType == GeometryType::POLYGON || geometryType == GeometryType::MULTIPOLYGON;
}
private:
GeometryType geometryType;
};
struct FlatGeometryVector : public CpuVector {
FlatGeometryVector(std::vector<GeometryType>&& geometryTypes_,
TopologyVector&& topologyVector_,
std::vector<std::uint32_t>&& vertexOffsets_,
std::vector<std::int32_t>&& vertexBuffer_,
VertexBufferType vertexBufferType_,
std::optional<MortonSettings> mortonSettings_) noexcept
: CpuVector(static_cast<std::uint32_t>(geometryTypes_.size()),
/*singleType=*/false,
std::move(topologyVector_),
std::move(vertexOffsets_),
std::move(vertexBuffer_),
vertexBufferType_,
mortonSettings_),
geometryTypes(geometryTypes_) {}
GeometryType getGeometryType(std::size_t index) const noexcept override {
assert(index < geometryTypes.size());
return geometryTypes[index];
}
bool containsPolygonGeometry() const noexcept override {
// TODO: cache? types can't change
return std::ranges::any_of(geometryTypes, [](const auto type) {
return type == GeometryType::POLYGON || type == GeometryType::MULTIPOLYGON;
});
}
private:
std::vector<GeometryType> geometryTypes;
};
} // namespace mlt::geometry
================================================
FILE: cpp/include/mlt/json.hpp
================================================
#pragma once
#include <sstream>
#if MLT_WITH_JSON
#include <mlt/common.hpp>
#include <mlt/coordinate.hpp>
#include <mlt/feature.hpp>
#include <mlt/geometry.hpp>
#include <mlt/layer.hpp>
#include <mlt/projection.hpp>
#include <mlt/tile.hpp>
#include <nlohmann/json.hpp>
#include <cmath>
#include <iterator>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
namespace mlt {
namespace json {
using json = nlohmann::json;
namespace detail {
#pragma region JSON utils
/// Create a json array object with pre-allocated space
inline json buildArray(std::size_t reservedSize) {
json array = json::array();
assert(array.is_array());
array.get_ref<nlohmann::json::array_t&>().reserve(reservedSize);
return array;
}
/// Add to a json array the result of a function applied to each element in a range
template <typename TRange, typename TFunc>
requires requires(TFunc f, typename std::ranges::range_rvalue_reference_t<TRange> v) {
{ f(v) } -> std::same_as<json>;
}
inline json append(TRange sourceRange, json&& array, TFunc transform) {
assert(array.is_array());
std::ranges::transform(
std::forward<TRange>(sourceRange), std::back_inserter(array), std::forward<TFunc>(transform));
return std::move(array);
}
/// Convert a collection range into a json array by applying the given function to each element
template <typename TRange, typename TFunc>
requires requires(TFunc f, typename std::ranges::range_rvalue_reference_t<TRange> v) {
{ f(v) } -> std::same_as<json>;
}
inline json buildArray(TRange sourceRange, TFunc transform) {
return append(sourceRange, buildArray(std::ranges::size(sourceRange)), std::forward<TFunc>(transform));
}
#pragma endregion JSON utils
#pragma region Geometry
/// Build the coordinate representation for a single coordinate that has already been projected
inline json buildProjectedCoordinateArray(const Coordinate& coord) {
return json::array({coord.x, coord.y});
}
/// Build the coordinate representation for a single coordinate
inline json buildCoordinateArray(const Coordinate& coord, const Projection& projection) {
return buildProjectedCoordinateArray(projection.project(coord));
}
/// Build the coordinate representation for a collection of coordinates
inline json buildCoordinatesArray(const CoordVec& coords, const Projection& projection) {
return buildArray(coords, [&](const auto& coord) { return buildCoordinateArray(coord, projection); });
}
/// Build the coordinate representation for a polygon, consisting of the rings concatenated to the shell
inline json buildPolygonCoords(const std::vector<CoordVec>& polyRings, const Projection& projection) {
auto result = buildArray(polyRings.size());
return append(polyRings, std::move(result), [&](const auto& lineString) {
return buildCoordinatesArray(lineString, projection);
});
}
/// Create the value type for the "geometry" entry in a GeoJSON feature with the given coordinate representation
inline json buildGeometryElement(std::string_view type, json&& coords) {
return {
{"type", type},
{"coordinates", std::move(coords)},
};
}
inline json buildGeometryElement(const geometry::Point& point, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return {
{"type", "Point"},
{"coordinates", buildCoordinateArray(point.getCoordinate(), projection)},
};
} else {
std::ostringstream ss;
ss << "POINT (" << point.getCoordinate().x << " " << point.getCoordinate().y << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::LineString& line, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("LineString", buildCoordinatesArray(line.getCoordinates(), projection));
} else {
std::ostringstream ss;
ss << "LINESTRING (";
const auto& coords = line.getCoordinates();
for (std::size_t i = 0, n = coords.size(); i < n; ++i) {
ss << (i == 0 ? "" : ", ") << coords[i].x << " " << coords[i].y;
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::LinearRing& line, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("LineString", buildCoordinatesArray(line.getCoordinates(), projection));
} else {
std::ostringstream ss;
ss << "LINESTRING (";
const auto& coords = line.getCoordinates();
for (std::size_t i = 0; i < coords.size(); ++i) {
ss << (i == 0 ? "" : ", ") << coords[i].x << " " << coords[i].y;
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::MultiPoint& points, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("MultiPoint", buildCoordinatesArray(points.getCoordinates(), projection));
} else {
std::ostringstream ss;
ss << "MULTIPOINT (";
const auto& coords = points.getCoordinates();
for (std::size_t i = 0; i < coords.size(); ++i) {
ss << (i == 0 ? "" : ", ") << "(" << coords[i].x << " " << coords[i].y << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::MultiLineString& mls, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("MultiLineString", buildArray(mls.getLineStrings(), [&](const auto& lineString) {
return buildCoordinatesArray(lineString, projection);
}));
} else {
std::ostringstream ss;
ss << "MULTILINESTRING (";
const auto& lineStrings = mls.getLineStrings();
for (std::size_t i = 0, n = lineStrings.size(); i < n; ++i) {
if (i != 0) {
ss << ", ";
}
ss << "(";
const auto& coords = lineStrings[i];
for (std::size_t j = 0; j < coords.size(); ++j) {
ss << (j == 0 ? "" : ", ") << coords[j].x << " " << coords[j].y;
}
ss << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::Polygon& poly, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("Polygon", buildPolygonCoords(poly.getRings(), projection));
} else {
std::ostringstream ss;
ss << "POLYGON (";
const auto& rings = poly.getRings();
for (std::size_t i = 0, n = rings.size(); i < n; ++i) {
if (i != 0) {
ss << ", ";
}
ss << "(";
const auto& coords = rings[i];
for (std::size_t j = 0; j <= coords.size(); ++j) {
// Wrap around to the first coordinate to close the ring.
// See `getLineStringCoords`
const auto& coord = coords[j % coords.size()];
ss << (j == 0 ? "" : ", ") << coord.x << " " << coord.y;
}
ss << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildGeometryElement(const geometry::MultiPolygon& poly, const Projection& projection, bool geoJSON) {
if (geoJSON) {
return buildGeometryElement("MultiPolygon", buildArray(poly.getPolygons(), [&](const auto& poly) {
return buildPolygonCoords(poly, projection);
}));
} else {
std::ostringstream ss;
ss << "MULTIPOLYGON (";
const auto& polygons = poly.getPolygons();
for (std::size_t i = 0; i < polygons.size(); ++i) {
if (i != 0) {
ss << ", ";
}
ss << "(";
const auto& rings = polygons[i];
for (std::size_t j = 0; j < rings.size(); ++j) {
if (j != 0) {
ss << ", ";
}
ss << "(";
const auto& coords = rings[j];
for (std::size_t k = 0; k <= coords.size(); ++k) {
const auto& coord = coords[k % coords.size()];
ss << (k == 0 ? "" : ", ") << coord.x << " " << coord.y;
}
ss << ")";
}
ss << ")";
}
ss << ")";
return ss.str();
}
}
inline json buildAnyGeometryElement(const geometry::Geometry& geometry, const Projection& projection, bool geoJSON) {
switch (geometry.type) {
case metadata::tileset::GeometryType::POINT:
return buildGeometryElement(static_cast<const geometry::Point&>(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::LINESTRING:
return buildGeometryElement(static_cast<const geometry::LineString&>(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::POLYGON:
return buildGeometryElement(static_cast<const geometry::Polygon&>(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::MULTIPOINT:
return buildGeometryElement(static_cast<const geometry::MultiPoint&>(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::MULTILINESTRING:
return buildGeometryElement(static_cast<const geometry::MultiLineString&>(geometry), projection, geoJSON);
case metadata::tileset::GeometryType::MULTIPOLYGON:
return buildGeometryElement(static_cast<const geometry::MultiPolygon&>(geometry), projection, geoJSON);
default:
throw std::runtime_error("Unsupported geometry type " + std::to_string(std::to_underlying(geometry.type)));
}
}
#pragma endregion Geometry
#pragma region Properties
struct PropertyVisitor {
template <typename T>
std::optional<json> encodeFloatingPoint(T value, std::string_view prefix) const {
if (std::isfinite(value)) {
return json(value);
}
if (std::isnan(value)) {
return json(std::string(prefix) + "::NAN");
}
if (std::signbit(value)) {
return json(std::string(prefix) + "::NEG_INFINITY");
}
return json(std::string(prefix) + "::INFINITY");
}
std::optional<json> operator()(float value) const { return encodeFloatingPoint(value, "f32"); }
std::optional<json> operator()(double value) const { return encodeFloatingPoint(value, "f64"); }
template <typename T>
std::optional<json> operator()(const T& value) const {
return value;
}
};
inline json buildProperties(const Layer& layer, const Feature& feature) {
auto result = json::object();
for (const auto& [key, _] : layer.getProperties()) {
if (const auto property = feature.getProperty(key, layer); property) {
if (auto json = std::visit(PropertyVisitor(), *property); json) {
result[key] = std::move(*json);
}
}
}
return result;
}
#pragma endregion Properties
} // namespace detail
inline json toJSON(const Layer& layer, const Feature& feature, const Projection& projection, bool geoJSON) {
auto result = json{
{"geometry", detail::buildAnyGeometryElement(feature.getGeometry(), projection, geoJSON)},
};
if (const auto id = feature.getID(); id.has_value()) {
result["id"] = *id;
}
if (geoJSON) {
result["type"] = "Feature";
}
if (!layer.getProperties().empty()) {
result["properties"] = detail::buildProperties(layer, feature);
}
return result;
}
inline json toJSON(const Layer& layer, const TileCoordinate& tileCoord, bool geoJSON) {
const auto projection = Projection{layer.getExtent(), tileCoord};
const auto features = std::ranges::views::all(layer.getFeatures());
return {{"name", layer.getName()},
{"extent", layer.getExtent()},
{"features", detail::buildArray(features, [&](const auto& feature) {
return toJSON(layer, feature, projection, geoJSON);
})}};
}
inline json toJSON(const MapLibreTile& tile, const TileCoordinate& tileCoord, bool geoJSON) {
const auto layers = std::ranges::views::all(tile.getLayers());
return {
{"layers", detail::buildArray(layers, [&](const auto& layer) { return toJSON(layer, tileCoord, geoJSON); })},
};
}
} // namespace json
} // namespace mlt
#endif
================================================
FILE: cpp/include/mlt/layer.hpp
================================================
#pragma once
#include <mlt/feature.hpp>
#include <mlt/properties.hpp>
#include <mlt/util/noncopyable.hpp>
#include <vector>
namespace mlt {
namespace geometry {
struct GeometryVector;
}
class Layer : public util::noncopyable {
public:
using extent_t = std::uint32_t;
Layer() = delete;
Layer(std::string name_,
extent_t extent_,
std::unique_ptr<geometry::GeometryVector>&& geometryVector_,
std::vector<Feature> features_,
PropertyVecMap properties_) noexcept;
~Layer();
Layer(Layer&&) noexcept = default;
Layer& operator=(Layer&&) = default;
const std::string& getName() const noexcept { return name; }
extent_t getExtent() const noexcept { return extent; }
const std::vector<Feature>& getFeatures() const noexcept { return features; }
const PropertyVecMap& getProperties() const { return properties; }
private:
std::string name;
extent_t extent;
// Retain the geometry vector because features may reference data from it rather than making copies
std::unique_ptr<geometry::GeometryVector> geometryVector;
std::vector<Feature> features;
PropertyVecMap properties;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/metadata/stream.hpp
================================================
#pragma once
#include <mlt/common.hpp>
#include <mlt/util/buffer_stream.hpp>
#include <mlt/util/noncopyable.hpp>
#include <mlt/util/varint.hpp>
#include <optional>
#include <memory>
namespace mlt::metadata::stream {
enum class DictionaryType : std::uint32_t {
NONE = 0,
SINGLE = 1,
SHARED = 2,
VERTEX = 3,
MORTON = 4,
FSST = 5,
VALUE_COUNT = 6,
};
enum class LengthType : std::uint32_t {
VAR_BINARY = 0,
GEOMETRIES = 1,
PARTS = 2,
RINGS = 3,
TRIANGLES = 4,
SYMBOL = 5,
DICTIONARY = 6,
VALUE_COUNT = 7,
};
enum class PhysicalLevelTechnique : std::uint32_t {
NONE = 0,
/// Preferred, tends to produce the best compression ratio and decoding performance.
/// But currently limited to 32-bit integer.
FAST_PFOR = 1,
/// Can produce better results in combination with a heavyweight compression scheme like Gzip.
/// Simple compression scheme where the decoder are easier to implement compared to FastPfor.
VARINT = 2,
VALUE_COUNT = 3,
};
enum class LogicalLevelTechnique : std::uint32_t {
NONE = 0,
DELTA = 1,
COMPONENTWISE_DELTA = 2,
RLE = 3,
MORTON = 4,
PSEUDODECIMAL = 5,
VALUE_COUNT = 6,
};
enum class OffsetType : std::uint32_t {
VERTEX = 0,
INDEX = 1,
STRING = 2,
KEY = 3,
VALUE_COUNT = 4,
};
enum class PhysicalStreamType : std::uint32_t {
PRESENT = 0,
DATA = 1,
OFFSET = 2,
LENGTH = 3,
VALUE_COUNT = 4,
};
class LogicalStreamType : public util::noncopyable {
public:
LogicalStreamType(DictionaryType type) noexcept
: dictionaryType(type) {}
LogicalStreamType(OffsetType type) noexcept
: offsetType(type) {}
LogicalStreamType(LengthType type) noexcept
: lengthType(type) {}
LogicalStreamType() = delete;
LogicalStreamType(LogicalStreamType&&) noexcept = default;
LogicalStreamType& operator=(LogicalStreamType&&) noexcept = default;
const std::optional<DictionaryType>& getDictionaryType() const noexcept { return dictionaryType; }
const std::optional<OffsetType>& getOffsetType() const noexcept { return offsetType; }
const std::optional<LengthType>& getLengthType() const noexcept { return lengthType; }
private:
std::optional<DictionaryType> dictionaryType;
std::optional<OffsetType> offsetType;
std::optional<LengthType> lengthType;
};
class StreamMetadata : public util::noncopyable {
public:
StreamMetadata() = delete;
StreamMetadata(PhysicalStreamType physicalStreamType_,
std::optional<LogicalStreamType> logicalStreamType_,
LogicalLevelTechnique logicalLevelTechnique1_,
LogicalLevelTechnique logicalLevelTechnique2_,
PhysicalLevelTechnique physicalLevelTechnique_,
std::uint32_t numValues_,
std::uint32_t byteLength_) noexcept
: physicalStreamType(physicalStreamType_),
logicalStreamType(std::move(logicalStreamType_)),
logicalLevelTechnique1(logicalLevelTechnique1_),
logicalLevelTechnique2(logicalLevelTechnique2_),
physicalLevelTechnique(physicalLevelTechnique_),
numValues(numValues_),
byteLength(byteLength_) {}
virtual ~StreamMetadata() noexcept = default;
StreamMetadata(StreamMetadata&&) noexcept = default;
StreamMetadata& operator=(StreamMetadata&&) noexcept = default;
virtual LogicalLevelTechnique getMetadataType() const noexcept { return LogicalLevelTechnique::NONE; }
static std::unique_ptr<StreamMetadata> decode(BufferStream&);
PhysicalStreamType getPhysicalStreamType() const { return physicalStreamType; }
const std::optional<LogicalStreamType>& getLogicalStreamType() const { return logicalStreamType; }
LogicalLevelTechnique getLogicalLevelTechnique1() const { return logicalLevelTechnique1; }
LogicalLevelTechnique getLogicalLevelTechnique2() const { return logicalLevelTechnique2; }
PhysicalLevelTechnique getPhysicalLevelTechnique() const { return physicalLevelTechnique; }
std::uint32_t getNumValues() const noexcept { return numValues; }
std::uint32_t getByteLength() const noexcept { return byteLength; }
private:
int getLogicalType() const noexcept;
friend class RleEncodedStreamMetadata;
friend class MortonEncodedStreamMetadata;
friend std::unique_ptr<StreamMetadata> decode(BufferStream&);
static StreamMetadata decodeInternal(BufferStream&);
PhysicalStreamType physicalStreamType;
std::optional<LogicalStreamType> logicalStreamType;
LogicalLevelTechnique logicalLevelTechnique1;
LogicalLevelTechnique logicalLevelTechnique2;
PhysicalLevelTechnique physicalLevelTechnique;
// After logical Level technique was applied -> when rle is used it is the length of the runs and values array
std::uint32_t numValues;
std::uint32_t byteLength;
};
class RleEncodedStreamMetadata : public StreamMetadata {
public:
/**
* Only used for RLE encoded integer values, not boolean and byte values.
*
* @param numValues After LogicalLevelTechnique was applied -> numRuns + numValues
* @param runs Length of the runs array
* @param numRleValues Used for pre-allocating the arrays on the client for faster decoding
*/
RleEncodedStreamMetadata(PhysicalStreamType physicalStreamType_,
std::optional<LogicalStreamType> logicalStreamType_,
LogicalLevelTechnique logicalLevelTechnique1_,
LogicalLevelTechnique logicalLevelTechnique2_,
PhysicalLevelTechnique physicalLevelTechnique_,
unsigned numValues_,
unsigned byteLength_,
unsigned runs_,
unsigned numRleValues_) noexcept
: StreamMetadata(physicalStreamType_,
std::move(logicalStreamType_),
logicalLevelTechnique1_,
logicalLevelTechnique2_,
physicalLevelTechnique_,
numValues_,
byteLength_),
runs(runs_),
numRleValues(numRleValues_) {}
RleEncodedStreamMetadata(StreamMetadata&& streamMetadata, unsigned runs_, unsigned numRleValues_) noexcept
: StreamMetadata(std::move(streamMetadata)),
runs(runs_),
numRleValues(numRleValues_) {}
RleEncodedStreamMetadata() = delete;
LogicalLevelTechnique getMetadataType() const noexcept override { return LogicalLevelTechnique::RLE; }
static RleEncodedStreamMetadata decodePartial(StreamMetadata&& streamMetadata, BufferStream& tileData) {
const auto [runs, numValues] = util::decoding::decodeVarints<std::uint32_t, 2>(tileData);
return RleEncodedStreamMetadata(std::move(streamMetadata), runs, numValues);
}
static RleEncodedStreamMetadata decode(BufferStream& tileData) {
return decodePartial(decodeInternal(tileData), tileData);
}
unsigned getRuns() const noexcept { return runs; }
unsigned getNumRleValues() const noexcept { return numRleValues; }
private:
unsigned runs;
unsigned numRleValues;
};
class MortonEncodedStreamMetadata : public StreamMetadata {
public:
MortonEncodedStreamMetadata(PhysicalStreamType physicalStreamType_,
LogicalStreamType logicalStreamType_,
LogicalLevelTechnique logicalLevelTechnique1_,
LogicalLevelTechnique logicalLevelTechnique2_,
PhysicalLevelTechnique physicalLevelTechnique_,
unsigned numValues_,
unsigned byteLength_,
unsigned numBits_,
unsigned coordinateShift_) noexcept
: StreamMetadata(physicalStreamType_,
std::move(logicalStreamType_),
logicalLevelTechnique1_,
logicalLevelTechnique2_,
physicalLevelTechnique_,
numValues_,
byteLength_),
numBits(numBits_),
coordinateShift(coordinateShift_) {}
MortonEncodedStreamMetadata(StreamMetadata&& streamMetadata, int numBits_, int coordinateShift_) noexcept
: StreamMetadata(std::move(streamMetadata)),
numBits(numBits_),
coordinateShift(coordinateShift_) {}
LogicalLevelTechnique getMetadataType() const noexcept override { return LogicalLevelTechnique::MORTON; }
static MortonEncodedStreamMetadata decodePartial(StreamMetadata&& streamMetadata, BufferStream& tileData) {
const auto [numBits, coordShift] = util::decoding::decodeVarints<std::uint32_t, 2>(tileData);
return MortonEncodedStreamMetadata(std::move(streamMetadata), numBits, coordShift);
}
static MortonEncodedStreamMetadata decode(BufferStream& tileData) {
return decodePartial(decodeInternal(tileData), tileData);
}
unsigned getNumBits() const noexcept { return numBits; }
unsigned getCoordinateShift() const noexcept { return coordinateShift; }
private:
unsigned numBits;
unsigned coordinateShift;
};
class PdeEncodedMetadata {};
} // namespace mlt::metadata::stream
================================================
FILE: cpp/include/mlt/metadata/tileset.hpp
================================================
#pragma once
#include <cstdint>
#include <optional>
#include <string>
#include <variant>
#include <vector>
namespace mlt {
struct BufferStream;
}
namespace mlt::metadata::tileset {
// See https://maplibre.org/maplibre-tile-spec/specification/
namespace schema {
enum class ColumnScope {
// 1:1 Mapping of property and feature -> id and geometry
FEATURE = 0,
// For M-Values -> 1:1 Mapping for property and vertex
VERTEX = 1,
};
enum class ScalarType {
BOOLEAN = 0,
INT_8 = 1,
UINT_8 = 2,
INT_32 = 3,
UINT_32 = 4,
INT_64 = 5,
UINT_64 = 6,
FLOAT = 7,
DOUBLE = 8,
STRING = 9,
};
enum class ComplexType {
// vec2<Int32> for the VertexBuffer stream with additional information
// (streams) about the topology
GEOMETRY = 0,
// vec3<Int32> for the VertexBuffer stream with additional information
// (streams) about the topology
STRUCT = 1,
};
enum class LogicalScalarType {
// uin32 or 64_t depending on hasLongID
ID = 0,
};
enum class LogicalComplexType {
};
} // namespace schema
using schema::ColumnScope;
using schema::ComplexType;
using schema::LogicalComplexType;
using schema::LogicalScalarType;
using schema::ScalarType;
enum class GeometryType {
POINT = 0,
LINESTRING = 1,
POLYGON = 2,
MULTIPOINT = 3,
MULTILINESTRING = 4,
MULTIPOLYGON = 5,
};
struct ScalarColumn {
std::variant<ScalarType, LogicalScalarType> type;
bool hasLongID = false;
bool hasPhysicalType() const { return std::holds_alternative<ScalarType>(type); }
bool hasLogicalType() const { return std::holds_alternative<LogicalScalarType>(type); }
auto& getPhysicalType() { return std::get<ScalarType>(type); }
auto& getPhysicalType() const { return std::get<ScalarType>(type); }
auto& getLogicalType() { return std::get<LogicalScalarType>(type); }
auto& getLogicalType() const { return std::get<LogicalScalarType>(type); }
bool isID() const { return hasLogicalType() && getLogicalType() == LogicalScalarType::ID; }
};
// The type tree is flattened in to a list via a pre-order traversal.
// Represents a column if it is a root (top-level) type or a child of a nested type.
struct Column;
struct ComplexColumn {
std::variant<ComplexType, LogicalComplexType> type;
// The complex type Geometry and the logical type BINARY have no children
// since there layout is implicit known. RangeMap has only one child
// specifying the type of the value since the key is always a vec2<double>.
std::vector<Column> children;
bool hasChildren() const { return !children.empty(); }
bool hasPhysicalType() const { return std::holds_alternative<ComplexType>(type); }
bool hasLogicalType() const { return std::holds_alternative<LogicalComplexType>(type); }
auto& getPhysicalType() { return std::get<ComplexType>(type); }
auto& getPhysicalType() const { return std::get<ComplexType>(type); }
auto& getLogicalType() { return std::get<LogicalComplexType>(type); }
auto& getLogicalType() const { return std::get<LogicalComplexType>(type); }
bool isGeometry() const { return hasPhysicalType() && getPhysicalType() == ComplexType::GEOMETRY; }
bool isStruct() const { return hasPhysicalType() && getPhysicalType() == ComplexType::STRUCT; }
};
// Column are top-level types in the schema
struct Column {
std::string name;
bool nullable = false;
ColumnScope columnScope = ColumnScope::FEATURE;
std::variant<ScalarColumn, ComplexColumn> type;
bool hasScalarType() const { return std::holds_alternative<ScalarColumn>(type); }
bool hasComplexType() const { return std::holds_alternative<ComplexColumn>(type); }
auto& getScalarType() { return std::get<ScalarColumn>(type); }
auto& getScalarType() const { return std::get<ScalarColumn>(type); }
auto& getComplexType() { return std::get<ComplexColumn>(type); }
auto& getComplexType() const { return std::get<ComplexColumn>(type); }
bool isID() const { return hasScalarType() && getScalarType().isID(); }
bool isGeometry() const { return hasComplexType() && getComplexType().isGeometry(); }
bool isStruct() const { return hasComplexType() && getComplexType().isStruct(); }
};
struct FeatureTable {
std::string name;
std::uint32_t extent;
std::vector<Column> columns;
};
FeatureTable decodeFeatureTable(BufferStream&);
} // namespace mlt::metadata::tileset
================================================
FILE: cpp/include/mlt/metadata/type_map.hpp
================================================
#include <cassert>
#include <cstddef>
#include <optional>
#include <mlt/metadata/tileset.hpp>
namespace mlt::metadata::type_map {
struct Tag0x01 {
using Column = metadata::tileset::Column;
using ScalarColumn = metadata::tileset::ScalarColumn;
using ComplexColumn = metadata::tileset::ComplexColumn;
using ScalarType = metadata::tileset::ScalarType;
using ComplexType = metadata::tileset::ComplexType;
using LogicalScalarType = metadata::tileset::LogicalScalarType;
using LogicalComplexType = metadata::tileset::LogicalComplexType;
/// Produces the unique type encoding for a `Column` or `Field`
static std::optional<std::uint32_t> encodeColumnType(std::optional<ScalarType> physicalScalarType,
std::optional<LogicalScalarType> logicalScalarType,
std::optional<ComplexType> physicalComplexType,
std::optional<LogicalComplexType>,
bool isNullable,
bool hasChildren,
bool hasLongIDs) {
if (physicalScalarType) {
if (!hasChildren) {
return mapScalarType(*physicalScalarType, isNullable);
}
} else if (logicalScalarType) {
if (logicalScalarType == LogicalScalarType::ID) {
return isNullable ? (hasLongIDs ? 3 : 2) : (hasLongIDs ? 1 : 0);
}
} else if (physicalComplexType) {
if (physicalComplexType == ComplexType::GEOMETRY) {
if (!isNullable && !hasChildren) {
return 4;
}
} else if (physicalComplexType == ComplexType::STRUCT) {
if (!isNullable && hasChildren) {
return 30;
}
}
}
return std::nullopt;
}
/// Re-create a `Column` from the unique type code.
/// The inverse of `encodeColumnType`
static std::optional<Column> decodeColumnType(std::uint32_t typeCode) {
using ColumnScope = metadata::tileset::ColumnScope;
switch (typeCode) {
case 0:
case 1:
case 2:
case 3:
return Column{.name = {},
.nullable = (typeCode & 1) != 0,
.columnScope = ColumnScope::FEATURE,
.type = ScalarColumn{.type = LogicalScalarType::ID, .hasLongID = typeCode > 1}};
case 4:
return Column{.name = {},
.nullable = false,
.columnScope = ColumnScope::FEATURE,
.type = ComplexColumn{.type = ComplexType::GEOMETRY, .children = {}}};
case 30:
return Column{.name = {},
.nullable = false,
.columnScope = ColumnScope::FEATURE,
.type = ComplexColumn{.type = ComplexType::STRUCT, .children = {}}};
default:
if (const auto type = mapScalarType(typeCode); type) {
return Column{.name = {},
.nullable = (typeCode & 1) != 0,
.columnScope = ColumnScope::FEATURE,
.type = ScalarColumn{.type = *type}};
}
return std::nullopt;
}
}
static bool columnTypeHasName(std::uint32_t typeCode) { return (10 <= typeCode); }
static bool columnTypeHasChildren(std::uint32_t typeCode) { return (typeCode == 30); }
static bool hasStreamCount(const Column& column) {
if (column.hasScalarType()) {
if (column.getScalarType().hasPhysicalType()) {
switch (column.getScalarType().getPhysicalType()) {
default:
case ScalarType::BOOLEAN:
case ScalarType::INT_8:
case ScalarType::UINT_8:
case ScalarType::INT_32:
case ScalarType::UINT_32:
case ScalarType::INT_64:
case ScalarType::UINT_64:
case ScalarType::FLOAT:
case ScalarType::DOUBLE:
return false;
case ScalarType::STRING:
return true;
};
} else if (column.getScalarType().hasLogicalType()) {
if (column.getScalarType().getLogicalType() == LogicalScalarType::ID) {
return false;
}
}
} else if (column.hasComplexType()) {
if (column.getComplexType().hasPhysicalType()) {
switch (column.getComplexType().getPhysicalType()) {
case ComplexType::GEOMETRY:
case ComplexType::STRUCT:
return true;
default:
break;
}
}
}
// other cases should be impossible
assert(false);
return false;
}
private:
constexpr static std::optional<ScalarType> mapScalarType(std::uint32_t typeCode) {
switch (typeCode) {
case 10:
case 11:
return ScalarType::BOOLEAN;
case 12:
case 13:
return ScalarType::INT_8;
case 14:
case 15:
return ScalarType::UINT_8;
case 16:
case 17:
return ScalarType::INT_32;
case 18:
case 19:
return ScalarType::UINT_32;
case 20:
case 21:
return ScalarType::INT_64;
case 22:
case 23:
return ScalarType::UINT_64;
case 24:
case 25:
return ScalarType::FLOAT;
case 26:
case 27:
return ScalarType::DOUBLE;
case 28:
case 29:
return ScalarType::STRING;
default:
return std::nullopt;
}
}
constexpr static std::optional<std::uint32_t> mapScalarType(ScalarType typeCode, bool isNullable) {
switch (typeCode) {
case ScalarType::BOOLEAN:
return isNullable ? 11 : 10;
case ScalarType::INT_8:
return isNullable ? 13 : 12;
case ScalarType::UINT_8:
return isNullable ? 15 : 14;
case ScalarType::INT_32:
return isNullable ? 17 : 16;
case ScalarType::UINT_32:
return isNullable ? 19 : 18;
case ScalarType::INT_64:
return isNullable ? 21 : 20;
case ScalarType::UINT_64:
return isNullable ? 23 : 22;
case ScalarType::FLOAT:
return isNullable ? 25 : 24;
case ScalarType::DOUBLE:
return isNullable ? 27 : 26;
case ScalarType::STRING:
return isNullable ? 29 : 28;
default:
assert(false);
return std::nullopt;
}
}
};
} // namespace mlt::metadata::type_map
================================================
FILE: cpp/include/mlt/polyfill.hpp
================================================
#pragma once
#include <algorithm>
#include <bit>
#include <ranges> // IWYU pragma: keep - Needed by MSVC
#include <utility>
namespace std {
#if !__has_cpp_attribute(__cpp_lib_to_underlying)
template <typename E>
constexpr auto to_underlying(E e) noexcept {
return static_cast<std::underlying_type_t<E>>(e);
}
#endif
#if !__has_cpp_attribute(__cpp_lib_byteswap)
template <std::integral T>
constexpr T byteswap(T value) noexcept {
static_assert(std::has_unique_object_representations_v<T>, "T may not have padding bits");
auto value_representation = std::bit_cast<std::array<std::byte, sizeof(T)>>(value);
std::ranges::reverse(value_representation);
return std::bit_cast<T>(value_representation);
}
#endif
} // namespace std
================================================
FILE: cpp/include/mlt/projection.hpp
================================================
#pragma once
#include <mlt/coordinate.hpp>
#include <mlt/layer.hpp>
#include <cmath>
#include <cstdint>
#include <numbers>
#include <stdexcept>
namespace mlt {
// Intended to match the results of
// https://github.com/mapbox/vector-tile-js/blob/77851380b63b07fd0af3d5a3f144cc86fb39fdd1/lib/vectortilefeature.js#L129
class Projection {
public:
Projection() = delete;
Projection(const Projection&) noexcept = default;
Projection(Projection&&) noexcept = default;
Projection(Layer::extent_t extent, const TileCoordinate& tile)
: size(extent * (1 << tile.z)),
x0(extent * tile.x),
y0(extent * tile.y),
s1(360.0 / size) {
if (extent == 0) {
throw std::runtime_error("Invalid tile extent");
}
}
Coordinate project(const Coordinate& coord) const noexcept { return {projectX(coord.x), projectY(coord.y)}; }
private:
float projectX(float x) const noexcept { return ((x + x0) * s1) - 180.0f; }
float projectY(float y) const noexcept {
return (2.0f * radToDeg(std::atan(std::exp(degToRad(180.0f - ((y + y0) * s1)))))) - 90.0f;
}
static float degToRad(float deg) noexcept { return deg * std::numbers::pi / 180.0; }
static float radToDeg(float rad) noexcept { return rad * 180 / std::numbers::pi; }
std::uint64_t size;
std::uint64_t x0;
std::uint64_t y0;
double s1;
constexpr static double s2 = 360.0 / std::numbers::pi;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/properties.hpp
================================================
#pragma once
#include <mlt/metadata/tileset.hpp>
#include <mlt/util/packed_bitset.hpp>
#include <mlt/util/noncopyable.hpp>
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
namespace mlt {
/// A block of data and a collection of strings views on it
class StringDictViews : util::noncopyable {
public:
StringDictViews() = default;
StringDictViews(std::vector<std::uint8_t>&& data_, std::vector<std::string_view> views_) noexcept
: data(std::move(data_)),
views(std::move(views_)) {}
StringDictViews(std::shared_ptr<std::vector<std::uint8_t>> data_, std::vector<std::string_view> views_) noexcept
: sharedData(std::move(data_)),
views(std::move(views_)) {}
StringDictViews(StringDictViews&&) noexcept = default;
StringDictViews& operator=(StringDictViews&&) = default;
const auto& getStrings() const noexcept { return views; }
private:
std::vector<std::uint8_t> data;
std::shared_ptr<std::vector<std::uint8_t>> sharedData;
std::vector<std::string_view> views;
};
/// A single feature property.
/// String properties reference the source property vector and must not outlive it.
using Property = std::variant<std::nullptr_t,
bool,
std::optional<bool>,
std::int32_t,
std::optional<std::int32_t>,
std::int64_t,
std::optional<std::int64_t>,
std::uint32_t,
std::optional<std::uint32_t>,
std::uint64_t,
std::optional<std::uint64_t>,
float,
std::optional<float>,
double,
std::optional<double>,
std::string_view>;
/// Map of properties for a single feature
using PropertyMap = std::unordered_map<std::string, Property>;
/// A single property for a column, with one value per feature
using PropertyVec = std::variant<std::vector<std::uint8_t>,
std::vector<std::uint32_t>,
std::vector<std::uint64_t>,
std::vector<std::int32_t>,
std::vector<std::int64_t>,
std::vector<float>,
std::vector<double>,
StringDictViews>;
namespace detail {
struct PropertyCounter {
const bool byteIsBoolean;
template <typename T>
std::size_t operator()(const std::vector<T>& vec) const noexcept {
return vec.size();
}
std::size_t operator()(const std::vector<std::uint8_t>& vec) const noexcept {
// For boolean columns, each bit is a property
return vec.size() * (byteIsBoolean ? 8 : 1);
}
std::size_t operator()(const StringDictViews& views) const noexcept { return views.getStrings().size(); }
};
} // namespace detail
static inline std::size_t propertyCount(const PropertyVec& vec, bool byteIsBoolean) {
return std::visit(detail::PropertyCounter{byteIsBoolean}, vec);
}
/// A column of properties and the present bits for each feature
class PresentProperties : public util::noncopyable {
public:
using ScalarType = metadata::tileset::ScalarType;
PresentProperties() = delete;
PresentProperties(ScalarType type_, PropertyVec properties_, const PackedBitset& present) noexcept;
ScalarType getType() const noexcept { return type; }
bool isBoolean() const noexcept { return type == ScalarType::BOOLEAN; }
const PropertyVec& getProperties() const noexcept { return properties; }
std::size_t getPropertyCount() const { return propertyCount(properties, isBoolean()); }
std::optional<Property> getProperty(std::uint32_t logicalIndex) const;
private:
ScalarType type;
PropertyVec properties;
using ByteIndexVec = std::vector<std::uint8_t>;
using ShortIndexVec = std::vector<std::uint16_t>;
using IntIndexVec = std::vector<std::uint32_t>;
std::variant<std::monostate, ByteIndexVec, ShortIndexVec, IntIndexVec> physicalIndexes;
};
/// All the property columns for a layer
using PropertyVecMap = std::unordered_map<std::string, PresentProperties>;
} // namespace mlt
================================================
FILE: cpp/include/mlt/tile.hpp
================================================
#pragma once
#include <mlt/layer.hpp>
#include <mlt/util/noncopyable.hpp>
#include <vector>
namespace mlt {
class MapLibreTile : public util::noncopyable {
public:
MapLibreTile() = delete;
MapLibreTile(std::vector<Layer> layers_) noexcept
: layers(std::move(layers_)) {}
MapLibreTile(MapLibreTile&&) noexcept = default;
MapLibreTile& operator=(MapLibreTile&&) noexcept = default;
const std::vector<Layer>& getLayers() const noexcept { return layers; }
const Layer* getLayer(const std::string_view& name) const noexcept {
auto hit = std::ranges::find_if(layers, [&](const auto& layer) { return layer.getName() == name; });
return (hit != layers.end()) ? &*hit : nullptr;
}
private:
std::vector<Layer> layers;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/util/buffer_stream.hpp
================================================
#pragma once
#include <mlt/common.hpp>
#include <mlt/util/noncopyable.hpp>
#include <cstdint>
#include <cstring>
#include <stdexcept>
namespace mlt {
struct BufferStream : public util::noncopyable {
BufferStream() = delete;
BufferStream(DataView data_) noexcept
: data(std::move(data_)),
offset(0) {}
BufferStream(BufferStream&&) = delete;
BufferStream& operator=(BufferStream&&) = delete;
auto getSize() const noexcept { return data.size(); }
auto getOffset() const noexcept { return offset; }
auto getRemaining() const noexcept { return data.size() - offset; }
bool available(std::size_t size = 1) const noexcept { return size <= getRemaining(); }
/// Get another DataView representing a portion of the remaining data
BufferStream getSubStream(std::size_t offset, std::size_t length) const {
const auto remaining = getRemaining();
if (offset + length > remaining) {
throw std::runtime_error("Substream exceeds buffer size");
}
return {{getReadPosition<DataView::value_type>() + offset, length}};
}
void reset() { offset = 0; }
void reset(DataView data_) {
data = std::move(data_);
offset = 0;
}
template <typename T = std::uint8_t>
const T* getData() const noexcept {
return reinterpret_cast<const T*>(data.data());
}
template <typename T = std::uint8_t>
const T* getReadPosition() const noexcept {
return reinterpret_cast<const T*>(&data[offset]);
}
template <typename T = std::uint8_t>
DataView::value_type read() {
check(sizeof(T));
const T* p = getReadPosition<T>();
consume(sizeof(T));
return static_cast<DataView::value_type>(*p);
}
void read(void* buffer, std::size_t size) {
check(size);
std::memcpy(buffer, getReadPosition(), size);
consume(size);
}
template <typename T = std::uint8_t>
DataView::value_type peek() const {
check(sizeof(T));
return *getReadPosition<T>();
}
void consume(std::size_t count) {
check(count);
offset += count;
}
private:
void check(std::size_t count) const {
if (!available(count)) {
throw std::runtime_error("Unexpected end of buffer");
}
}
DataView data;
std::size_t offset;
};
} // namespace mlt
================================================
FILE: cpp/include/mlt/util/noncopyable.hpp
================================================
#pragma once
namespace mlt::util {
class noncopyable {
public:
noncopyable(noncopyable&) = delete;
noncopyable(noncopyable&&) = default;
noncopyable& operator=(const noncopyable&) = delete;
noncopyable& operator=(noncopyable&&) noexcept = default;
protected:
constexpr noncopyable() noexcept = default;
~noncopyable() noexcept = default;
};
} // namespace mlt::util
================================================
FILE: cpp/include/mlt/util/packed_bitset.hpp
================================================
#pragma once
#include <bit>
#include <cassert>
#include <cstdint>
#include <numeric>
#include <optional>
#include <vector>
namespace mlt {
// `std::vector<bool>` is not great, just use a vector of bytes
using PackedBitset = std::vector<std::uint8_t>;
/// Test a specific bit
static inline bool testBit(const PackedBitset& bitset, std::size_t i) noexcept {
return ((i / 8) < bitset.size()) && (bitset[i / 8] & (1 << (i % 8)));
}
/// Get the total number of bits set
static inline std::size_t countSetBits(const PackedBitset& bitset) {
// NOLINTNEXTLINE(boost-use-ranges)
return std::accumulate(
bitset.begin(), bitset.end(), static_cast<std::size_t>(0), [](const auto total, const auto byte) {
return total + static_cast<unsigned>(std::popcount(byte));
});
}
/// Return the index of the next set bit within the bitstream
/// @param bits The bitset
/// @param afterIndex The bit index to start with
/// @return The index of the next set bit (including the starting index)
static inline std::optional<std::size_t> nextSetBit(const PackedBitset& bits,
const std::size_t afterIndex = 0) noexcept {
if (std::size_t byteIndex = (afterIndex / 8); byteIndex < bits.size()) {
auto byte = bits[byteIndex];
// If we're mid-byte, shift it down so the next bit is in the 1 position
std::size_t result = afterIndex;
if (const auto partialBits = result & 7; partialBits) {
byte >>= partialBits;
if (!byte) {
// skip to the next byte
if (++byteIndex == bits.size()) {
return {};
}
result += (8 - partialBits);
byte = bits[byteIndex];
}
}
while (byteIndex < bits.size()) {
// If this byte is non-zero, the next bit is within it
if (byte) {
const auto ffs = std::countr_zero(byte);
return result + ffs;
}
// Continue to the next byte
if (++byteIndex < bits.size()) {
byte = bits[byteIndex];
result += 8;
}
}
}
return {};
}
} // namespace mlt
================================================
FILE: cpp/include/mlt/util/stl.hpp
================================================
#pragma once
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <vector>
namespace mlt::util {
/// Create a vector of N items by invoking the given function N times
template <typename T, typename F, typename I = std::size_t>
requires requires(F f, I i) {
{ f(i) } -> std::same_as<T>;
}
std::vector<T> generateVector(const std::size_t count, F generator) {
std::vector<T> result;
result.reserve(count);
std::generate_n(
std::back_inserter(result), count, [i = I{0}, f = std::move(generator)]() mutable { return f(i++); });
return result;
}
// Helper for using lambdas with `std::variant`
// See https://en.cppreference.com/w/cpp/utility/variant/visit
template <class... Ts>
struct overloaded : Ts... {
using Ts::operator()...;
};
// explicit deduction guide (not needed as of C++20)
// (but seems to be needed by MSVC)
template <class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;
} // namespace mlt::util
================================================
FILE: cpp/include/mlt/util/varint.hpp
================================================
#pragma once
#include <mlt/common.hpp>
#include <mlt/util/buffer_stream.hpp>
#include <stdexcept>
#include <type_traits>
namespace mlt::util::decoding {
/// Returns the size of the varint encoding for a given value.
/// Equivalent to `max(1,ceil(log128(value)))`
template <typename T = std::uint32_t>
std::size_t getVarintSize(T value) {
return std::max<std::size_t>(1, ((8 * sizeof(value)) - std::countl_zero(value) + 6) / 7);
}
template <typename T>
requires(std::is_integral_v<T>)
T decodeVarint(BufferStream&);
// allow decoding directly to enum types
template <typename T>
requires(std::is_enum_v<T>)
T decodeVarint(BufferStream& tileData) {
return static_cast<T>(decodeVarint<std::make_unsigned_t<std::underlying_type_t<T>>>(tileData));
}
template <>
inline std::uint32_t decodeVarint(BufferStream& buffer) {
// Max 4 bytes supported
auto b = buffer.read<std::uint8_t>();
auto value = static_cast<std::uint32_t>(b & 0x7f);
if (b & 0x80) {
b = buffer.read<std::uint8_t>();
value |= static_cast<std::uint32_t>(b & 0x7f) << 7;
if (b & 0x80) {
b = buffer.read<std::uint8_t>();
value |= static_cast<std::uint32_t>(b & 0x7f) << 14;
if (b & 0x80) {
b = buffer.read<std::uint8_t>();
value |= static_cast<std::uint32_t>(b & 0x7f) << 21;
if (b & 0x80) {
const auto v = static_cast<std::uint32_t>(buffer.read<std::uint8_t>() & 0x7f);
if (v > 0x0f) {
throw std::runtime_error("varint exceeds 32 bits");
}
value |= v << 28;
}
}
}
}
return value;
}
template <>
inline std::uint64_t decodeVarint(BufferStream& buffer) {
std::uint64_t value = 0;
for (int shift = 0; buffer.available();) {
auto b = buffer.read<std::uint8_t>();
value |= static_cast<std::uint64_t>(b & 0x7F) << shift;
if (shift == 63 && b > 1) {
throw std::runtime_error("Varint too long");
}
if ((b & 0x80) == 0) {
break;
}
shift += 7;
if (shift >= 64) {
throw std::runtime_error("Varint too long");
}
}
return value;
}
/// Decode N varints, retrurning the values in a `std::tuple`
template <typename T, std::size_t N>
requires(std::is_integral_v<T> || std::is_enum_v<T>, 0 < N)
auto decodeVarints(BufferStream& buffer) {
auto v = std::make_tuple(static_cast<T>(decodeVarint<std::uint32_t>(buffer)));
if constexpr (N == 1) {
return v;
} else
return std::tuple_cat(std::move(v), decodeVarints<T, N - 1>(buffer));
}
/// Decode N varints into the provided buffer
/// Each result is cast to the target type.
template <typename TDecode, typename TTarget = TDecode>
requires(std::is_integral_v<TDecode> && (std::is_integral_v<TTarget> || std::is_enum_v<TTarget>) &&
sizeof(TDecode) <= sizeof(TTarget))
void decodeVarints(BufferStream& buffer, const std::uint32_t numValues, TTarget* out) {
std::generate_n(out, numValues, [&buffer]() { return static_cast<TTarget>(decodeVarint<TDecode>(buffer)); });
}
} // namespace mlt::util::decoding
================================================
FILE: cpp/mod.just
================================================
just := quote(just_executable())
_default: (just '--list' 'cpp')
[private]
just *args:
{{just}} {{args}}
# Initialize CMake build
cmake-init:
cmake -B build -S . -DCMAKE_BUILD_TYPE=Coverage
# Build with CMake
cmake-build: cmake-init
cmake --build build --target mlt-cpp-test mlt-cpp-json
# Quick compile check (CMake build)
check: cmake-build
# Run all CI steps: test, coverage, bazel build
ci-test: coverage bazel-build
{{just}} assert-git-is-clean
# Delete build artifacts
clean:
rm -rf build
# Reformat code
fmt:
pre-commit run --all-files clang-format
# Run linting
lint:
echo "TODO: Add C++ linting command"
_install_npm_deps:
cd ../test/synthetic/synthetic-test-utils && npm ci
npm ci
_test-synthetic: _install_npm_deps
{{just}} ts install
npx vitest run tool/synthetic.test.ts
# Run tests
[working-directory: 'build']
test: _clean_coverage_data cmake-build _test-synthetic
ctest
_clean_coverage_data:
find . -name "*.gcda" -delete
# Generate coverage report
[working-directory: 'build']
coverage: _clean_coverage_data (_check-tool 'gcovr') test
gcovr --root ../.. \
--filter ../src --filter ../include \
--txt coverage.txt \
--merge-mode-functions=separate \
--cobertura-pretty --cobertura coverage.xml \
--html-details coverage.html
@echo "Coverage report at $PWD/coverage.html"
# Build with Bazel
bazel-build:
bazel build //cpp:mlt_cpp
# Sanity test for mlt-cpp-json tool
test-json:
build/tool/mlt-cpp-json ../test/expected/tag0x01/bing/4-12-6.mlt | jq . >/dev/null
_check-tool command:
@which {{command}} > /dev/null || (echo "Error: {{command}} is not installed. Please install it using: brew install {{command}} (macOS) or pip3 install {{command}} (Linux)" && exit 1)
================================================
FILE: cpp/package.json
================================================
{
"type": "module",
"dependencies": {
"synthetic-test-utils": "file:../test/synthetic/synthetic-test-utils",
"vitest": "^4.0.18"
}
}
================================================
FILE: cpp/src/mlt/decode/geometry.hpp
================================================
#pragma once
#include <mlt/decode/int.hpp>
#include <mlt/feature.hpp>
#include <mlt/geometry.hpp>
#include <mlt/geometry_vector.hpp>
#include <mlt/metadata/stream.hpp>
#include <mlt/metadata/tileset.hpp>
#include <mlt/util/buffer_stream.hpp>
#include <mlt/util/noncopyable.hpp>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
namespace mlt::decoder {
class GeometryDecoder {
public:
using GeometryVector = geometry::GeometryVector;
GeometryDecoder(IntegerDecoder& intDecoder)
: intDecoder(intDecoder) {}
private:
enum class VectorType : std::uint32_t {
FLAT,
CONST,
SEQUENCE,
DICTIONARY,
FSST_DICTIONARY,
};
VectorType getVectorTypeIntStream(const metadata::stream::StreamMetadata& streamMetadata) {
using namespace metadata::stream;
const auto logicalLevelTechnique1 = streamMetadata.getLogicalLevelTechnique1();
const auto logicalLevelTechnique2 = streamMetadata.getLogicalLevelTechnique2();
const auto metadataType = streamMetadata.getMetadataType();
const auto& rleMetadata = static_cast<const RleEncodedStreamMetadata&>(streamMetadata);
const auto rleRuns = (metadataType == LogicalLevelTechnique::RLE) ? rleMetadata.getRuns() : 0;
if (logicalLevelTechnique1 == LogicalLevelTechnique::RLE) {
assert(metadataType == LogicalLevelTechnique::RLE);
return (rleRuns == 1) ? VectorType::CONST : VectorType::FLAT;
} else if (logicalLevelTechnique1 == LogicalLevelTechnique::DELTA &&
logicalLevelTechnique2 == LogicalLevelTechnique::RLE) {
assert(metadataType == LogicalLevelTechnique::RLE);
// If base value equals delta value then one run else two runs
if (rleRuns == 1 || rleRuns == 2) {
return VectorType::SEQUENCE;
}
}
return (streamMetadata.getNumValues() == 1) ? VectorType::CONST : VectorType::FLAT;
}
public:
std::unique_ptr<GeometryVector> decodeGeometryColumn(BufferStream& tileData,
const metadata::tileset::Column& column,
std::uint32_t numStreams) {
using namespace util::decoding;
using namespace metadata::stream;
using namespace metadata::tileset;
std::vector<GeometryType> geometryTypes;
std::vector<std::uint32_t> geometryOffsets;
std::vector<std::uint32_t> partOffsets;
std::vector<std::uint32_t> ringOffsets;
std::vector<std::uint32_t> vertexOffsets;
std::vector<std::uint32_t> indexBuffer;
std::vector<std::uint32_t> triangles;
std::vector<std::int32_t> vertices;
const auto geomTypeMetadata = StreamMetadata::decode(tileData);
if (!geomTypeMetadata) {
throw std::runtime_error("geometry column missing metadata stream: " + column.name);
}
[[maybe_unused]] const auto geometryTypesVectorType = getVectorTypeIntStream(*geomTypeMetadata);
// If all geometries in the column have the same geometry type, we could decode them
// somewhat more efficiently, and return the geometry in a more GPU-friendly form.
// if (geometryTypesVectorType == VectorType::CONST) {
// const auto geomType = intDecoder.decodeConstIntStream<std::uint32_t, std::uint32_t, GeometryType>(
// tileData, *geomTypeMetadata);
// ...
// }
// Different geometry types are mixed in the geometry column
intDecoder.decodeIntStream<std::uint32_t, std::uint32_t, GeometryType>(
tileData, geometryTypes, *geomTypeMetadata);
std::optional<geometry::MortonSettings> mortonSettings;
for (std::uint32_t i = 1; i < numStreams; ++i) {
const auto geomStreamMetadata = StreamMetadata::decode(tileData);
switch (geomStreamMetadata->getPhysicalStreamType()) {
case PhysicalStreamType::LENGTH: {
if (!geomStreamMetadata->getLogicalStreamType() ||
!geomStreamMetadata->getLogicalStreamType()->getLengthType()) {
throw std::runtime_error("Length stream missing logical type: " + column.name);
}
const auto type = *geomStreamMetadata->getLogicalStreamType()->getLengthType();
std::optional<std::reference_wrapper<std::vector<std::uint32_t>>> target;
switch (type) {
case LengthType::GEOMETRIES:
target = geometryOffsets;
break;
case LengthType::PARTS:
target = partOffsets;
break;
case LengthType::RINGS:
target = ringOffsets;
break;
case LengthType::TRIANGLES:
target = triangles;
break;
default:
throw std::runtime_error("Length stream type '" + std::to_string(std::to_underlying(type)) +
" not implemented: " + column.name);
}
intDecoder.decodeIntStream<std::uint32_t, std::uint32_t, std::uint32_t>(
tileData, target->get(), *geomStreamMetadata);
break;
}
case PhysicalStreamType::OFFSET: {
if (!geomStreamMetadata->getLogicalStreamType() ||
!geomStreamMetadata->getLogicalStreamType()->getOffsetType()) {
throw std::runtime_error("Offset stream missing type: " + column.name);
}
const auto type = *geomStreamMetadata->getLogicalStreamType()->getOffsetType();
std::optional<std::reference_wrapper<std::vector<std::uint32_t>>> target;
switch (type) {
case OffsetType::VERTEX:
target = vertexOffsets;
break;
case OffsetType::INDEX:
target = indexBuffer;
break;
default:
throw std::runtime_error("Offset stream type '" + std::to_string(std::to_underlying(type)) +
" not implemented: " + column.name);
}
intDecoder.decodeIntStream<std::uint32_t>(tileData, target->get(), *geomStreamMetadata);
break;
}
case PhysicalStreamType::DATA: {
if (!geomStreamMetadata->getLogicalStreamType() ||
!geomStreamMetadata->getLogicalStreamType()->getDictionaryType()) {
throw std::runtime_error("Data stream missing dictionary type: " + column.name);
}
if (mortonSettings) {
throw std::runtime_error("multiple data streams");
}
const auto type = *geomStreamMetadata->getLogicalStreamType()->getDictionaryType();
switch (type) {
case DictionaryType::VERTEX:
switch (geomStreamMetadata->getPhysicalLevelTechnique()) {
case PhysicalLevelTechnique::NONE:
case PhysicalLevelTechnique::VARINT:
case PhysicalLevelTechnique::FAST_PFOR:
intDecoder.decodeIntStream<std::uint32_t, std::uint32_t, std::int32_t>(
tileData, vertices, *geomStreamMetadata, /*isSigned=*/true);
break;
default:
throw std::runtime_error("Unsupported encoding " +
std::to_string(std::to_underlying(
geomStreamMetadata->getPhysicalLevelTechnique())) +
" for geometries: " + column.name);
};
break;
case DictionaryType::MORTON: {
assert(geomStreamMetadata->getMetadataType() == LogicalLevelTechnique::MORTON);
const auto& mortonStreamMetadata = static_cast<const MortonEncodedStreamMetadata&>(
*geomStreamMetadata);
// TODO: This results in double-morton-decoding, need to align with TypeScript
// implementation. mortonSettings = geometry::MortonSettings{
// .numBits = mortonStreamMetadata.getNumBits(),
// .coordinateShift = mortonStreamMetadata.getCoordinateShift()};
intDecoder.decodeMortonStream<std::uint32_t, std::int32_t>(
tileData, vertices, mortonStreamMetadata);
break;
}
default:
throw std::runtime_error("Dictionary type '" + std::to_string(std::to_underlying(type)) +
"' not implemented: " + column.name);
}
break;
}
case PhysicalStreamType::PRESENT:
break;
default:
throw std::runtime_error("Unsupported logical stream type: " + column.name);
}
}
if (!indexBuffer.empty() && partOffsets.empty()) {
/* Case when the indices of a Polygon outline are not encoded in the data so no
* topology data are present in the tile */
return std::make_unique<geometry::FlatGpuVector>(
std::move(geometryTypes), std::move(triangles), std::move(indexBuffer), std::move(vertices));
}
if (!geometryOffsets.empty()) {
auto geometryOffsetsCopy = geometryOffsets; // TODO: avoid copies
decodeRootLengthStream(geometryTypes,
geometryOffsetsCopy,
/*bufferId=*/GeometryType::POLYGON,
geometryOffsets);
if (!partOffsets.empty()) {
if (!ringOffsets.empty()) {
auto partOffsetsCopy = partOffsets;
decodeLevel1LengthStream(geometryTypes,
geometryOffsets,
partOffsetsCopy,
/*isLineStringPresent=*/false,
partOffsets);
auto ringOffsetsCopy = ringOffsets;
decodeLevel2LengthStream(geometryTypes, geometryOffsets, partOffsets, ringOffsetsCopy, ringOffsets);
} else {
auto partOffsetsCopy = partOffsets;
decodeLevel1WithoutRingBufferLengthStream(
geometryTypes, geometryOffsets, partOffsetsCopy, partOffsets);
}
}
} else if (!partOffsets.empty()) {
auto partOffsetsCopy = partOffsets;
if (!ringOffsets.empty()) {
auto ringOffsetsCopy = ringOffsets;
decodeRootLengthStream(geometryTypes, partOffsetsCopy, GeometryType::LINESTRING, partOffsets);
decodeLevel1LengthStream(geometryTypes,
partOffsets,
ringOffsetsCopy,
/*isLineStringPresent=*/true,
ringOffsets);
} else {
decodeRootLengthStream(geometryTypes, partOffsetsCopy, GeometryType::POINT, partOffsets);
}
}
if (!indexBuffer.empty()) {
/* Case when the indices of a Polygon outline are encoded in the tile */
return std::make_unique<geometry::FlatGpuVector>(
std::move(geometryTypes),
std::move(triangles),
std::move(indexBuffer),
std::move(vertices),
geometry::TopologyVector(std::move(geometryOffsets), std::move(partOffsets), std::move(ringOffsets)));
}
return std::make_unique<geometry::FlatGeometryVector>(
std::move(geometryTypes),
geometry::TopologyVector(std::move(geometryOffsets), std::move(partOffsets), std::move(ringOffsets)),
std::move(vertexOffsets),
std::move(vertices),
mortonSettings ? geometry::VertexBufferType::MORTON : geometry::VertexBufferType::VEC_2,
mortonSettings);
}
/*
* Handle the parsing of the different topology length buffers separate not generic to reduce the
* branching and improve the performance
*/
void decodeRootLengthStream(const std::vector<metadata::tileset::GeometryType>& geometryTypes,
const std::vector<std::uint32_t>& rootLengthStream,
const metadata::tileset::GeometryType bufferId,
std::vector<std::uint32_t>& rootBufferOffsets) {
assert(&rootLengthStream != &rootBufferOffsets);
rootBufferOffsets.resize(geometryTypes.size() + 1);
std::uint32_t previousOffset = rootBufferOffsets[0] = 0;
std::uint32_t rootLengthCounter = 0;
for (std::size_t i = 0; i < geometryTypes.size(); ++i) {
/* Test if the geometry has and entry in the root buffer
* BufferId: 2 GeometryOffsets -> MultiPolygon, MultiLineString, MultiPoint
* BufferId: 1 PartOffsets -> Polygon
* BufferId: 0 PartOffsets, RingOffsets -> LineString
* */
previousOffset = rootBufferOffsets[i + 1] = previousOffset + ((geometryTypes[i] > bufferId)
? rootLengthStream[rootLengthCounter++]
: 1);
}
}
void decodeLevel1LengthStream(const std::vector<metadata::tileset::GeometryType>& geometryTypes,
const std::vector<std::uint32_t>& rootOffsetBuffer,
const std::vector<std::uint32_t>& level1LengthBuffer,
const bool isLineStringPresent,
std::vector<std::uint32_t>& level1BufferOffsets) {
assert(&rootOffsetBuffer != &level1BufferOffsets);
assert(&level1LengthBuffer != &level1BufferOffsets);
using metadata::tileset::GeometryType;
level1BufferOffsets.resize(rootOffsetBuffer[rootOffsetBuffer.size() - 1] + 1);
std::uint32_t previousOffset = level1BufferOffsets[0] = 0;
std::uint32_t level1BufferCounter = 1;
std::uint32_t level1LengthBufferCounter = 0;
for (std::size_t i = 0; i < geometryTypes.size(); ++i) {
const auto geometryType = geometryTypes[i];
const auto numGeometries = rootOffsetBuffer[i + 1] - rootOffsetBuffer[i];
if (geometryType == GeometryType::MULTIPOLYGON || geometryType == GeometryType::POLYGON ||
(isLineStringPresent &&
(geometryType == GeometryType::MULTILINESTRING || geometryType == GeometryType::LINESTRING))) {
/* For MultiPolygon, Polygon and in some cases for MultiLineString and LineString
* a value in the level1LengthBuffer exists */
for (std::uint32_t j = 0; j < numGeometries; ++j) {
previousOffset = level1BufferOffsets[level1BufferCounter++] =
previousOffset + level1LengthBuffer[level1LengthBufferCounter++];
}
} else {
/* For MultiPoint and Point and in some cases for MultiLineString and LineString no value in the
* level1LengthBuffer exists */
for (std::uint32_t j = 0; j < numGeometries; j++) {
level1BufferOffsets[level1BufferCounter++] = ++previousOffset;
}
}
}
}
/*
* Case where no ring buffer exists so no MultiPolygon or Polygon geometry is part of the buffer
*/
void decodeLevel1WithoutRingBufferLengthStream(const std::vector<metadata::tileset::GeometryType>& geometryTypes,
const std::vector<std::uint32_t>& rootOffsetBuffer,
const std::vector<std::uint32_t>& level1LengthBuffer,
std::vector<std::uint32_t>& level1BufferOffsets) {
assert(&rootOffsetBuffer != &level1BufferOffsets);
assert(&level1LengthBuffer != &level1BufferOffsets);
using metadata::tileset::GeometryType;
level1BufferOffsets.resize(rootOffsetBuffer[rootOffsetBuffer.size() - 1] + 1);
std::uint32_t previousOffset = level1BufferOffsets[0] = 0;
std::uint32_t level1OffsetBufferCounter = 1;
std::uint32_t level1LengthCounter = 0;
for (std::size_t i = 0; i < geometryTypes.size(); ++i) {
const auto geometryType = geometryTypes[i];
const auto numGeometries = rootOffsetBuffer[i + 1] - rootOffsetBuffer[i];
if (geometryType == GeometryType::MULTILINESTRING || geometryType == GeometryType::LINESTRING) {
/* For MultiLineString and LineString a value in the level1LengthBuffer exists */
for (std::uint32_t j = 0; j < numGeometries; ++j) {
previousOffset = level1BufferOffsets[level1OffsetBufferCounter++] =
previousOffset + level1LengthBuffer[level1LengthCounter++];
}
} else {
/* For MultiPoint and Point no value in level1LengthBuffer exists */
for (std::uint32_t j = 0; j < numGeometries; ++j) {
level1BufferOffsets[level1OffsetBufferCounter++] = ++previousOffset;
}
}
}
}
void decodeLevel2LengthStream(const std::vector<metadata::tileset::GeometryType>& geometryTypes,
const std::vector<std::uint32_t>& rootOffsetBuffer,
const std::vector<std::uint32_t>& level1OffsetBuffer,
const std::vector<std::uint32_t>& level2LengthBuffer,
std::vector<std::uint32_t>& level2BufferOffsets) {
assert(&rootOffsetBuffer != &level2BufferOffsets);
assert(&level1OffsetBuffer != &level2BufferOffsets);
assert(&level2LengthBuffer != &level2BufferOffsets);
using metadata::tileset::GeometryType;
level2BufferOffsets.resize(level1OffsetBuffer[level1OffsetBuffer.size() - 1] + 1);
std::uint32_t previousOffset = level2BufferOffsets[0] = 0;
std::uint32_t level1OffsetBufferCounter = 1;
std::uint32_t level2OffsetBufferCounter = 1;
std::uint32_t level2LengthBufferCounter = 0;
for (std::size_t i = 0; i < geometryTypes.size(); ++i) {
const auto geometryType = geometryTypes[i];
const auto numGeometries = rootOffsetBuffer[i + 1] - rootOffsetBuffer[i];
if (geometryType != GeometryType::POINT && geometryType != GeometryType::MULTIPOINT) {
/* For MultiPolygon, MultiLineString, Polygon and LineString a value in level2LengthBuffer
* exists */
for (std::uint32_t j = 0; j < numGeometries; ++j) {
const auto numParts = level1OffsetBuffer[level1OffsetBufferCounter] -
level1OffsetBuffer[level1OffsetBufferCounter - 1];
level1OffsetBufferCounter++;
for (std::uint32_t k = 0; k < numParts; ++k) {
previousOffset = level2BufferOffsets[level2OffsetBufferCounter++] =
previousOffset + level2LengthBuffer[level2LengthBufferCounter++];
}
}
} else {
/* For MultiPoint and Point no value in level2LengthBuffer exists */
for (std::uint32_t j = 0; j < numGeometries; j++) {
level2BufferOffsets[level2OffsetBufferCounter++] = ++previousOffset;
level1OffsetBufferCounter++;
}
}
}
}
private:
IntegerDecoder& intDecoder;
};
} // namespace mlt::decoder
================================================
FILE: cpp/src/mlt/decode/int.cpp
================================================
#include <algorithm>
#include <mlt/decode/int.hpp>
#include <mlt/decode/int_template.hpp>
// from fastpfor/...
#if MLT_WITH_FASTPFOR
#include <compositecodec.h>
#include <fastpfor.h>
#include <variablebyte.h>
#endif // MLT_WITH_FASTPFOR
#include <cstdint>
#ifdef _MSC_VER
#include <array>
#include <bitset>
#include <intrin.h>
#endif
namespace mlt::decoder {
struct IntegerDecoder::Impl {
#if MLT_WITH_FASTPFOR
// Impl pattern to prevent FastPFOR from being an API dependency
FastPForLib::CompositeCodec<FastPForLib::FastPFor<8>, FastPForLib::VariableByte> codec;
#endif // MLT_WITH_FASTPFOR
};
IntegerDecoder::IntegerDecoder([[maybe_unused]] bool enableFastPFOR)
: impl(std::make_unique<Impl>())
#if MLT_WITH_FASTPFOR
,
enableFastPFOR(enableFastPFOR)
#endif
{
}
IntegerDecoder::~IntegerDecoder() noexcept = default;
std::uint32_t IntegerDecoder::decodeFastPfor([[maybe_unused]] BufferStream& buffer,
[[maybe_unused]] std::uint32_t* const result,
[[maybe_unused]] const std::size_t numValues,
[[maybe_unused]] const std::size_t byteLength) {
#if MLT_WITH_FASTPFOR
if (enableFastPFOR) {
#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_IA64) || defined(_M_AMD64))
#if defined(__GNUC__) || defined(__clang__)
// https://gcc.gnu.org/onlinedocs/gcc/x86-Built-in-Functions.html
if (!__builtin_cpu_supports("sse4.1")) {
// The x86 implementation in FastPFOR requires SSE4.1
throw std::runtime_error("FastPFOR decoding requires SSE4.1 on x86 platforms");
}
#elif defined(_MSC_VER)
// https://learn.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
{
int cpui[4];
__cpuid(cpui, 0);
cpui[2] = 0;
if (cpui[0] > 0) {
__cpuidex(cpui, 1, 0);
}
if (const std::bitset<32> fn1ECX = cpui[2]; !fn1ECX[19]) {
// The x86 implementation in FastPFOR requires SSE4.1
throw std::runtime_error("FastPFOR decoding requires SSE4.1 on x86 platforms");
}
}
#endif
#endif
const auto* inputValues = reinterpret_cast<const std::uint32_t*>(buffer.getReadPosition());
// TODO: change to little endian in the encoder?
const auto intLength = (byteLength + sizeof(std::uint32_t) - 1) / sizeof(std::uint32_t);
const auto leBuffer = getTempBuffer<std::uint32_t>(intLength);
std::transform(inputValues, inputValues + intLength, leBuffer.get(), [](std::uint32_t v) noexcept {
return std::byteswap(v);
});
auto resultCount = numValues;
impl->codec.decodeArray(leBuffer, intLength, result, resultCount);
buffer.consume(byteLength);
return static_cast<std::uint32_t>(resultCount);
} else {
throw std::runtime_error("FastPFOR decoding is not enabled");
}
#else
throw std::runtime_error("FastPFOR decoding is not enabled. Configure with MLT_WITH_FASTPFOR=ON");
#endif // MLT_WITH_FASTPFOR
}
} // namespace mlt::decoder
================================================
FILE: cpp/src/mlt/decode/int.hpp
================================================
#pragma once
#include <mlt/metadata/stream.hpp>
#include <mlt/util/buffer_stream.hpp>
#include <mlt/util/noncopyable.hpp>
#include <mlt/util/rle.hpp>
#include <mlt/util/vectorized.hpp>
#include <mlt/util/zigzag.hpp>
#include <cstdint>
#include <type_traits>
#include <vector>
namespace mlt::decoder {
class IntegerDecoder : public util::noncopyable {
public:
using StreamMetadata = metadata::stream::StreamMetadata;
using MortonEncodedStreamMetadata = metadata::stream::MortonEncodedStreamMetadata;
IntegerDecoder(bool enableFastPFOR);
~IntegerDecoder() noexcept;
IntegerDecoder(IntegerDecoder&&) = delete;
// FastPFOR classes have implicitly-deleted assignment operators.
// We could create new ones, if really necessary.
IntegerDecoder& operator=(IntegerDecoder&&) = delete;
/// Decode a buffer of integers into another, according to the encoding scheme specified by the metadata
/// @param values Input values
/// @param out Output values (should be sized according to `getIntArrayBufferSize`)
/// @param outCount Number of elements in the output buffer
/// @param metadata Stream metadata specifying the encoding details
template <typename T, typename TTarget = T>
requires((std::is_integral_v<T> || std::is_enum_v<T>) &&
(std::is_integral_v<TTarget> || std::is_enum_v<TTarget>) && sizeof(T) <= sizeof(TTarget))
void decodeIntArray(const T* values,
std::size_t count,
TTarget* out,
std::size_t outCount,
const StreamMetadata&,
bool isSigned = std::is_signed_v<T>);
/// Decode an integer stream into the target buffer
/// @param tileData source data
/// @param out output data, automatically resized
/// @param metadata stream metadata specifying the encoding details
/// @details Uses an internal buffer for intermediate values
template <typename TDecode, typename TInt = TDecode, typename TTarget = TDecode>
void decodeIntStream(BufferStream& tileData,
std::vector<TTarget>& out,
const StreamMetadata&,
bool isSigned = std::is_signed_v<TDecode>);
/// Decode an integer stream into the target buffer
/// @param tileData source data
/// @param buffer storage for intermediate values, automatically resized
/// @param out output data, automatically resized
/// @param metadata stream metadata specifying the encoding details
template <typename TDecode, typename TInt = TDecode, typename TTarget = TInt>
void decodeIntStream(BufferStream& tileData,
TInt* buffer,
std::size_t bufferSize,
std::vector<TTarget>& out,
const StreamMetadata&,
bool isSigned = std::is_signed_v<TDecode>);
template <typename TDecode, typename TInt = TDecode, typename TTarget = TInt>
TTarget decodeConstIntStream(BufferStream& tileData,
const StreamMetadata&,
bool isSigned = std::is_signed_v<TDecode>);
template <typename TDecode, typename TInt = TDecode, typename TTarget = TInt, bool Delta = true>
void decodeMortonStream(BufferStream& tileData,
std::vector<TTarget>& out,
const MortonEncodedStreamMetadata& metadata);
template <typename TDecode, typename TInt = TDecode, typename TTarget = TInt, bool Delta = true>
void decodeMortonStream(BufferStream& tileData,
TInt* buffer,
std::size_t bufferSize,
TTarget* out,
std::size_t outCount,
const MortonEncodedStreamMetadata&);
private:
struct Impl;
std::unique_ptr<Impl> impl;
std::vector<std::vector<std::uint8_t>> buffer;
std::size_t bufferIndex = 0;
#if MLT_
gitextract_0pgzvh0v/
├── .clang-format
├── .cursor/
│ └── rules/
│ └── karpathy-guidelines.mdc
├── .gitattributes
├── .github/
│ ├── FUNDING.yml
│ ├── actions/
│ │ ├── mlt-setup-java/
│ │ │ └── action.yml
│ │ ├── mlt-setup-node/
│ │ │ └── action.yml
│ │ └── mlt-setup-rust/
│ │ └── action.yml
│ ├── dependabot.yml
│ └── workflows/
│ ├── autofix.yml
│ ├── ci.yml
│ ├── cpp.yml
│ ├── dependabot.yml
│ ├── gh-pages.yml
│ ├── hotpath-comment.yml
│ ├── hotpath-profile.yml
│ ├── java-release.yml
│ ├── java.yml
│ ├── python-release.yml
│ ├── rust.yml
│ ├── ts-bump-version.yml
│ ├── ts-release.yml
│ └── ts.yml
├── .gitignore
├── .gitmodules
├── .pre-commit-config.yaml
├── CODE_OF_CONDUCT.md
├── LICENSE-APACHE
├── LICENSE-CC0
├── LICENSE-MIT
├── MODULE.bazel
├── README.md
├── SECURITY_POLICY.txt
├── biome.json
├── cpp/
│ ├── .clang-tidy
│ ├── .gitignore
│ ├── .nvmrc
│ ├── BUILD.bazel
│ ├── CMakeLists.txt
│ ├── CTestCustom.cmake
│ ├── README.md
│ ├── bazel/
│ │ └── check/
│ │ ├── BUILD.bazel
│ │ ├── avx.c
│ │ ├── avx2.c
│ │ └── sse42.c
│ ├── cmake/
│ │ └── AddCXXCompilerFlag.cmake
│ ├── include/
│ │ └── mlt/
│ │ ├── common.hpp
│ │ ├── coordinate.hpp
│ │ ├── decoder.hpp
│ │ ├── feature.hpp
│ │ ├── geometry.hpp
│ │ ├── geometry_vector.hpp
│ │ ├── json.hpp
│ │ ├── layer.hpp
│ │ ├── metadata/
│ │ │ ├── stream.hpp
│ │ │ ├── tileset.hpp
│ │ │ └── type_map.hpp
│ │ ├── polyfill.hpp
│ │ ├── projection.hpp
│ │ ├── properties.hpp
│ │ ├── tile.hpp
│ │ └── util/
│ │ ├── buffer_stream.hpp
│ │ ├── noncopyable.hpp
│ │ ├── packed_bitset.hpp
│ │ ├── stl.hpp
│ │ └── varint.hpp
│ ├── mod.just
│ ├── package.json
│ ├── src/
│ │ └── mlt/
│ │ ├── decode/
│ │ │ ├── geometry.hpp
│ │ │ ├── int.cpp
│ │ │ ├── int.hpp
│ │ │ ├── int_template.hpp
│ │ │ ├── property.hpp
│ │ │ └── string.hpp
│ │ ├── decoder.cpp
│ │ ├── feature.cpp
│ │ ├── geometry_vector.cpp
│ │ ├── layer.cpp
│ │ ├── metadata/
│ │ │ ├── stream.cpp
│ │ │ └── tileset.cpp
│ │ ├── properties.cpp
│ │ └── util/
│ │ ├── json_diff.hpp
│ │ ├── morton_curve.hpp
│ │ ├── raw.hpp
│ │ ├── rle.cpp
│ │ ├── rle.hpp
│ │ ├── space_filling_curve.hpp
│ │ ├── vectorized.hpp
│ │ └── zigzag.hpp
│ ├── test/
│ │ ├── CMakeLists.txt
│ │ ├── test_decode.cpp
│ │ ├── test_fastpfor.cpp
│ │ ├── test_fsst.cpp
│ │ ├── test_packed_bitset.cpp
│ │ ├── test_util.cpp
│ │ └── test_varint.cpp
│ ├── tool/
│ │ ├── CMakeLists.txt
│ │ ├── mlt-json.cpp
│ │ ├── synthetic-geojson.cpp
│ │ ├── synthetic-geojson.hpp
│ │ └── synthetic.test.ts
│ └── vendor/
│ └── fastpfor.cmake
├── docs/
│ ├── assets/
│ │ ├── extra.css
│ │ └── spec/
│ │ ├── mlt_tileset_metadata.json
│ │ └── place_feature.json
│ ├── encodings.md
│ ├── implementation-status.md
│ ├── index.md
│ ├── snippets/
│ │ └── live-spec-note
│ └── specification.md
├── java/
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── README-Decode.md
│ ├── README-Encode.md
│ ├── README.MD
│ ├── encoding-server/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── config.json
│ │ ├── config.mjs
│ │ ├── convert.mjs
│ │ ├── eslint.config.mjs
│ │ ├── package.json
│ │ └── server.mjs
│ ├── gradle/
│ │ ├── libs.versions.toml
│ │ └── wrapper/
│ │ ├── gradle-wrapper.jar
│ │ └── gradle-wrapper.properties
│ ├── gradlew
│ ├── gradlew.bat
│ ├── lombok.config
│ ├── mlt-cli/
│ │ ├── build.gradle
│ │ └── src/
│ │ ├── main/
│ │ │ ├── kotlin/
│ │ │ │ └── org/
│ │ │ │ └── maplibre/
│ │ │ │ └── mlt/
│ │ │ │ └── cli/
│ │ │ │ ├── Conversion.kt
│ │ │ │ ├── Decode.kt
│ │ │ │ ├── Encode.kt
│ │ │ │ ├── EncodeCommandLine.kt
│ │ │ │ ├── EncodeConfig.kt
│ │ │ │ ├── Environment.kt
│ │ │ │ ├── Json.kt
│ │ │ │ ├── Logging.kt
│ │ │ │ ├── MBTiles.kt
│ │ │ │ ├── OfflineDB.kt
│ │ │ │ ├── PMTiles.kt
│ │ │ │ ├── ReadablePmtiles.kt
│ │ │ │ ├── SerialTaskRunner.kt
│ │ │ │ ├── Server.kt
│ │ │ │ ├── TaskRunner.kt
│ │ │ │ ├── ThreadPoolTaskRunner.kt
│ │ │ │ └── Timer.kt
│ │ │ └── resources/
│ │ │ └── log4j2.json
│ │ └── test/
│ │ └── kotlin/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ └── cli/
│ │ ├── EncodeCommandLineTest.kt
│ │ ├── EnvironmentResolverTest.kt
│ │ ├── LoggingTest.kt
│ │ ├── ReadablePmtilesMapDirectoryTest.kt
│ │ ├── TaskRunnerTest.kt
│ │ ├── TestUtil.kt
│ │ └── TileCoordRangeTest.kt
│ ├── mlt-core/
│ │ ├── build.gradle
│ │ └── src/
│ │ ├── jmh/
│ │ │ └── java/
│ │ │ └── org/
│ │ │ └── maplibre/
│ │ │ └── mlt/
│ │ │ ├── BenchmarkUtils.java
│ │ │ ├── OmtDecoderBenchmark.java
│ │ │ ├── converter/
│ │ │ │ └── encodings/
│ │ │ │ └── fsst/
│ │ │ │ └── FsstBenchmark.java
│ │ │ └── data/
│ │ │ ├── rle_PartOffsets.csv
│ │ │ ├── rle_class_ratio17.csv
│ │ │ └── rle_id_ratio22_45k.csv
│ │ ├── main/
│ │ │ └── java/
│ │ │ ├── org/
│ │ │ │ └── maplibre/
│ │ │ │ └── mlt/
│ │ │ │ ├── compare/
│ │ │ │ │ └── CompareHelper.java
│ │ │ │ ├── converter/
│ │ │ │ │ ├── CollectionUtils.java
│ │ │ │ │ ├── ColumnMapping.java
│ │ │ │ │ ├── ColumnMappingConfig.java
│ │ │ │ │ ├── ConversionConfig.java
│ │ │ │ │ ├── FeatureTableOptimizations.java
│ │ │ │ │ ├── MltConverter.java
│ │ │ │ │ ├── MortonSettings.java
│ │ │ │ │ ├── encodings/
│ │ │ │ │ │ ├── BooleanEncoder.java
│ │ │ │ │ │ ├── ByteRleEncoder.java
│ │ │ │ │ │ ├── DoubleEncoder.java
│ │ │ │ │ │ ├── EncodingUtils.java
│ │ │ │ │ │ ├── FloatEncoder.java
│ │ │ │ │ │ ├── GeometryEncoder.java
│ │ │ │ │ │ ├── IntegerEncoder.java
│ │ │ │ │ │ ├── LinearRegression.java
│ │ │ │ │ │ ├── MltTypeMap.java
│ │ │ │ │ │ ├── PropertyEncoder.java
│ │ │ │ │ │ ├── StringEncoder.java
│ │ │ │ │ │ └── fsst/
│ │ │ │ │ │ ├── Fsst.java
│ │ │ │ │ │ ├── FsstDebug.java
│ │ │ │ │ │ ├── FsstEncoder.java
│ │ │ │ │ │ ├── FsstJava.java
│ │ │ │ │ │ ├── FsstJni.java
│ │ │ │ │ │ ├── Symbol.java
│ │ │ │ │ │ ├── SymbolTable.java
│ │ │ │ │ │ └── SymbolTableBuilder.java
│ │ │ │ │ ├── geometry/
│ │ │ │ │ │ ├── GeometryType.java
│ │ │ │ │ │ ├── GeometryUtils.java
│ │ │ │ │ │ ├── Hilbert.java
│ │ │ │ │ │ ├── HilbertCurve.java
│ │ │ │ │ │ ├── SpaceFillingCurve.java
│ │ │ │ │ │ ├── Vertex.java
│ │ │ │ │ │ └── ZOrderCurve.java
│ │ │ │ │ ├── mvt/
│ │ │ │ │ │ └── MvtUtils.java
│ │ │ │ │ └── tessellation/
│ │ │ │ │ ├── TessellatedPolygon.java
│ │ │ │ │ └── TessellationUtils.java
│ │ │ │ ├── data/
│ │ │ │ │ ├── Feature.java
│ │ │ │ │ ├── FeatureInterface.java
│ │ │ │ │ ├── IndexedProperty.java
│ │ │ │ │ ├── Layer.java
│ │ │ │ │ ├── LayerSource.java
│ │ │ │ │ ├── MLTFeature.java
│ │ │ │ │ ├── MVTFeature.java
│ │ │ │ │ ├── MapLibreTile.java
│ │ │ │ │ ├── MapboxVectorTile.java
│ │ │ │ │ ├── Property.java
│ │ │ │ │ └── unsigned/
│ │ │ │ │ ├── U32.java
│ │ │ │ │ ├── U64.java
│ │ │ │ │ ├── U8.java
│ │ │ │ │ └── Unsigned.java
│ │ │ │ ├── decoder/
│ │ │ │ │ ├── ByteRleDecoder.java
│ │ │ │ │ ├── DecodingUtils.java
│ │ │ │ │ ├── DoubleDecoder.java
│ │ │ │ │ ├── FloatDecoder.java
│ │ │ │ │ ├── GeometryDecoder.java
│ │ │ │ │ ├── IntegerDecoder.java
│ │ │ │ │ ├── MltDecoder.java
│ │ │ │ │ ├── PropertyDecoder.java
│ │ │ │ │ ├── StringDecoder.java
│ │ │ │ │ └── vectorized/
│ │ │ │ │ └── VectorizedDecodingUtils.java
│ │ │ │ ├── json/
│ │ │ │ │ └── Json.java
│ │ │ │ ├── metadata/
│ │ │ │ │ ├── stream/
│ │ │ │ │ │ ├── DictionaryType.java
│ │ │ │ │ │ ├── LengthType.java
│ │ │ │ │ │ ├── LogicalLevelTechnique.java
│ │ │ │ │ │ ├── LogicalStreamType.java
│ │ │ │ │ │ ├── MortonEncodedStreamMetadata.java
│ │ │ │ │ │ ├── OffsetType.java
│ │ │ │ │ │ ├── PhysicalLevelTechnique.java
│ │ │ │ │ │ ├── PhysicalStreamType.java
│ │ │ │ │ │ ├── RleEncodedStreamMetadata.java
│ │ │ │ │ │ ├── StreamMetadata.java
│ │ │ │ │ │ └── StreamMetadataDecoder.java
│ │ │ │ │ └── tileset/
│ │ │ │ │ └── MltMetadata.java
│ │ │ │ └── util/
│ │ │ │ ├── ByteArrayUtil.java
│ │ │ │ ├── ExceptionUtil.java
│ │ │ │ ├── OptionalUtil.java
│ │ │ │ └── StreamUtil.java
│ │ │ └── springmeyer/
│ │ │ ├── Pbf.java
│ │ │ ├── Point.java
│ │ │ ├── VectorTile.java
│ │ │ ├── VectorTileFeature.java
│ │ │ └── VectorTileLayer.java
│ │ └── test/
│ │ └── java/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ ├── MltGenerator.java
│ │ ├── TestSettings.java
│ │ ├── TestUtils.java
│ │ ├── benchmarks/
│ │ │ ├── CompressionBenchmarksTest.java
│ │ │ └── MltDecoderBenchmarkTest.java
│ │ ├── compare/
│ │ │ └── CompareHelperTest.java
│ │ ├── converter/
│ │ │ ├── ConversionConfigTest.java
│ │ │ ├── MltConverterTest.java
│ │ │ ├── encodings/
│ │ │ │ ├── EncodingUtilsTest.java
│ │ │ │ ├── LinearRegressionTest.java
│ │ │ │ ├── MltTypeMapTest.java
│ │ │ │ ├── VarintTest.java
│ │ │ │ └── fsst/
│ │ │ │ ├── FsstTest.java
│ │ │ │ └── SymbolTest.java
│ │ │ ├── geometry/
│ │ │ │ ├── HilbertCurveTest.java
│ │ │ │ ├── SpaceFillingCurveTest.java
│ │ │ │ └── ZOrderCurveTest.java
│ │ │ └── tessellation/
│ │ │ └── TessellationUtilsTest.java
│ │ ├── data/
│ │ │ └── unsigned/
│ │ │ └── UnsignedTest.java
│ │ ├── decoder/
│ │ │ ├── ByteRleTest.java
│ │ │ ├── DecodingUtilsTest.java
│ │ │ ├── DoubleDecoderTest.java
│ │ │ ├── IntegerDecoderTest.java
│ │ │ ├── MltDecoderTest.java
│ │ │ ├── MltDecoderTest2.java
│ │ │ └── StringDecoderTest.java
│ │ ├── json/
│ │ │ └── JsonTest.java
│ │ ├── metadata/
│ │ │ └── tileset/
│ │ │ └── MltMetadataColumnTest.java
│ │ ├── synthetics/
│ │ │ └── SyntheticsTest.java
│ │ └── util/
│ │ ├── OptionalUtilTest.java
│ │ └── StreamUtilTest.java
│ ├── mlt-tools/
│ │ ├── build.gradle
│ │ └── src/
│ │ └── main/
│ │ └── java/
│ │ └── org/
│ │ └── maplibre/
│ │ └── mlt/
│ │ └── tools/
│ │ ├── SyntheticMltGenerator.java
│ │ └── SyntheticMltUtil.java
│ ├── mod.just
│ ├── resources/
│ │ ├── CMakeLists.txt
│ │ ├── FsstWrapper.cpp
│ │ ├── FsstWrapper.h
│ │ ├── compile
│ │ └── compile-windows.bat
│ ├── settings.gradle
│ └── tessellation/
│ ├── index.mjs
│ └── package.json
├── justfile
├── mkdocs.yml
├── qgis/
│ ├── .gitignore
│ ├── README.md
│ └── mlt_plugin/
│ ├── __init__.py
│ ├── loader.py
│ ├── metadata.txt
│ ├── plugin.py
│ └── tile_coords.py
├── release-plz.toml
├── rust/
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── Cargo.toml
│ ├── README.md
│ ├── bench_param.sh
│ ├── clippy.toml
│ ├── mlt/
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ └── src/
│ │ ├── convert/
│ │ │ ├── files.rs
│ │ │ ├── mod.rs
│ │ │ └── tileset.rs
│ │ ├── dump.rs
│ │ ├── ls.rs
│ │ ├── main.rs
│ │ └── ui/
│ │ ├── mbt.rs
│ │ ├── mod.rs
│ │ ├── rendering/
│ │ │ ├── files.rs
│ │ │ ├── help.rs
│ │ │ ├── layers.rs
│ │ │ ├── map.rs
│ │ │ └── mod.rs
│ │ └── state.rs
│ ├── mlt-core/
│ │ ├── .gitignore
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── benches/
│ │ │ ├── bench_utils.rs
│ │ │ ├── decoding_e2e.rs
│ │ │ ├── decoding_strings.rs
│ │ │ ├── decoding_utils.rs
│ │ │ ├── encoding_e2e.rs
│ │ │ └── encoding_from_mvt.rs
│ │ ├── fuzz/
│ │ │ ├── .gitignore
│ │ │ ├── Cargo.toml
│ │ │ ├── README.md
│ │ │ ├── fuzz_targets/
│ │ │ │ ├── decoded_layer.rs
│ │ │ │ └── layer.rs
│ │ │ ├── src/
│ │ │ │ ├── decoded_layer.rs
│ │ │ │ ├── layer.rs
│ │ │ │ └── lib.rs
│ │ │ └── tests/
│ │ │ └── reproduce.rs
│ │ ├── src/
│ │ │ ├── codecs/
│ │ │ │ ├── bytes.rs
│ │ │ │ ├── fastpfor.rs
│ │ │ │ ├── fsst.rs
│ │ │ │ ├── hilbert.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── morton.rs
│ │ │ │ ├── rle.rs
│ │ │ │ ├── varint.rs
│ │ │ │ └── zigzag.rs
│ │ │ ├── convert/
│ │ │ │ ├── geojson.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── mvt.rs
│ │ │ ├── decoder/
│ │ │ │ ├── analyze.rs
│ │ │ │ ├── column.rs
│ │ │ │ ├── fuzzing.rs
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── geotype.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── model.rs
│ │ │ │ ├── id/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── model.rs
│ │ │ │ ├── iterators.rs
│ │ │ │ ├── layer.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── model.rs
│ │ │ │ ├── property/
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── geojson.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ └── strings.rs
│ │ │ │ ├── root.rs
│ │ │ │ ├── stream/
│ │ │ │ │ ├── analyze.rs
│ │ │ │ │ ├── decode.rs
│ │ │ │ │ ├── logical.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── parse.rs
│ │ │ │ │ └── physical.rs
│ │ │ │ └── tile.rs
│ │ │ ├── encoder/
│ │ │ │ ├── analyze.rs
│ │ │ │ ├── fuzzing.rs
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── encode.rs
│ │ │ │ │ ├── geotype.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ └── tests.rs
│ │ │ │ ├── id/
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ └── staged_id.rs
│ │ │ │ ├── mod.rs
│ │ │ │ ├── model.rs
│ │ │ │ ├── optimizer.rs
│ │ │ │ ├── property/
│ │ │ │ │ ├── encode.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── shared_dict.rs
│ │ │ │ │ ├── strings.rs
│ │ │ │ │ └── tests.rs
│ │ │ │ ├── sort.rs
│ │ │ │ ├── stream/
│ │ │ │ │ ├── codecs.rs
│ │ │ │ │ ├── encode_stream.rs
│ │ │ │ │ ├── encoder.rs
│ │ │ │ │ ├── logical.rs
│ │ │ │ │ ├── mod.rs
│ │ │ │ │ ├── model.rs
│ │ │ │ │ ├── optimizer.rs
│ │ │ │ │ ├── physical.rs
│ │ │ │ │ ├── tests.rs
│ │ │ │ │ └── write.rs
│ │ │ │ ├── tests.rs
│ │ │ │ ├── tile.rs
│ │ │ │ ├── unknown.rs
│ │ │ │ └── writer.rs
│ │ │ ├── errors.rs
│ │ │ ├── lib.rs
│ │ │ └── utils/
│ │ │ ├── analyze.rs
│ │ │ ├── extensions.rs
│ │ │ ├── formatter.rs
│ │ │ ├── lazy_state.rs
│ │ │ ├── mod.rs
│ │ │ ├── parse.rs
│ │ │ ├── presence.rs
│ │ │ ├── serialize.rs
│ │ │ └── test_helpers.rs
│ │ └── tests/
│ │ ├── geojson.rs
│ │ ├── snapshots.rs
│ │ └── unknown_layer.rs
│ ├── mlt-py/
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── maplibre_tiles.pyi
│ │ ├── pyproject.toml
│ │ └── src/
│ │ ├── bins/
│ │ │ └── stub_gen.rs
│ │ ├── feature.rs
│ │ ├── lib.rs
│ │ └── tile_transform.rs
│ ├── mlt-synthetics/
│ │ ├── Cargo.toml
│ │ └── src/
│ │ ├── layer.rs
│ │ ├── main.rs
│ │ └── writer.rs
│ ├── mlt-wasm/
│ │ ├── .gitignore
│ │ ├── .nvmrc
│ │ ├── CHANGELOG.md
│ │ ├── Cargo.toml
│ │ ├── README.md
│ │ ├── js/
│ │ │ ├── decoder.bench.ts
│ │ │ ├── index.ts
│ │ │ ├── synthetic.spec.ts
│ │ │ └── vectorTile.ts
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── geometry.rs
│ │ │ ├── layer.rs
│ │ │ ├── lib.rs
│ │ │ ├── properties.rs
│ │ │ └── tile.rs
│ │ ├── tsconfig.json
│ │ └── vitest.config.ts
│ ├── mod.just
│ └── tomlfmt.toml
├── spec/
│ └── schema/
│ └── mlt_tileset_metadata.proto
├── test/
│ ├── .gitignore
│ ├── .java-version
│ ├── convert_tiles
│ ├── expected/
│ │ └── tag0x01/
│ │ ├── amazon/
│ │ │ ├── 10_518_352.mlt
│ │ │ ├── 11_1037_704.mlt
│ │ │ ├── 5_16_11.mlt
│ │ │ ├── 5_5_11.mlt
│ │ │ ├── 5_6_21.mlt
│ │ │ ├── 5_8_12.mlt
│ │ │ ├── 6_33_21.mlt
│ │ │ ├── 6_33_22.mlt
│ │ │ ├── 7_68_44.mlt
│ │ │ ├── 8_136_89.mlt
│ │ │ └── 9_259_176.mlt
│ │ ├── amazon_here/
│ │ │ ├── 4_8_5.mlt
│ │ │ ├── 4_9_4.mlt
│ │ │ ├── 5_16_10.mlt
│ │ │ ├── 6_33_22.mlt
│ │ │ └── 8_132_85.mlt
│ │ ├── bing/
│ │ │ ├── 4-12-6.mlt
│ │ │ ├── 4-13-6.mlt
│ │ │ ├── 4-8-5.mlt
│ │ │ ├── 4-9-5.mlt
│ │ │ ├── 5-15-10.mlt
│ │ │ ├── 5-16-11.mlt
│ │ │ ├── 5-16-9.mlt
│ │ │ ├── 5-17-10.mlt
│ │ │ ├── 5-17-11.mlt
│ │ │ ├── 6-32-21.mlt
│ │ │ ├── 6-32-22.mlt
│ │ │ ├── 6-32-23.mlt
│ │ │ ├── 6-33-22.mlt
│ │ │ ├── 7-65-42.mlt
│ │ │ ├── 7-66-42.mlt
│ │ │ ├── 7-66-43.mlt
│ │ │ └── 7-66-44.mlt
│ │ ├── omt/
│ │ │ ├── 0_0_0.mlt
│ │ │ ├── 10_530_682.mlt
│ │ │ ├── 10_530_683.mlt
│ │ │ ├── 10_530_684.mlt
│ │ │ ├── 10_531_682.mlt
│ │ │ ├── 10_531_683.mlt
│ │ │ ├── 10_531_684.mlt
│ │ │ ├── 10_532_682.mlt
│ │ │ ├── 10_532_683.mlt
│ │ │ ├── 10_532_684.mlt
│ │ │ ├── 10_533_682.mlt
│ │ │ ├── 10_533_683.mlt
│ │ │ ├── 10_533_684.mlt
│ │ │ ├── 11_1062_1366.mlt
│ │ │ ├── 11_1062_1367.mlt
│ │ │ ├── 11_1062_1368.mlt
│ │ │ ├── 11_1063_1366.mlt
│ │ │ ├── 11_1063_1367.mlt
│ │ │ ├── 11_1063_1368.mlt
│ │ │ ├── 11_1064_1366.mlt
│ │ │ ├── 11_1064_1367.mlt
│ │ │ ├── 11_1064_1368.mlt
│ │ │ ├── 11_1065_1366.mlt
│ │ │ ├── 11_1065_1367.mlt
│ │ │ ├── 11_1065_1368.mlt
│ │ │ ├── 12_2130_2733.mlt
│ │ │ ├── 12_2130_2734.mlt
│ │ │ ├── 12_2131_2733.mlt
│ │ │ ├── 12_2131_2734.mlt
│ │ │ ├── 12_2132_2733.mlt
│ │ │ ├── 12_2132_2734.mlt
│ │ │ ├── 12_2133_2733.mlt
│ │ │ ├── 12_2133_2734.mlt
│ │ │ ├── 12_2134_2733.mlt
│ │ │ ├── 12_2134_2734.mlt
│ │ │ ├── 13_4264_5467.mlt
│ │ │ ├── 13_4264_5468.mlt
│ │ │ ├── 13_4265_5467.mlt
│ │ │ ├── 13_4265_5468.mlt
│ │ │ ├── 13_4266_5467.mlt
│ │ │ ├── 13_4266_5468.mlt
│ │ │ ├── 13_4267_5467.mlt
│ │ │ ├── 13_4267_5468.mlt
│ │ │ ├── 14_8296_10748.mlt
│ │ │ ├── 14_8296_10749.mlt
│ │ │ ├── 14_8297_10748.mlt
│ │ │ ├── 14_8297_10749.mlt
│ │ │ ├── 14_8298_10748.mlt
│ │ │ ├── 14_8298_10749.mlt
│ │ │ ├── 14_8299_10748.mlt
│ │ │ ├── 14_8299_10749.mlt
│ │ │ ├── 14_8300_10748.mlt
│ │ │ ├── 14_8300_10749.mlt
│ │ │ ├── 1_1_1.mlt
│ │ │ ├── 2_2_2.mlt
│ │ │ ├── 3_4_5.mlt
│ │ │ ├── 4_3_9.mlt
│ │ │ ├── 4_8_10.mlt
│ │ │ ├── 5_16_11.mlt
│ │ │ ├── 5_16_20.mlt
│ │ │ ├── 5_16_21.mlt
│ │ │ ├── 5_17_20.mlt
│ │ │ ├── 5_17_21.mlt
│ │ │ ├── 6_32_41.mlt
│ │ │ ├── 6_32_42.mlt
│ │ │ ├── 6_33_41.mlt
│ │ │ ├── 6_33_42.mlt
│ │ │ ├── 6_34_41.mlt
│ │ │ ├── 6_34_42.mlt
│ │ │ ├── 7_66_83.mlt
│ │ │ ├── 7_66_84.mlt
│ │ │ ├── 7_66_85.mlt
│ │ │ ├── 7_67_83.mlt
│ │ │ ├── 7_67_84.mlt
│ │ │ ├── 7_67_85.mlt
│ │ │ ├── 7_68_83.mlt
│ │ │ ├── 7_68_84.mlt
│ │ │ ├── 7_68_85.mlt
│ │ │ ├── 8_132_170.mlt
│ │ │ ├── 8_132_171.mlt
│ │ │ ├── 8_133_170.mlt
│ │ │ ├── 8_133_171.mlt
│ │ │ ├── 8_134_170.mlt
│ │ │ ├── 8_134_171.mlt
│ │ │ ├── 8_135_170.mlt
│ │ │ ├── 8_135_171.mlt
│ │ │ ├── 9_264_340.mlt
│ │ │ ├── 9_264_341.mlt
│ │ │ ├── 9_264_342.mlt
│ │ │ ├── 9_265_340.mlt
│ │ │ ├── 9_265_341.mlt
│ │ │ ├── 9_265_342.mlt
│ │ │ ├── 9_266_340.mlt
│ │ │ ├── 9_266_341.mlt
│ │ │ └── 9_266_342.mlt
│ │ └── simple/
│ │ ├── LICENSE
│ │ ├── line-boolean.mlt
│ │ ├── line-boolean.mlt.geojson
│ │ ├── multiline-boolean.mlt
│ │ ├── multiline-boolean.mlt.geojson
│ │ ├── multipoint-boolean.mlt
│ │ ├── multipoint-boolean.mlt.geojson
│ │ ├── multipolygon-boolean.mlt
│ │ ├── multipolygon-boolean.mlt.geojson
│ │ ├── point-boolean.mlt
│ │ ├── point-boolean.mlt.geojson
│ │ ├── polygon-boolean.mlt
│ │ └── polygon-boolean.mlt.geojson
│ ├── fixtures/
│ │ ├── amazon/
│ │ │ ├── 10_518_352.mvt
│ │ │ ├── 11_1037_704.mvt
│ │ │ ├── 5_16_11.mvt
│ │ │ ├── 5_5_11.mvt
│ │ │ ├── 5_6_21.mvt
│ │ │ ├── 5_8_12.mvt
│ │ │ ├── 6_33_21.mvt
│ │ │ ├── 6_33_22.mvt
│ │ │ ├── 7_68_44.mvt
│ │ │ ├── 8_136_89.mvt
│ │ │ └── 9_259_176.mvt
│ │ ├── amazon_here/
│ │ │ ├── 4_8_5.mvt
│ │ │ ├── 4_9_4.mvt
│ │ │ ├── 5_16_10.mvt
│ │ │ ├── 6_33_22.mvt
│ │ │ └── 8_132_85.mvt
│ │ ├── bing/
│ │ │ ├── 4-12-6.mvt
│ │ │ ├── 4-13-6.mvt
│ │ │ ├── 4-8-5.mvt
│ │ │ ├── 4-9-5.mvt
│ │ │ ├── 5-15-10.mvt
│ │ │ ├── 5-16-11.mvt
│ │ │ ├── 5-16-9.mvt
│ │ │ ├── 5-17-10.mvt
│ │ │ ├── 5-17-11.mvt
│ │ │ ├── 6-32-21.mvt
│ │ │ ├── 6-32-22.mvt
│ │ │ ├── 6-32-23.mvt
│ │ │ ├── 6-33-22.mvt
│ │ │ ├── 7-65-42.mvt
│ │ │ ├── 7-66-42.mvt
│ │ │ ├── 7-66-43.mvt
│ │ │ └── 7-66-44.mvt
│ │ ├── fastpfor/
│ │ │ └── README.md
│ │ ├── omt/
│ │ │ ├── 0_0_0.mvt
│ │ │ ├── 10_530_682.mvt
│ │ │ ├── 10_530_683.mvt
│ │ │ ├── 10_530_684.mvt
│ │ │ ├── 10_531_682.mvt
│ │ │ ├── 10_531_683.mvt
│ │ │ ├── 10_531_684.mvt
│ │ │ ├── 10_532_682.mvt
│ │ │ ├── 10_532_683.mvt
│ │ │ ├── 10_532_684.mvt
│ │ │ ├── 10_533_682.mvt
│ │ │ ├── 10_533_683.mvt
│ │ │ ├── 10_533_684.mvt
│ │ │ ├── 11_1062_1366.mvt
│ │ │ ├── 11_1062_1367.mvt
│ │ │ ├── 11_1062_1368.mvt
│ │ │ ├── 11_1063_1366.mvt
│ │ │ ├── 11_1063_1367.mvt
│ │ │ ├── 11_1063_1368.mvt
│ │ │ ├── 11_1064_1366.mvt
│ │ │ ├── 11_1064_1367.mvt
│ │ │ ├── 11_1064_1368.mvt
│ │ │ ├── 11_1065_1366.mvt
│ │ │ ├── 11_1065_1367.mvt
│ │ │ ├── 11_1065_1368.mvt
│ │ │ ├── 12_2130_2733.mvt
│ │ │ ├── 12_2130_2734.mvt
│ │ │ ├── 12_2131_2733.mvt
│ │ │ ├── 12_2131_2734.mvt
│ │ │ ├── 12_2132_2733.mvt
│ │ │ ├── 12_2132_2734.mvt
│ │ │ ├── 12_2133_2733.mvt
│ │ │ ├── 12_2133_2734.mvt
│ │ │ ├── 12_2134_2733.mvt
│ │ │ ├── 12_2134_2734.mvt
│ │ │ ├── 13_4264_5467.mvt
│ │ │ ├── 13_4264_5468.mvt
│ │ │ ├── 13_4265_5467.mvt
│ │ │ ├── 13_4265_5468.mvt
│ │ │ ├── 13_4266_5467.mvt
│ │ │ ├── 13_4266_5468.mvt
│ │ │ ├── 13_4267_5467.mvt
│ │ │ ├── 13_4267_5468.mvt
│ │ │ ├── 14_8296_10748.mvt
│ │ │ ├── 14_8296_10749.mvt
│ │ │ ├── 14_8297_10748.mvt
│ │ │ ├── 14_8297_10749.mvt
│ │ │ ├── 14_8298_10748.mvt
│ │ │ ├── 14_8298_10749.mvt
│ │ │ ├── 14_8299_10748.mvt
│ │ │ ├── 14_8299_10749.mvt
│ │ │ ├── 14_8300_10748.mvt
│ │ │ ├── 14_8300_10749.mvt
│ │ │ ├── 1_1_1.mvt
│ │ │ ├── 2_2_2.mvt
│ │ │ ├── 3_4_5.mvt
│ │ │ ├── 4_3_9.mvt
│ │ │ ├── 4_8_10.mvt
│ │ │ ├── 5_16_11.mvt
│ │ │ ├── 5_16_20.mvt
│ │ │ ├── 5_16_21.mvt
│ │ │ ├── 5_17_20.mvt
│ │ │ ├── 5_17_21.mvt
│ │ │ ├── 6_32_41.mvt
│ │ │ ├── 6_32_42.mvt
│ │ │ ├── 6_33_41.mvt
│ │ │ ├── 6_33_42.mvt
│ │ │ ├── 6_34_41.mvt
│ │ │ ├── 6_34_42.mvt
│ │ │ ├── 7_66_83.mvt
│ │ │ ├── 7_66_84.mvt
│ │ │ ├── 7_66_85.mvt
│ │ │ ├── 7_67_83.mvt
│ │ │ ├── 7_67_84.mvt
│ │ │ ├── 7_67_85.mvt
│ │ │ ├── 7_68_83.mvt
│ │ │ ├── 7_68_84.mvt
│ │ │ ├── 7_68_85.mvt
│ │ │ ├── 8_132_170.mvt
│ │ │ ├── 8_132_171.mvt
│ │ │ ├── 8_133_170.mvt
│ │ │ ├── 8_133_171.mvt
│ │ │ ├── 8_134_170.mvt
│ │ │ ├── 8_134_171.mvt
│ │ │ ├── 8_135_170.mvt
│ │ │ ├── 8_135_171.mvt
│ │ │ ├── 9_264_340.mvt
│ │ │ ├── 9_264_341.mvt
│ │ │ ├── 9_264_342.mvt
│ │ │ ├── 9_265_340.mvt
│ │ │ ├── 9_265_341.mvt
│ │ │ ├── 9_265_342.mvt
│ │ │ ├── 9_266_340.mvt
│ │ │ ├── 9_266_341.mvt
│ │ │ └── 9_266_342.mvt
│ │ ├── omt-planet-20260112.mvt.max1.pmtiles
│ │ ├── omt-planet-20260112.mvt.max1.pmtiles.txt
│ │ ├── omt.max1.mbtiles
│ │ └── simple/
│ │ ├── LICENSE
│ │ ├── line-boolean.mvt
│ │ ├── multiline-boolean.mvt
│ │ ├── multipoint-boolean.mvt
│ │ ├── multipolygon-boolean.mvt
│ │ ├── point-boolean.mvt
│ │ └── polygon-boolean.mvt
│ ├── omt-advanced-mlt.mbtiles
│ ├── omt-basic-mlt.mbtiles
│ ├── omt-ref.mbtiles
│ └── synthetic/
│ ├── 0x01/
│ │ ├── extent_1073741824.json
│ │ ├── extent_1073741824.mlt
│ │ ├── extent_131072.json
│ │ ├── extent_131072.mlt
│ │ ├── extent_4096.json
│ │ ├── extent_4096.mlt
│ │ ├── extent_512.json
│ │ ├── extent_512.mlt
│ │ ├── extent_buf_1073741824.json
│ │ ├── extent_buf_1073741824.mlt
│ │ ├── extent_buf_131072.json
│ │ ├── extent_buf_131072.mlt
│ │ ├── extent_buf_4096.json
│ │ ├── extent_buf_4096.mlt
│ │ ├── extent_buf_512.json
│ │ ├── extent_buf_512.mlt
│ │ ├── fpf_align_1.json
│ │ ├── fpf_align_1.mlt
│ │ ├── fpf_align_2.json
│ │ ├── fpf_align_2.mlt
│ │ ├── fpf_align_3.json
│ │ ├── fpf_align_3.mlt
│ │ ├── fpf_align_4.json
│ │ ├── fpf_align_4.mlt
│ │ ├── fpf_align_5.json
│ │ ├── fpf_align_5.mlt
│ │ ├── fpf_align_6.json
│ │ ├── fpf_align_6.mlt
│ │ ├── fpf_align_7.json
│ │ ├── fpf_align_7.mlt
│ │ ├── fpf_align_8.json
│ │ ├── fpf_align_8.mlt
│ │ ├── id.json
│ │ ├── id.mlt
│ │ ├── id64.json
│ │ ├── id64.mlt
│ │ ├── id_min.json
│ │ ├── id_min.mlt
│ │ ├── ids.json
│ │ ├── ids.mlt
│ │ ├── ids64.json
│ │ ├── ids64.mlt
│ │ ├── ids64_delta.json
│ │ ├── ids64_delta.mlt
│ │ ├── ids64_delta_rle.json
│ │ ├── ids64_delta_rle.mlt
│ │ ├── ids64_opt.json
│ │ ├── ids64_opt.mlt
│ │ ├── ids64_opt_delta.json
│ │ ├── ids64_opt_delta.mlt
│ │ ├── ids64_rle.json
│ │ ├── ids64_rle.mlt
│ │ ├── ids_delta.json
│ │ ├── ids_delta.mlt
│ │ ├── ids_delta_rle.json
│ │ ├── ids_delta_rle.mlt
│ │ ├── ids_opt.json
│ │ ├── ids_opt.mlt
│ │ ├── ids_opt_delta.json
│ │ ├── ids_opt_delta.mlt
│ │ ├── ids_rle.json
│ │ ├── ids_rle.mlt
│ │ ├── line.json
│ │ ├── line.mlt
│ │ ├── line_morton_curve_morton.json
│ │ ├── line_morton_curve_morton.mlt
│ │ ├── line_morton_curve_no_morton.json
│ │ ├── line_morton_curve_no_morton.mlt
│ │ ├── line_zero_length.json
│ │ ├── line_zero_length.mlt
│ │ ├── mix_2_line_line.json
│ │ ├── mix_2_line_line.mlt
│ │ ├── mix_2_line_mline.json
│ │ ├── mix_2_line_mline.mlt
│ │ ├── mix_2_line_mpoly.json
│ │ ├── mix_2_line_mpoly.mlt
│ │ ├── mix_2_line_mpt.json
│ │ ├── mix_2_line_mpt.mlt
│ │ ├── mix_2_line_poly.json
│ │ ├── mix_2_line_poly.mlt
│ │ ├── mix_2_line_polyh.json
│ │ ├── mix_2_line_polyh.mlt
│ │ ├── mix_2_mline_mline.json
│ │ ├── mix_2_mline_mline.mlt
│ │ ├── mix_2_mline_mpoly.json
│ │ ├── mix_2_mline_mpoly.mlt
│ │ ├── mix_2_mpoly_mpoly.json
│ │ ├── mix_2_mpoly_mpoly.mlt
│ │ ├── mix_2_mpoly_mpoly_tes.json
│ │ ├── mix_2_mpoly_mpoly_tes.mlt
│ │ ├── mix_2_mpt_mline.json
│ │ ├── mix_2_mpt_mline.mlt
│ │ ├── mix_2_mpt_mpoly.json
│ │ ├── mix_2_mpt_mpoly.mlt
│ │ ├── mix_2_mpt_mpt.json
│ │ ├── mix_2_mpt_mpt.mlt
│ │ ├── mix_2_poly_mline.json
│ │ ├── mix_2_poly_mline.mlt
│ │ ├── mix_2_poly_mpoly.json
│ │ ├── mix_2_poly_mpoly.mlt
│ │ ├── mix_2_poly_mpoly_tes.json
│ │ ├── mix_2_poly_mpoly_tes.mlt
│ │ ├── mix_2_poly_mpt.json
│ │ ├── mix_2_poly_mpt.mlt
│ │ ├── mix_2_poly_poly.json
│ │ ├── mix_2_poly_poly.mlt
│ │ ├── mix_2_poly_poly_tes.json
│ │ ├── mix_2_poly_poly_tes.mlt
│ │ ├── mix_2_poly_polyh.json
│ │ ├── mix_2_poly_polyh.mlt
│ │ ├── mix_2_poly_polyh_tes.json
│ │ ├── mix_2_poly_polyh_tes.mlt
│ │ ├── mix_2_polyh_mline.json
│ │ ├── mix_2_polyh_mline.mlt
│ │ ├── mix_2_polyh_mpoly.json
│ │ ├── mix_2_polyh_mpoly.mlt
│ │ ├── mix_2_polyh_mpoly_tes.json
│ │ ├── mix_2_polyh_mpoly_tes.mlt
│ │ ├── mix_2_polyh_mpt.json
│ │ ├── mix_2_polyh_mpt.mlt
│ │ ├── mix_2_polyh_polyh.json
│ │ ├── mix_2_polyh_polyh.mlt
│ │ ├── mix_2_polyh_polyh_tes.json
│ │ ├── mix_2_polyh_polyh_tes.mlt
│ │ ├── mix_2_pt_line.json
│ │ ├── mix_2_pt_line.mlt
│ │ ├── mix_2_pt_mline.json
│ │ ├── mix_2_pt_mline.mlt
│ │ ├── mix_2_pt_mpoly.json
│ │ ├── mix_2_pt_mpoly.mlt
│ │ ├── mix_2_pt_mpt.json
│ │ ├── mix_2_pt_mpt.mlt
│ │ ├── mix_2_pt_poly.json
│ │ ├── mix_2_pt_poly.mlt
│ │ ├── mix_2_pt_polyh.json
│ │ ├── mix_2_pt_polyh.mlt
│ │ ├── mix_2_pt_pt.json
│ │ ├── mix_2_pt_pt.mlt
│ │ ├── mix_3_line_mline_line.json
│ │ ├── mix_3_line_mline_line.mlt
│ │ ├── mix_3_line_mline_mpoly.json
│ │ ├── mix_3_line_mline_mpoly.mlt
│ │ ├── mix_3_line_mpoly_line.json
│ │ ├── mix_3_line_mpoly_line.mlt
│ │ ├── mix_3_line_mpt_line.json
│ │ ├── mix_3_line_mpt_line.mlt
│ │ ├── mix_3_line_mpt_mline.json
│ │ ├── mix_3_line_mpt_mline.mlt
│ │ ├── mix_3_line_mpt_mpoly.json
│ │ ├── mix_3_line_mpt_mpoly.mlt
│ │ ├── mix_3_line_poly_line.json
│ │ ├── mix_3_line_poly_line.mlt
│ │ ├── mix_3_line_poly_mline.json
│ │ ├── mix_3_line_poly_mline.mlt
│ │ ├── mix_3_line_poly_mpoly.json
│ │ ├── mix_3_line_poly_mpoly.mlt
│ │ ├── mix_3_line_poly_mpt.json
│ │ ├── mix_3_line_poly_mpt.mlt
│ │ ├── mix_3_line_poly_polyh.json
│ │ ├── mix_3_line_poly_polyh.mlt
│ │ ├── mix_3_line_polyh_line.json
│ │ ├── mix_3_line_polyh_line.mlt
│ │ ├── mix_3_line_polyh_mline.json
│ │ ├── mix_3_line_polyh_mline.mlt
│ │ ├── mix_3_line_polyh_mpoly.json
│ │ ├── mix_3_line_polyh_mpoly.mlt
│ │ ├── mix_3_line_polyh_mpt.json
│ │ ├── mix_3_line_polyh_mpt.mlt
│ │ ├── mix_3_line_pt_line.json
│ │ ├── mix_3_line_pt_line.mlt
│ │ ├── mix_3_mline_line_mline.json
│ │ ├── mix_3_mline_line_mline.mlt
│ │ ├── mix_3_mline_mpoly_mline.json
│ │ ├── mix_3_mline_mpoly_mline.mlt
│ │ ├── mix_3_mline_mpt_mline.json
│ │ ├── mix_3_mline_mpt_mline.mlt
│ │ ├── mix_3_mline_poly_mline.json
│ │ ├── mix_3_mline_poly_mline.mlt
│ │ ├── mix_3_mline_polyh_mline.json
│ │ ├── mix_3_mline_polyh_mline.mlt
│ │ ├── mix_3_mline_pt_mline.json
│ │ ├── mix_3_mline_pt_mline.mlt
│ │ ├── mix_3_mpoly_line_mpoly.json
│ │ ├── mix_3_mpoly_line_mpoly.mlt
│ │ ├── mix_3_mpoly_mline_mpoly.json
│ │ ├── mix_3_mpoly_mline_mpoly.mlt
│ │ ├── mix_3_mpoly_mpt_mpoly.json
│ │ ├── mix_3_mpoly_mpt_mpoly.mlt
│ │ ├── mix_3_mpoly_poly_mpoly.json
│ │ ├── mix_3_mpoly_poly_mpoly.mlt
│ │ ├── mix_3_mpoly_poly_mpoly_tes.json
│ │ ├── mix_3_mpoly_poly_mpoly_tes.mlt
│ │ ├── mix_3_mpoly_polyh_mpoly.json
│ │ ├── mix_3_mpoly_polyh_mpoly.mlt
│ │ ├── mix_3_mpoly_polyh_mpoly_tes.json
│ │ ├── mix_3_mpoly_polyh_mpoly_tes.mlt
│ │ ├── mix_3_mpoly_pt_mpoly.json
│ │ ├── mix_3_mpoly_pt_mpoly.mlt
│ │ ├── mix_3_mpt_line_mpt.json
│ │ ├── mix_3_mpt_line_mpt.mlt
│ │ ├── mix_3_mpt_mline_mpoly.json
│ │ ├── mix_3_mpt_mline_mpoly.mlt
│ │ ├── mix_3_mpt_mline_mpt.json
│ │ ├── mix_3_mpt_mline_mpt.mlt
│ │ ├── mix_3_mpt_mpoly_mpt.json
│ │ ├── mix_3_mpt_mpoly_mpt.mlt
│ │ ├── mix_3_mpt_poly_mpt.json
│ │ ├── mix_3_mpt_poly_mpt.mlt
│ │ ├── mix_3_mpt_polyh_mpt.json
│ │ ├── mix_3_mpt_polyh_mpt.mlt
│ │ ├── mix_3_mpt_pt_mpt.json
│ │ ├── mix_3_mpt_pt_mpt.mlt
│ │ ├── mix_3_poly_line_poly.json
│ │ ├── mix_3_poly_line_poly.mlt
│ │ ├── mix_3_poly_mline_mpoly.json
│ │ ├── mix_3_poly_mline_mpoly.mlt
│ │ ├── mix_3_poly_mline_poly.json
│ │ ├── mix_3_poly_mline_poly.mlt
│ │ ├── mix_3_poly_mpoly_poly.json
│ │ ├── mix_3_poly_mpoly_poly.mlt
│ │ ├── mix_3_poly_mpoly_poly_tes.json
│ │ ├── mix_3_poly_mpoly_poly_tes.mlt
│ │ ├── mix_3_poly_mpt_mline.json
│ │ ├── mix_3_poly_mpt_mline.mlt
│ │ ├── mix_3_poly_mpt_mpoly.json
│ │ ├── mix_3_poly_mpt_mpoly.mlt
│ │ ├── mix_3_poly_mpt_poly.json
│ │ ├── mix_3_poly_mpt_poly.mlt
│ │ ├── mix_3_poly_polyh_mline.json
│ │ ├── mix_3_poly_polyh_mline.mlt
│ │ ├── mix_3_poly_polyh_mpoly.json
│ │ ├── mix_3_poly_polyh_mpoly.mlt
│ │ ├── mix_3_poly_polyh_mpoly_tes.json
│ │ ├── mix_3_poly_polyh_mpoly_tes.mlt
│ │ ├── mix_3_poly_polyh_mpt.json
│ │ ├── mix_3_poly_polyh_mpt.mlt
│ │ ├── mix_3_poly_polyh_poly.json
│ │ ├── mix_3_poly_polyh_poly.mlt
│ │ ├── mix_3_poly_polyh_poly_tes.json
│ │ ├── mix_3_poly_polyh_poly_tes.mlt
│ │ ├── mix_3_poly_pt_poly.json
│ │ ├── mix_3_poly_pt_poly.mlt
│ │ ├── mix_3_polyh_line_polyh.json
│ │ ├── mix_3_polyh_line_polyh.mlt
│ │ ├── mix_3_polyh_mline_mpoly.json
│ │ ├── mix_3_polyh_mline_mpoly.mlt
│ │ ├── mix_3_polyh_mline_polyh.json
│ │ ├── mix_3_polyh_mline_polyh.mlt
│ │ ├── mix_3_polyh_mpoly_polyh.json
│ │ ├── mix_3_polyh_mpoly_polyh.mlt
│ │ ├── mix_3_polyh_mpoly_polyh_tes.json
│ │ ├── mix_3_polyh_mpoly_polyh_tes.mlt
│ │ ├── mix_3_polyh_mpt_mline.json
│ │ ├── mix_3_polyh_mpt_mline.mlt
│ │ ├── mix_3_polyh_mpt_mpoly.json
│ │ ├── mix_3_polyh_mpt_mpoly.mlt
│ │ ├── mix_3_polyh_mpt_polyh.json
│ │ ├── mix_3_polyh_mpt_polyh.mlt
│ │ ├── mix_3_polyh_poly_polyh.json
│ │ ├── mix_3_polyh_poly_polyh.mlt
│ │ ├── mix_3_polyh_poly_polyh_tes.json
│ │ ├── mix_3_polyh_poly_polyh_tes.mlt
│ │ ├── mix_3_polyh_pt_polyh.json
│ │ ├── mix_3_polyh_pt_polyh.mlt
│ │ ├── mix_3_pt_line_mline.json
│ │ ├── mix_3_pt_line_mline.mlt
│ │ ├── mix_3_pt_line_mpoly.json
│ │ ├── mix_3_pt_line_mpoly.mlt
│ │ ├── mix_3_pt_line_mpt.json
│ │ ├── mix_3_pt_line_mpt.mlt
│ │ ├── mix_3_pt_line_poly.json
│ │ ├── mix_3_pt_line_poly.mlt
│ │ ├── mix_3_pt_line_polyh.json
│ │ ├── mix_3_pt_line_polyh.mlt
│ │ ├── mix_3_pt_line_pt.json
│ │ ├── mix_3_pt_line_pt.mlt
│ │ ├── mix_3_pt_mline_mpoly.json
│ │ ├── mix_3_pt_mline_mpoly.mlt
│ │ ├── mix_3_pt_mline_pt.json
│ │ ├── mix_3_pt_mline_pt.mlt
│ │ ├── mix_3_pt_mpoly_pt.json
│ │ ├── mix_3_pt_mpoly_pt.mlt
│ │ ├── mix_3_pt_mpt_mline.json
│ │ ├── mix_3_pt_mpt_mline.mlt
│ │ ├── mix_3_pt_mpt_mpoly.json
│ │ ├── mix_3_pt_mpt_mpoly.mlt
│ │ ├── mix_3_pt_mpt_pt.json
│ │ ├── mix_3_pt_mpt_pt.mlt
│ │ ├── mix_3_pt_poly_mline.json
│ │ ├── mix_3_pt_poly_mline.mlt
│ │ ├── mix_3_pt_poly_mpoly.json
│ │ ├── mix_3_pt_poly_mpoly.mlt
│ │ ├── mix_3_pt_poly_mpt.json
│ │ ├── mix_3_pt_poly_mpt.mlt
│ │ ├── mix_3_pt_poly_polyh.json
│ │ ├── mix_3_pt_poly_polyh.mlt
│ │ ├── mix_3_pt_poly_pt.json
│ │ ├── mix_3_pt_poly_pt.mlt
│ │ ├── mix_3_pt_polyh_mline.json
│ │ ├── mix_3_pt_polyh_mline.mlt
│ │ ├── mix_3_pt_polyh_mpoly.json
│ │ ├── mix_3_pt_polyh_mpoly.mlt
│ │ ├── mix_3_pt_polyh_mpt.json
│ │ ├── mix_3_pt_polyh_mpt.mlt
│ │ ├── mix_3_pt_polyh_pt.json
│ │ ├── mix_3_pt_polyh_pt.mlt
│ │ ├── mix_4_line_mpt_mline_mpoly.json
│ │ ├── mix_4_line_mpt_mline_mpoly.mlt
│ │ ├── mix_4_line_poly_mline_mpoly.json
│ │ ├── mix_4_line_poly_mline_mpoly.mlt
│ │ ├── mix_4_line_poly_mpt_mline.json
│ │ ├── mix_4_line_poly_mpt_mline.mlt
│ │ ├── mix_4_line_poly_mpt_mpoly.json
│ │ ├── mix_4_line_poly_mpt_mpoly.mlt
│ │ ├── mix_4_line_poly_polyh_mline.json
│ │ ├── mix_4_line_poly_polyh_mline.mlt
│ │ ├── mix_4_line_poly_polyh_mpoly.json
│ │ ├── mix_4_line_poly_polyh_mpoly.mlt
│ │ ├── mix_4_line_poly_polyh_mpt.json
│ │ ├── mix_4_line_poly_polyh_mpt.mlt
│ │ ├── mix_4_line_polyh_mline_mpoly.json
│ │ ├── mix_4_line_polyh_mline_mpoly.mlt
│ │ ├── mix_4_line_polyh_mpt_mline.json
│ │ ├── mix_4_line_polyh_mpt_mline.mlt
│ │ ├── mix_4_line_polyh_mpt_mpoly.json
│ │ ├── mix_4_line_polyh_mpt_mpoly.mlt
│ │ ├── mix_4_poly_mpt_mline_mpoly.json
│ │ ├── mix_4_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_4_poly_polyh_mline_mpoly.json
│ │ ├── mix_4_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_4_poly_polyh_mpt_mline.json
│ │ ├── mix_4_poly_polyh_mpt_mline.mlt
│ │ ├── mix_4_poly_polyh_mpt_mpoly.json
│ │ ├── mix_4_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_4_polyh_mpt_mline_mpoly.json
│ │ ├── mix_4_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_4_pt_line_mline_mpoly.json
│ │ ├── mix_4_pt_line_mline_mpoly.mlt
│ │ ├── mix_4_pt_line_mpt_mline.json
│ │ ├── mix_4_pt_line_mpt_mline.mlt
│ │ ├── mix_4_pt_line_mpt_mpoly.json
│ │ ├── mix_4_pt_line_mpt_mpoly.mlt
│ │ ├── mix_4_pt_line_poly_mline.json
│ │ ├── mix_4_pt_line_poly_mline.mlt
│ │ ├── mix_4_pt_line_poly_mpoly.json
│ │ ├── mix_4_pt_line_poly_mpoly.mlt
│ │ ├── mix_4_pt_line_poly_mpt.json
│ │ ├── mix_4_pt_line_poly_mpt.mlt
│ │ ├── mix_4_pt_line_poly_polyh.json
│ │ ├── mix_4_pt_line_poly_polyh.mlt
│ │ ├── mix_4_pt_line_polyh_mline.json
│ │ ├── mix_4_pt_line_polyh_mline.mlt
│ │ ├── mix_4_pt_line_polyh_mpoly.json
│ │ ├── mix_4_pt_line_polyh_mpoly.mlt
│ │ ├── mix_4_pt_line_polyh_mpt.json
│ │ ├── mix_4_pt_line_polyh_mpt.mlt
│ │ ├── mix_4_pt_mpt_mline_mpoly.json
│ │ ├── mix_4_pt_mpt_mline_mpoly.mlt
│ │ ├── mix_4_pt_poly_mline_mpoly.json
│ │ ├── mix_4_pt_poly_mline_mpoly.mlt
│ │ ├── mix_4_pt_poly_mpt_mline.json
│ │ ├── mix_4_pt_poly_mpt_mline.mlt
│ │ ├── mix_4_pt_poly_mpt_mpoly.json
│ │ ├── mix_4_pt_poly_mpt_mpoly.mlt
│ │ ├── mix_4_pt_poly_polyh_mline.json
│ │ ├── mix_4_pt_poly_polyh_mline.mlt
│ │ ├── mix_4_pt_poly_polyh_mpoly.json
│ │ ├── mix_4_pt_poly_polyh_mpoly.mlt
│ │ ├── mix_4_pt_poly_polyh_mpt.json
│ │ ├── mix_4_pt_poly_polyh_mpt.mlt
│ │ ├── mix_4_pt_polyh_mline_mpoly.json
│ │ ├── mix_4_pt_polyh_mline_mpoly.mlt
│ │ ├── mix_4_pt_polyh_mpt_mline.json
│ │ ├── mix_4_pt_polyh_mpt_mline.mlt
│ │ ├── mix_4_pt_polyh_mpt_mpoly.json
│ │ ├── mix_4_pt_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_line_poly_mpt_mline_mpoly.json
│ │ ├── mix_5_line_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_5_line_poly_polyh_mline_mpoly.json
│ │ ├── mix_5_line_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_5_line_poly_polyh_mpt_mline.json
│ │ ├── mix_5_line_poly_polyh_mpt_mline.mlt
│ │ ├── mix_5_line_poly_polyh_mpt_mpoly.json
│ │ ├── mix_5_line_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_line_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_line_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_5_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_line_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_mline_mpoly.json
│ │ ├── mix_5_pt_line_poly_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_mpt_mline.json
│ │ ├── mix_5_pt_line_poly_mpt_mline.mlt
│ │ ├── mix_5_pt_line_poly_mpt_mpoly.json
│ │ ├── mix_5_pt_line_poly_mpt_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mline.json
│ │ ├── mix_5_pt_line_poly_polyh_mline.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mpoly.json
│ │ ├── mix_5_pt_line_poly_polyh_mpoly.mlt
│ │ ├── mix_5_pt_line_poly_polyh_mpt.json
│ │ ├── mix_5_pt_line_poly_polyh_mpt.mlt
│ │ ├── mix_5_pt_line_polyh_mline_mpoly.json
│ │ ├── mix_5_pt_line_polyh_mline_mpoly.mlt
│ │ ├── mix_5_pt_line_polyh_mpt_mline.json
│ │ ├── mix_5_pt_line_polyh_mpt_mline.mlt
│ │ ├── mix_5_pt_line_polyh_mpt_mpoly.json
│ │ ├── mix_5_pt_line_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_pt_poly_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_5_pt_poly_polyh_mline_mpoly.json
│ │ ├── mix_5_pt_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_5_pt_poly_polyh_mpt_mline.json
│ │ ├── mix_5_pt_poly_polyh_mpt_mline.mlt
│ │ ├── mix_5_pt_poly_polyh_mpt_mpoly.json
│ │ ├── mix_5_pt_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_5_pt_polyh_mpt_mline_mpoly.json
│ │ ├── mix_5_pt_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_line_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_line_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_line_poly_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mline_mpoly.json
│ │ ├── mix_6_pt_line_poly_polyh_mline_mpoly.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mline.json
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mline.mlt
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mpoly.json
│ │ ├── mix_6_pt_line_poly_polyh_mpt_mpoly.mlt
│ │ ├── mix_6_pt_line_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_line_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_6_pt_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_6_pt_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── mix_7_pt_line_poly_polyh_mpt_mline_mpoly.json
│ │ ├── mix_7_pt_line_poly_polyh_mpt_mline_mpoly.mlt
│ │ ├── multiline.json
│ │ ├── multiline.mlt
│ │ ├── multiline_morton.json
│ │ ├── multiline_morton.mlt
│ │ ├── multipoint.json
│ │ ├── multipoint.mlt
│ │ ├── multipoint_morton.json
│ │ ├── multipoint_morton.mlt
│ │ ├── point.json
│ │ ├── point.mlt
│ │ ├── poly.json
│ │ ├── poly.mlt
│ │ ├── poly_collinear.json
│ │ ├── poly_collinear.mlt
│ │ ├── poly_collinear_fpf.json
│ │ ├── poly_collinear_fpf.mlt
│ │ ├── poly_collinear_fpf_tes.json
│ │ ├── poly_collinear_fpf_tes.mlt
│ │ ├── poly_collinear_tes.json
│ │ ├── poly_collinear_tes.mlt
│ │ ├── poly_fpf.json
│ │ ├── poly_fpf.mlt
│ │ ├── poly_fpf_tes.json
│ │ ├── poly_fpf_tes.mlt
│ │ ├── poly_hole.json
│ │ ├── poly_hole.mlt
│ │ ├── poly_hole_fpf.json
│ │ ├── poly_hole_fpf.mlt
│ │ ├── poly_hole_fpf_tes.json
│ │ ├── poly_hole_fpf_tes.mlt
│ │ ├── poly_hole_tes.json
│ │ ├── poly_hole_tes.mlt
│ │ ├── poly_hole_touching.json
│ │ ├── poly_hole_touching.mlt
│ │ ├── poly_hole_touching_fpf.json
│ │ ├── poly_hole_touching_fpf.mlt
│ │ ├── poly_hole_touching_fpf_tes.json
│ │ ├── poly_hole_touching_fpf_tes.mlt
│ │ ├── poly_hole_touching_tes.json
│ │ ├── poly_hole_touching_tes.mlt
│ │ ├── poly_morton_hole_morton.json
│ │ ├── poly_morton_hole_morton.mlt
│ │ ├── poly_morton_ring_morton.json
│ │ ├── poly_morton_ring_morton.mlt
│ │ ├── poly_morton_ring_no_morton.json
│ │ ├── poly_morton_ring_no_morton.mlt
│ │ ├── poly_multi.json
│ │ ├── poly_multi.mlt
│ │ ├── poly_multi_fpf.json
│ │ ├── poly_multi_fpf.mlt
│ │ ├── poly_multi_fpf_tes.json
│ │ ├── poly_multi_fpf_tes.mlt
│ │ ├── poly_multi_morton_hole_morton.json
│ │ ├── poly_multi_morton_hole_morton.mlt
│ │ ├── poly_multi_morton_ring_morton.json
│ │ ├── poly_multi_morton_ring_morton.mlt
│ │ ├── poly_multi_morton_ring_no_morton.json
│ │ ├── poly_multi_morton_ring_no_morton.mlt
│ │ ├── poly_multi_tes.json
│ │ ├── poly_multi_tes.mlt
│ │ ├── poly_self_intersect.json
│ │ ├── poly_self_intersect.mlt
│ │ ├── poly_self_intersect_fpf.json
│ │ ├── poly_self_intersect_fpf.mlt
│ │ ├── poly_self_intersect_fpf_tes.json
│ │ ├── poly_self_intersect_fpf_tes.mlt
│ │ ├── poly_self_intersect_tes.json
│ │ ├── poly_self_intersect_tes.mlt
│ │ ├── poly_tes.json
│ │ ├── poly_tes.mlt
│ │ ├── prop_bool.json
│ │ ├── prop_bool.mlt
│ │ ├── prop_bool_false.json
│ │ ├── prop_bool_false.mlt
│ │ ├── prop_bool_false_null.json
│ │ ├── prop_bool_false_null.mlt
│ │ ├── prop_bool_null_false.json
│ │ ├── prop_bool_null_false.mlt
│ │ ├── prop_bool_null_true.json
│ │ ├── prop_bool_null_true.mlt
│ │ ├── prop_bool_true_null.json
│ │ ├── prop_bool_true_null.mlt
│ │ ├── prop_empty_name.json
│ │ ├── prop_empty_name.mlt
│ │ ├── prop_f32.json
│ │ ├── prop_f32.mlt
│ │ ├── prop_f32_max.json
│ │ ├── prop_f32_max.mlt
│ │ ├── prop_f32_min_norm.json
│ │ ├── prop_f32_min_norm.mlt
│ │ ├── prop_f32_min_val.json
│ │ ├── prop_f32_min_val.mlt
│ │ ├── prop_f32_nan.json
│ │ ├── prop_f32_nan.mlt
│ │ ├── prop_f32_neg_inf.json
│ │ ├── prop_f32_neg_inf.mlt
│ │ ├── prop_f32_neg_zero.json
│ │ ├── prop_f32_neg_zero.mlt
│ │ ├── prop_f32_null_val.json
│ │ ├── prop_f32_null_val.mlt
│ │ ├── prop_f32_pos_inf.json
│ │ ├── prop_f32_pos_inf.mlt
│ │ ├── prop_f32_val_null.json
│ │ ├── prop_f32_val_null.mlt
│ │ ├── prop_f32_zero.json
│ │ ├── prop_f32_zero.mlt
│ │ ├── prop_f64.json
│ │ ├── prop_f64.mlt
│ │ ├── prop_f64_max.json
│ │ ├── prop_f64_max.mlt
│ │ ├── prop_f64_min_norm.json
│ │ ├── prop_f64_min_norm.mlt
│ │ ├── prop_f64_min_val.json
│ │ ├── prop_f64_min_val.mlt
│ │ ├── prop_f64_nan.json
│ │ ├── prop_f64_nan.mlt
│ │ ├── prop_f64_neg_inf.json
│ │ ├── prop_f64_neg_inf.mlt
│ │ ├── prop_f64_neg_zero.json
│ │ ├── prop_f64_neg_zero.mlt
│ │ ├── prop_f64_null_val.json
│ │ ├── prop_f64_null_val.mlt
│ │ ├── prop_f64_pos_inf.json
│ │ ├── prop_f64_pos_inf.mlt
│ │ ├── prop_f64_val_null.json
│ │ ├── prop_f64_val_null.mlt
│ │ ├── prop_f64_zero.json
│ │ ├── prop_f64_zero.mlt
│ │ ├── prop_i32.json
│ │ ├── prop_i32.mlt
│ │ ├── prop_i32_max.json
│ │ ├── prop_i32_max.mlt
│ │ ├── prop_i32_min.json
│ │ ├── prop_i32_min.mlt
│ │ ├── prop_i32_neg.json
│ │ ├── prop_i32_neg.mlt
│ │ ├── prop_i32_null_val.json
│ │ ├── prop_i32_null_val.mlt
│ │ ├── prop_i32_val_null.json
│ │ ├── prop_i32_val_null.mlt
│ │ ├── prop_i64.json
│ │ ├── prop_i64.mlt
│ │ ├── prop_i64_max.json
│ │ ├── prop_i64_max.mlt
│ │ ├── prop_i64_min.json
│ │ ├── prop_i64_min.mlt
│ │ ├── prop_i64_neg.json
│ │ ├── prop_i64_neg.mlt
│ │ ├── prop_i64_null_val.json
│ │ ├── prop_i64_null_val.mlt
│ │ ├── prop_i64_val_null.json
│ │ ├── prop_i64_val_null.mlt
│ │ ├── prop_special_name.json
│ │ ├── prop_special_name.mlt
│ │ ├── prop_str_ascii.json
│ │ ├── prop_str_ascii.mlt
│ │ ├── prop_str_empty.json
│ │ ├── prop_str_empty.mlt
│ │ ├── prop_str_empty_val.json
│ │ ├── prop_str_empty_val.mlt
│ │ ├── prop_str_escape.json
│ │ ├── prop_str_escape.mlt
│ │ ├── prop_str_null_val.json
│ │ ├── prop_str_null_val.mlt
│ │ ├── prop_str_special.json
│ │ ├── prop_str_special.mlt
│ │ ├── prop_str_unicode.json
│ │ ├── prop_str_unicode.mlt
│ │ ├── prop_str_val_empty.json
│ │ ├── prop_str_val_empty.mlt
│ │ ├── prop_str_val_null.json
│ │ ├── prop_str_val_null.mlt
│ │ ├── prop_u32.json
│ │ ├── prop_u32.mlt
│ │ ├── prop_u32_max.json
│ │ ├── prop_u32_max.mlt
│ │ ├── prop_u32_min.json
│ │ ├── prop_u32_min.mlt
│ │ ├── prop_u32_null_val.json
│ │ ├── prop_u32_null_val.mlt
│ │ ├── prop_u32_val_null.json
│ │ ├── prop_u32_val_null.mlt
│ │ ├── prop_u64.json
│ │ ├── prop_u64.mlt
│ │ ├── prop_u64_max.json
│ │ ├── prop_u64_max.mlt
│ │ ├── prop_u64_min.json
│ │ ├── prop_u64_min.mlt
│ │ ├── prop_u64_null_val.json
│ │ ├── prop_u64_null_val.mlt
│ │ ├── prop_u64_val_null.json
│ │ ├── prop_u64_val_null.mlt
│ │ ├── props_i32.json
│ │ ├── props_i32.mlt
│ │ ├── props_i32_delta.json
│ │ ├── props_i32_delta.mlt
│ │ ├── props_i32_delta_rle.json
│ │ ├── props_i32_delta_rle.mlt
│ │ ├── props_i32_rle.json
│ │ ├── props_i32_rle.mlt
│ │ ├── props_i64.json
│ │ ├── props_i64.mlt
│ │ ├── props_i64_delta.json
│ │ ├── props_i64_delta.mlt
│ │ ├── props_i64_delta_rle.json
│ │ ├── props_i64_delta_rle.mlt
│ │ ├── props_i64_rle.json
│ │ ├── props_i64_rle.mlt
│ │ ├── props_mixed.json
│ │ ├── props_mixed.mlt
│ │ ├── props_no_shared_dict.json
│ │ ├── props_no_shared_dict.mlt
│ │ ├── props_offset_str.json
│ │ ├── props_offset_str.mlt
│ │ ├── props_offset_str_fsst.json
│ │ ├── props_offset_str_fsst.mlt
│ │ ├── props_shared_dict.json
│ │ ├── props_shared_dict.mlt
│ │ ├── props_shared_dict_2_same_prefix.json
│ │ ├── props_shared_dict_2_same_prefix.mlt
│ │ ├── props_shared_dict_fsst.json
│ │ ├── props_shared_dict_fsst.mlt
│ │ ├── props_shared_dict_no_child_name.json
│ │ ├── props_shared_dict_no_child_name.mlt
│ │ ├── props_shared_dict_no_child_name_fsst.json
│ │ ├── props_shared_dict_no_child_name_fsst.mlt
│ │ ├── props_shared_dict_no_struct_name.json
│ │ ├── props_shared_dict_no_struct_name.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst.json
│ │ ├── props_shared_dict_no_struct_name_fsst.mlt
│ │ ├── props_shared_dict_one_child.json
│ │ ├── props_shared_dict_one_child.mlt
│ │ ├── props_shared_dict_one_child_fsst.json
│ │ ├── props_shared_dict_one_child_fsst.mlt
│ │ ├── props_str.json
│ │ ├── props_str.mlt
│ │ ├── props_str_fsst.json
│ │ ├── props_str_fsst.mlt
│ │ ├── props_u32.json
│ │ ├── props_u32.mlt
│ │ ├── props_u32_delta.json
│ │ ├── props_u32_delta.mlt
│ │ ├── props_u32_delta_rle.json
│ │ ├── props_u32_delta_rle.mlt
│ │ ├── props_u32_fpf_127.json
│ │ ├── props_u32_fpf_127.mlt
│ │ ├── props_u32_fpf_128.json
│ │ ├── props_u32_fpf_128.mlt
│ │ ├── props_u32_fpf_129.json
│ │ ├── props_u32_fpf_129.mlt
│ │ ├── props_u32_fpf_255.json
│ │ ├── props_u32_fpf_255.mlt
│ │ ├── props_u32_fpf_256.json
│ │ ├── props_u32_fpf_256.mlt
│ │ ├── props_u32_fpf_257.json
│ │ ├── props_u32_fpf_257.mlt
│ │ ├── props_u32_fpf_383.json
│ │ ├── props_u32_fpf_383.mlt
│ │ ├── props_u32_fpf_384.json
│ │ ├── props_u32_fpf_384.mlt
│ │ ├── props_u32_fpf_385.json
│ │ ├── props_u32_fpf_385.mlt
│ │ ├── props_u32_fpf_511.json
│ │ ├── props_u32_fpf_511.mlt
│ │ ├── props_u32_fpf_512.json
│ │ ├── props_u32_fpf_512.mlt
│ │ ├── props_u32_fpf_513.json
│ │ ├── props_u32_fpf_513.mlt
│ │ ├── props_u32_rle.json
│ │ ├── props_u32_rle.mlt
│ │ ├── props_u64.json
│ │ ├── props_u64.mlt
│ │ ├── props_u64_delta.json
│ │ ├── props_u64_delta.mlt
│ │ ├── props_u64_delta_rle.json
│ │ ├── props_u64_delta_rle.mlt
│ │ ├── props_u64_rle.json
│ │ └── props_u64_rle.mlt
│ ├── 0x01-rust/
│ │ ├── id64_max.json
│ │ ├── id64_max.mlt
│ │ ├── id_max.json
│ │ ├── id_max.mlt
│ │ ├── ids64_minmax.json
│ │ ├── ids64_minmax.mlt
│ │ ├── ids64_minmax_delta.json
│ │ ├── ids64_minmax_delta.mlt
│ │ ├── ids_delta_fpf.json
│ │ ├── ids_delta_fpf.mlt
│ │ ├── ids_fpf.json
│ │ ├── ids_fpf.mlt
│ │ ├── mix_2_poly_poly_tes_ns.json
│ │ ├── mix_2_poly_poly_tes_ns.mlt
│ │ ├── mix_2_poly_polyh_tes_ns.json
│ │ ├── mix_2_poly_polyh_tes_ns.mlt
│ │ ├── mix_2_polyh_polyh_tes_ns.json
│ │ ├── mix_2_polyh_polyh_tes_ns.mlt
│ │ ├── mix_3_poly_polyh_poly_tes_ns.json
│ │ ├── mix_3_poly_polyh_poly_tes_ns.mlt
│ │ ├── mix_3_polyh_poly_polyh_tes_ns.json
│ │ ├── mix_3_polyh_poly_polyh_tes_ns.mlt
│ │ ├── poly_collinear_fpf_tes_ns.json
│ │ ├── poly_collinear_fpf_tes_ns.mlt
│ │ ├── poly_collinear_tes_ns.json
│ │ ├── poly_collinear_tes_ns.mlt
│ │ ├── poly_fpf_tes_ns.json
│ │ ├── poly_fpf_tes_ns.mlt
│ │ ├── poly_hole_fpf_tes_ns.json
│ │ ├── poly_hole_fpf_tes_ns.mlt
│ │ ├── poly_hole_tes_ns.json
│ │ ├── poly_hole_tes_ns.mlt
│ │ ├── poly_hole_touching_fpf_tes_ns.json
│ │ ├── poly_hole_touching_fpf_tes_ns.mlt
│ │ ├── poly_hole_touching_tes_ns.json
│ │ ├── poly_hole_touching_tes_ns.mlt
│ │ ├── poly_self_intersect_fpf_tes_ns.json
│ │ ├── poly_self_intersect_fpf_tes_ns.mlt
│ │ ├── poly_self_intersect_tes_ns.json
│ │ ├── poly_self_intersect_tes_ns.mlt
│ │ ├── poly_tes_ns.json
│ │ ├── poly_tes_ns.mlt
│ │ ├── prop_bool_false_np.json
│ │ ├── prop_bool_false_np.mlt
│ │ ├── prop_bool_np.json
│ │ ├── prop_bool_np.mlt
│ │ ├── prop_empty_name_np.json
│ │ ├── prop_empty_name_np.mlt
│ │ ├── prop_f32_max_np.json
│ │ ├── prop_f32_max_np.mlt
│ │ ├── prop_f32_min_norm_np.json
│ │ ├── prop_f32_min_norm_np.mlt
│ │ ├── prop_f32_min_val_np.json
│ │ ├── prop_f32_min_val_np.mlt
│ │ ├── prop_f32_nan_np.json
│ │ ├── prop_f32_nan_np.mlt
│ │ ├── prop_f32_neg_inf_np.json
│ │ ├── prop_f32_neg_inf_np.mlt
│ │ ├── prop_f32_neg_zero_np.json
│ │ ├── prop_f32_neg_zero_np.mlt
│ │ ├── prop_f32_np.json
│ │ ├── prop_f32_np.mlt
│ │ ├── prop_f32_pos_inf_np.json
│ │ ├── prop_f32_pos_inf_np.mlt
│ │ ├── prop_f32_zero_np.json
│ │ ├── prop_f32_zero_np.mlt
│ │ ├── prop_f64_max_np.json
│ │ ├── prop_f64_max_np.mlt
│ │ ├── prop_f64_min_norm_np.json
│ │ ├── prop_f64_min_norm_np.mlt
│ │ ├── prop_f64_min_val_np.json
│ │ ├── prop_f64_min_val_np.mlt
│ │ ├── prop_f64_nan_np.json
│ │ ├── prop_f64_nan_np.mlt
│ │ ├── prop_f64_neg_inf_np.json
│ │ ├── prop_f64_neg_inf_np.mlt
│ │ ├── prop_f64_neg_zero_np.json
│ │ ├── prop_f64_neg_zero_np.mlt
│ │ ├── prop_f64_np.json
│ │ ├── prop_f64_np.mlt
│ │ ├── prop_f64_pos_inf_np.json
│ │ ├── prop_f64_pos_inf_np.mlt
│ │ ├── prop_f64_zero_np.json
│ │ ├── prop_f64_zero_np.mlt
│ │ ├── prop_i32_max_np.json
│ │ ├── prop_i32_max_np.mlt
│ │ ├── prop_i32_min_np.json
│ │ ├── prop_i32_min_np.mlt
│ │ ├── prop_i32_neg_np.json
│ │ ├── prop_i32_neg_np.mlt
│ │ ├── prop_i32_np.json
│ │ ├── prop_i32_np.mlt
│ │ ├── prop_i64_max_np.json
│ │ ├── prop_i64_max_np.mlt
│ │ ├── prop_i64_min_np.json
│ │ ├── prop_i64_min_np.mlt
│ │ ├── prop_i64_neg_np.json
│ │ ├── prop_i64_neg_np.mlt
│ │ ├── prop_i64_np.json
│ │ ├── prop_i64_np.mlt
│ │ ├── prop_special_name_np.json
│ │ ├── prop_special_name_np.mlt
│ │ ├── prop_str_ascii_np.json
│ │ ├── prop_str_ascii_np.mlt
│ │ ├── prop_str_empty_np.json
│ │ ├── prop_str_empty_np.mlt
│ │ ├── prop_str_escape_np.json
│ │ ├── prop_str_escape_np.mlt
│ │ ├── prop_str_special_np.json
│ │ ├── prop_str_special_np.mlt
│ │ ├── prop_str_unicode_np.json
│ │ ├── prop_str_unicode_np.mlt
│ │ ├── prop_u32_max_np.json
│ │ ├── prop_u32_max_np.mlt
│ │ ├── prop_u32_min_np.json
│ │ ├── prop_u32_min_np.mlt
│ │ ├── prop_u32_np.json
│ │ ├── prop_u32_np.mlt
│ │ ├── prop_u64_max_np.json
│ │ ├── prop_u64_max_np.mlt
│ │ ├── prop_u64_min_np.json
│ │ ├── prop_u64_min_np.mlt
│ │ ├── prop_u64_np.json
│ │ ├── prop_u64_np.mlt
│ │ ├── props_i32_delta_np.json
│ │ ├── props_i32_delta_np.mlt
│ │ ├── props_i32_delta_rle_np.json
│ │ ├── props_i32_delta_rle_np.mlt
│ │ ├── props_i32_np.json
│ │ ├── props_i32_np.mlt
│ │ ├── props_i32_rle_np.json
│ │ ├── props_i32_rle_np.mlt
│ │ ├── props_mixed_np.json
│ │ ├── props_mixed_np.mlt
│ │ ├── props_no_shared_dict_np.json
│ │ ├── props_no_shared_dict_np.mlt
│ │ ├── props_offset_str_fsst.json
│ │ ├── props_offset_str_fsst.mlt
│ │ ├── props_offset_str_fsst_np.json
│ │ ├── props_offset_str_fsst_np.mlt
│ │ ├── props_offset_str_np.json
│ │ ├── props_offset_str_np.mlt
│ │ ├── props_shared_dict_2_same_prefix_np.json
│ │ ├── props_shared_dict_2_same_prefix_np.mlt
│ │ ├── props_shared_dict_fsst.json
│ │ ├── props_shared_dict_fsst.mlt
│ │ ├── props_shared_dict_fsst_np.json
│ │ ├── props_shared_dict_fsst_np.mlt
│ │ ├── props_shared_dict_no_child_name_fsst.json
│ │ ├── props_shared_dict_no_child_name_fsst.mlt
│ │ ├── props_shared_dict_no_child_name_fsst_np.json
│ │ ├── props_shared_dict_no_child_name_fsst_np.mlt
│ │ ├── props_shared_dict_no_child_name_np.json
│ │ ├── props_shared_dict_no_child_name_np.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst.json
│ │ ├── props_shared_dict_no_struct_name_fsst.mlt
│ │ ├── props_shared_dict_no_struct_name_fsst_np.json
│ │ ├── props_shared_dict_no_struct_name_fsst_np.mlt
│ │ ├── props_shared_dict_no_struct_name_np.json
│ │ ├── props_shared_dict_no_struct_name_np.mlt
│ │ ├── props_shared_dict_np.json
│ │ ├── props_shared_dict_np.mlt
│ │ ├── props_shared_dict_one_child_fsst.json
│ │ ├── props_shared_dict_one_child_fsst.mlt
│ │ ├── props_shared_dict_one_child_fsst_np.json
│ │ ├── props_shared_dict_one_child_fsst_np.mlt
│ │ ├── props_shared_dict_one_child_np.json
│ │ ├── props_shared_dict_one_child_np.mlt
│ │ ├── props_shared_dict_presence_variants.json
│ │ ├── props_shared_dict_presence_variants.mlt
│ │ ├── props_shared_dict_presence_variants_np.json
│ │ ├── props_shared_dict_presence_variants_np.mlt
│ │ ├── props_str_fsst.json
│ │ ├── props_str_fsst.mlt
│ │ ├── props_str_fsst_np.json
│ │ ├── props_str_fsst_np.mlt
│ │ ├── props_str_np.json
│ │ ├── props_str_np.mlt
│ │ ├── props_u32_delta_np.json
│ │ ├── props_u32_delta_np.mlt
│ │ ├── props_u32_delta_rle_np.json
│ │ ├── props_u32_delta_rle_np.mlt
│ │ ├── props_u32_fpf_127_np.json
│ │ ├── props_u32_fpf_127_np.mlt
│ │ ├── props_u32_fpf_128_np.json
│ │ ├── props_u32_fpf_128_np.mlt
│ │ ├── props_u32_fpf_129_np.json
│ │ ├── props_u32_fpf_129_np.mlt
│ │ ├── props_u32_fpf_255_np.json
│ │ ├── props_u32_fpf_255_np.mlt
│ │ ├── props_u32_fpf_256_np.json
│ │ ├── props_u32_fpf_256_np.mlt
│ │ ├── props_u32_fpf_257_np.json
│ │ ├── props_u32_fpf_257_np.mlt
│ │ ├── props_u32_fpf_383_np.json
│ │ ├── props_u32_fpf_383_np.mlt
│ │ ├── props_u32_fpf_384_np.json
│ │ ├── props_u32_fpf_384_np.mlt
│ │ ├── props_u32_fpf_385_np.json
│ │ ├── props_u32_fpf_385_np.mlt
│ │ ├── props_u32_fpf_511_np.json
│ │ ├── props_u32_fpf_511_np.mlt
│ │ ├── props_u32_fpf_512_np.json
│ │ ├── props_u32_fpf_512_np.mlt
│ │ ├── props_u32_fpf_513_np.json
│ │ ├── props_u32_fpf_513_np.mlt
│ │ ├── props_u32_np.json
│ │ ├── props_u32_np.mlt
│ │ ├── props_u32_rle_np.json
│ │ ├── props_u32_rle_np.mlt
│ │ ├── props_u64_delta_np.json
│ │ ├── props_u64_delta_np.mlt
│ │ ├── props_u64_delta_rle_np.json
│ │ ├── props_u64_delta_rle_np.mlt
│ │ ├── props_u64_np.json
│ │ ├── props_u64_np.mlt
│ │ ├── props_u64_rle_np.json
│ │ └── props_u64_rle_np.mlt
│ ├── java.txt
│ ├── rust.txt
│ └── synthetic-test-utils/
│ ├── index.ts
│ └── package.json
└── ts/
├── .gitignore
├── .nvmrc
├── README.md
├── RELEASE.md
├── biome.json
├── buf.gen.yaml
├── eslint.config.mjs
├── mod.just
├── package.json
├── src/
│ ├── decoding/
│ │ ├── bigEndianDecode.spec.ts
│ │ ├── bigEndianDecode.ts
│ │ ├── decodingTestUtils.ts
│ │ ├── decodingUtils.spec.ts
│ │ ├── decodingUtils.ts
│ │ ├── fastPforCrossLanguage.spec.ts
│ │ ├── fastPforDecoder.spec.ts
│ │ ├── fastPforDecoder.ts
│ │ ├── fastPforShared.spec.ts
│ │ ├── fastPforShared.ts
│ │ ├── fastPforUnpack.spec.ts
│ │ ├── fastPforUnpack.ts
│ │ ├── fsstDecoder.spec.ts
│ │ ├── fsstDecoder.ts
│ │ ├── geometryDecoder.ts
│ │ ├── geometryScaling.ts
│ │ ├── intWrapper.ts
│ │ ├── integerDecodingUtils.spec.ts
│ │ ├── integerDecodingUtils.ts
│ │ ├── integerStreamDecoder.spec.ts
│ │ ├── integerStreamDecoder.ts
│ │ ├── propertyDecoder.spec.ts
│ │ ├── propertyDecoder.ts
│ │ ├── stringDecoder.spec.ts
│ │ ├── stringDecoder.ts
│ │ ├── unpackNullableUtils.spec.ts
│ │ └── unpackNullableUtils.ts
│ ├── encoding/
│ │ ├── bigEndianEncode.ts
│ │ ├── constGeometryVectorEncoder.ts
│ │ ├── embeddedTilesetMetadataEncoder.ts
│ │ ├── encodingUtils.ts
│ │ ├── fastPforEncoder.spec.ts
│ │ ├── fastPforEncoder.ts
│ │ ├── fsstEncoder.ts
│ │ ├── integerEncodingUtils.ts
│ │ ├── integerStreamEncoder.ts
│ │ ├── packNullableUtils.ts
│ │ ├── propertyEncoder.ts
│ │ ├── stringEncoder.ts
│ │ └── zOrderCurveEncoder.ts
│ ├── index.ts
│ ├── metadata/
│ │ ├── tile/
│ │ │ ├── dictionaryType.ts
│ │ │ ├── lengthType.ts
│ │ │ ├── logicalLevelTechnique.ts
│ │ │ ├── logicalStreamType.ts
│ │ │ ├── offsetType.ts
│ │ │ ├── physicalLevelTechnique.ts
│ │ │ ├── physicalStreamType.ts
│ │ │ ├── scalarType.ts
│ │ │ └── streamMetadataDecoder.ts
│ │ └── tileset/
│ │ ├── embeddedTilesetMetadataDecoder.spec.ts
│ │ ├── embeddedTilesetMetadataDecoder.ts
│ │ ├── tilesetMetadata.ts
│ │ ├── typeMap.spec.ts
│ │ └── typeMap.ts
│ ├── mltDecoder.spec.ts
│ ├── mltDecoder.ts
│ ├── mltMetadata.ts
│ ├── synthetic.spec.ts
│ └── vector/
│ ├── constant/
│ │ ├── int32ConstVector.ts
│ │ └── int64ConstVector.ts
│ ├── dictionary/
│ │ └── stringDictionaryVector.ts
│ ├── featureTable.ts
│ ├── filter/
│ │ ├── flatSelectionVector.spec.ts
│ │ ├── flatSelectionVector.ts
│ │ ├── selectionVector.ts
│ │ ├── selectionVectorUtil.spec.ts
│ │ ├── selectionVectorUtils.ts
│ │ ├── sequenceSelectionVector.spec.ts
│ │ └── sequenceSelectionVector.ts
│ ├── fixedSizeVector.ts
│ ├── flat/
│ │ ├── bitVector.ts
│ │ ├── booleanFlatVector.ts
│ │ ├── doubleFlatVector.ts
│ │ ├── floatFlatVector.spec.ts
│ │ ├── floatFlatVector.ts
│ │ ├── int32FlatVector.spec.ts
│ │ ├── int32FlatVector.ts
│ │ ├── int64FlatVector.spec.ts
│ │ ├── int64FlatVector.ts
│ │ └── stringFlatVector.ts
│ ├── fsst-dictionary/
│ │ ├── stringFsstDictionaryVector.spec.ts
│ │ └── stringFsstDictionaryVector.ts
│ ├── geometry/
│ │ ├── constGeometryVector.ts
│ │ ├── constGpuVector.ts
│ │ ├── flatGeometryVector.ts
│ │ ├── flatGpuVector.ts
│ │ ├── geometryType.ts
│ │ ├── geometryVector.ts
│ │ ├── geometryVectorConverter.spec.ts
│ │ ├── geometryVectorConverter.ts
│ │ ├── gpuVector.ts
│ │ ├── topologyVector.ts
│ │ ├── vertexBufferType.ts
│ │ ├── zOrderCurve.spec.ts
│ │ └── zOrderCurve.ts
│ ├── idVector.ts
│ ├── sequence/
│ │ ├── int32SequenceVector.ts
│ │ ├── int64SequenceVector.spec.ts
│ │ ├── int64SequenceVector.ts
│ │ └── sequenceVector.ts
│ ├── variableSizeVector.ts
│ ├── vector.ts
│ └── vectorType.ts
├── tsconfig.json
└── tsconfig.lint.json
Showing preview only (329K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3643 symbols across 371 files)
FILE: cpp/bazel/check/avx.c
function main (line 2) | int main(){
FILE: cpp/bazel/check/avx2.c
function main (line 2) | int main(){
FILE: cpp/bazel/check/sse42.c
function main (line 2) | int main(){
FILE: cpp/include/mlt/common.hpp
type mlt (line 8) | namespace mlt {
function countof (line 13) | constexpr std::size_t countof(T (&)[N]) {
type underlying_type (line 19) | struct underlying_type {
type underlying_type<T, true> (line 23) | struct underlying_type<T, true> : ::std::underlying_type<T> {}
FILE: cpp/include/mlt/coordinate.hpp
type mlt (line 6) | namespace mlt {
type Coordinate (line 8) | struct Coordinate {
method Coordinate (line 12) | Coordinate(float x_, float y_) noexcept
type TileCoordinate (line 21) | struct TileCoordinate {
FILE: cpp/include/mlt/decoder.hpp
type mlt (line 10) | namespace mlt {
class Decoder (line 12) | class Decoder : public util::noncopyable {
method Decoder (line 20) | Decoder(Decoder&&) = delete;
method Decoder (line 21) | Decoder& operator=(Decoder&&) = delete;
type Impl (line 28) | struct Impl
FILE: cpp/include/mlt/feature.hpp
type mlt (line 9) | namespace mlt {
type geometry (line 11) | namespace geometry {
class Geometry (line 12) | class Geometry
class Layer (line 14) | class Layer
class Feature (line 15) | class Feature : public util::noncopyable {
method Feature (line 21) | Feature() = delete;
method Feature (line 22) | Feature(Feature&&) noexcept = default;
method Feature (line 23) | Feature& operator=(Feature&&) = delete;
method getID (line 33) | std::optional<id_t> getID() const noexcept { return ident; }
method getIndex (line 34) | std::uint32_t getIndex() const noexcept { return index; }
method Geometry (line 35) | const Geometry& getGeometry() const noexcept { return *geometry; }
FILE: cpp/include/mlt/geometry.hpp
type mlt::geometry (line 11) | namespace mlt::geometry {
class Geometry (line 13) | class Geometry : public util::noncopyable {
method Geometry (line 18) | Geometry(GeometryType type_) noexcept
method setTriangles (line 25) | void setTriangles(std::span<const std::uint32_t> triangles_) noexcep...
class Point (line 33) | class Point : public Geometry {
method Point (line 35) | Point(const Coordinate& coord) noexcept
method Coordinate (line 39) | const Coordinate& getCoordinate() const noexcept { return coordinate; }
class MultiPoint (line 45) | class MultiPoint : public Geometry {
method MultiPoint (line 47) | MultiPoint(CoordVec coords) noexcept
method CoordVec (line 51) | const CoordVec& getCoordinates() const noexcept { return coordinates; }
method MultiPoint (line 54) | MultiPoint(CoordVec coords, GeometryType type_) noexcept
class LineString (line 62) | class LineString : public MultiPoint {
method LineString (line 64) | LineString(CoordVec coords) noexcept
class LinearRing (line 70) | class LinearRing : public MultiPoint {
method LinearRing (line 72) | LinearRing(CoordVec coords) noexcept
class MultiLineString (line 78) | class MultiLineString : public Geometry {
method MultiLineString (line 80) | MultiLineString(std::vector<CoordVec> lineStrings_) noexcept
class Polygon (line 90) | class Polygon : public Geometry {
method Polygon (line 95) | Polygon(RingVec rings_) noexcept
method RingVec (line 99) | const RingVec& getRings() const noexcept { return rings; }
class MultiPolygon (line 105) | class MultiPolygon : public Geometry {
method MultiPolygon (line 110) | MultiPolygon(std::vector<RingVec> polygons_) noexcept
class GeometryFactory (line 120) | class GeometryFactory {
method GeometryFactory (line 122) | GeometryFactory() = default;
method createPoint (line 125) | virtual std::unique_ptr<Geometry> createPoint(const Coordinate& coor...
method createMultiPoint (line 128) | virtual std::unique_ptr<Geometry> createMultiPoint(CoordVec&& coords...
method createLineString (line 131) | virtual std::unique_ptr<Geometry> createLineString(CoordVec&& coords...
method createLinearRing (line 134) | virtual std::unique_ptr<Geometry> createLinearRing(CoordVec&& coords...
method createPolygon (line 137) | virtual std::unique_ptr<Geometry> createPolygon(std::vector<CoordVec...
method createMultiLineString (line 140) | virtual std::unique_ptr<Geometry> createMultiLineString(std::vector<...
method createMultiPolygon (line 143) | virtual std::unique_ptr<Geometry> createMultiPolygon(std::vector<Mul...
FILE: cpp/include/mlt/geometry_vector.hpp
type mlt::geometry (line 9) | namespace mlt::geometry {
type MortonSettings (line 11) | struct MortonSettings {
type VertexBufferType (line 16) | enum class VertexBufferType : std::uint32_t {
type TopologyVector (line 22) | struct TopologyVector : public util::noncopyable {
method TopologyVector (line 23) | TopologyVector(std::vector<std::uint32_t>&& geometryOffsets_,
type GeometryVector (line 42) | struct GeometryVector : public util::noncopyable {
method getNumGeometries (line 47) | std::uint32_t getNumGeometries() const noexcept { return numGeometri...
method isSingleGeometryType (line 48) | bool isSingleGeometryType() const noexcept { return singleType; }
method GeometryVector (line 55) | GeometryVector(std::uint32_t numGeometries_,
type GpuVector (line 95) | struct GpuVector : public GeometryVector {
method GpuVector (line 96) | GpuVector(std::uint32_t numGeometries_,
type ConstGpuVector (line 116) | struct ConstGpuVector : public GpuVector {
method ConstGpuVector (line 117) | ConstGpuVector(std::uint32_t numGeometries_,
method GeometryType (line 134) | GeometryType getGeometryType(std::size_t) const noexcept override { ...
method containsPolygonGeometry (line 136) | bool containsPolygonGeometry() const noexcept override {
type FlatGpuVector (line 144) | struct FlatGpuVector : public GpuVector {
method FlatGpuVector (line 145) | FlatGpuVector(std::vector<GeometryType>&& geometryTypes_,
method GeometryType (line 159) | GeometryType getGeometryType(std::size_t index) const noexcept overr...
method containsPolygonGeometry (line 164) | bool containsPolygonGeometry() const noexcept override {
type CpuVector (line 175) | struct CpuVector : public GeometryVector {
method CpuVector (line 176) | CpuVector(std::uint32_t numGeometries_,
method Coordinate (line 193) | Coordinate getVertex(std::size_t index) const {
type ConstGeometryVector (line 211) | struct ConstGeometryVector : public CpuVector {
method ConstGeometryVector (line 212) | ConstGeometryVector(std::uint32_t numGeometries_,
method GeometryType (line 228) | GeometryType getGeometryType(std::size_t) const noexcept override { ...
method containsPolygonGeometry (line 230) | bool containsPolygonGeometry() const noexcept override {
type FlatGeometryVector (line 238) | struct FlatGeometryVector : public CpuVector {
method FlatGeometryVector (line 239) | FlatGeometryVector(std::vector<GeometryType>&& geometryTypes_,
method GeometryType (line 254) | GeometryType getGeometryType(std::size_t index) const noexcept overr...
method containsPolygonGeometry (line 259) | bool containsPolygonGeometry() const noexcept override {
FILE: cpp/include/mlt/json.hpp
type mlt (line 22) | namespace mlt {
type json (line 23) | namespace json {
type detail (line 27) | namespace detail {
function json (line 31) | inline json buildArray(std::size_t reservedSize) {
function json (line 43) | inline json append(TRange sourceRange, json&& array, TFunc transfo...
function json (line 55) | inline json buildArray(TRange sourceRange, TFunc transform) {
function json (line 62) | inline json buildProjectedCoordinateArray(const Coordinate& coord) {
function json (line 67) | inline json buildCoordinateArray(const Coordinate& coord, const Pr...
function json (line 72) | inline json buildCoordinatesArray(const CoordVec& coords, const Pr...
function json (line 77) | inline json buildPolygonCoords(const std::vector<CoordVec>& polyRi...
function json (line 85) | inline json buildGeometryElement(std::string_view type, json&& coo...
function json (line 92) | inline json buildGeometryElement(const geometry::Point& point, con...
function json (line 105) | inline json buildGeometryElement(const geometry::LineString& line,...
function json (line 120) | inline json buildGeometryElement(const geometry::LinearRing& line,...
function json (line 135) | inline json buildGeometryElement(const geometry::MultiPoint& point...
function json (line 150) | inline json buildGeometryElement(const geometry::MultiLineString& ...
function json (line 175) | inline json buildGeometryElement(const geometry::Polygon& poly, co...
function json (line 201) | inline json buildGeometryElement(const geometry::MultiPolygon& pol...
function json (line 235) | inline json buildAnyGeometryElement(const geometry::Geometry& geom...
type PropertyVisitor (line 256) | struct PropertyVisitor {
method encodeFloatingPoint (line 258) | std::optional<json> encodeFloatingPoint(T value, std::string_vie...
function json (line 280) | inline json buildProperties(const Layer& layer, const Feature& fea...
function json (line 295) | inline json toJSON(const Layer& layer, const Feature& feature, const...
function json (line 311) | inline json toJSON(const Layer& layer, const TileCoordinate& tileCoo...
function json (line 321) | inline json toJSON(const MapLibreTile& tile, const TileCoordinate& t...
FILE: cpp/include/mlt/layer.hpp
type mlt (line 9) | namespace mlt {
type geometry (line 11) | namespace geometry {
type GeometryVector (line 12) | struct GeometryVector
class Layer (line 15) | class Layer : public util::noncopyable {
method Layer (line 19) | Layer() = delete;
method Layer (line 27) | Layer(Layer&&) noexcept = default;
method Layer (line 28) | Layer& operator=(Layer&&) = default;
method extent_t (line 31) | extent_t getExtent() const noexcept { return extent; }
method PropertyVecMap (line 33) | const PropertyVecMap& getProperties() const { return properties; }
FILE: cpp/include/mlt/metadata/stream.hpp
type mlt::metadata::stream (line 11) | namespace mlt::metadata::stream {
type DictionaryType (line 13) | enum class DictionaryType : std::uint32_t {
type LengthType (line 23) | enum class LengthType : std::uint32_t {
type PhysicalLevelTechnique (line 34) | enum class PhysicalLevelTechnique : std::uint32_t {
type LogicalLevelTechnique (line 45) | enum class LogicalLevelTechnique : std::uint32_t {
type OffsetType (line 55) | enum class OffsetType : std::uint32_t {
type PhysicalStreamType (line 63) | enum class PhysicalStreamType : std::uint32_t {
class LogicalStreamType (line 71) | class LogicalStreamType : public util::noncopyable {
method LogicalStreamType (line 73) | LogicalStreamType(DictionaryType type) noexcept
method LogicalStreamType (line 75) | LogicalStreamType(OffsetType type) noexcept
method LogicalStreamType (line 77) | LogicalStreamType(LengthType type) noexcept
method LogicalStreamType (line 80) | LogicalStreamType() = delete;
method LogicalStreamType (line 81) | LogicalStreamType(LogicalStreamType&&) noexcept = default;
method LogicalStreamType (line 82) | LogicalStreamType& operator=(LogicalStreamType&&) noexcept = default;
class StreamMetadata (line 94) | class StreamMetadata : public util::noncopyable {
method StreamMetadata (line 96) | StreamMetadata() = delete;
method StreamMetadata (line 97) | StreamMetadata(PhysicalStreamType physicalStreamType_,
method StreamMetadata (line 112) | StreamMetadata(StreamMetadata&&) noexcept = default;
method StreamMetadata (line 113) | StreamMetadata& operator=(StreamMetadata&&) noexcept = default;
method LogicalLevelTechnique (line 115) | virtual LogicalLevelTechnique getMetadataType() const noexcept { ret...
method PhysicalStreamType (line 119) | PhysicalStreamType getPhysicalStreamType() const { return physicalSt...
method LogicalLevelTechnique (line 121) | LogicalLevelTechnique getLogicalLevelTechnique1() const { return log...
method LogicalLevelTechnique (line 122) | LogicalLevelTechnique getLogicalLevelTechnique2() const { return log...
method PhysicalLevelTechnique (line 123) | PhysicalLevelTechnique getPhysicalLevelTechnique() const { return ph...
method getNumValues (line 125) | std::uint32_t getNumValues() const noexcept { return numValues; }
method getByteLength (line 126) | std::uint32_t getByteLength() const noexcept { return byteLength; }
class RleEncodedStreamMetadata (line 147) | class RleEncodedStreamMetadata : public StreamMetadata {
method RleEncodedStreamMetadata (line 156) | RleEncodedStreamMetadata(PhysicalStreamType physicalStreamType_,
method RleEncodedStreamMetadata (line 175) | RleEncodedStreamMetadata(StreamMetadata&& streamMetadata, unsigned r...
method RleEncodedStreamMetadata (line 180) | RleEncodedStreamMetadata() = delete;
method LogicalLevelTechnique (line 182) | LogicalLevelTechnique getMetadataType() const noexcept override { re...
method RleEncodedStreamMetadata (line 184) | static RleEncodedStreamMetadata decodePartial(StreamMetadata&& strea...
method RleEncodedStreamMetadata (line 189) | static RleEncodedStreamMetadata decode(BufferStream& tileData) {
method getRuns (line 193) | unsigned getRuns() const noexcept { return runs; }
method getNumRleValues (line 194) | unsigned getNumRleValues() const noexcept { return numRleValues; }
class MortonEncodedStreamMetadata (line 201) | class MortonEncodedStreamMetadata : public StreamMetadata {
method MortonEncodedStreamMetadata (line 203) | MortonEncodedStreamMetadata(PhysicalStreamType physicalStreamType_,
method MortonEncodedStreamMetadata (line 222) | MortonEncodedStreamMetadata(StreamMetadata&& streamMetadata, int num...
method LogicalLevelTechnique (line 227) | LogicalLevelTechnique getMetadataType() const noexcept override { re...
method MortonEncodedStreamMetadata (line 229) | static MortonEncodedStreamMetadata decodePartial(StreamMetadata&& st...
method MortonEncodedStreamMetadata (line 234) | static MortonEncodedStreamMetadata decode(BufferStream& tileData) {
method getNumBits (line 238) | unsigned getNumBits() const noexcept { return numBits; }
method getCoordinateShift (line 239) | unsigned getCoordinateShift() const noexcept { return coordinateShif...
class PdeEncodedMetadata (line 246) | class PdeEncodedMetadata {}
FILE: cpp/include/mlt/metadata/tileset.hpp
type mlt (line 9) | namespace mlt {
type BufferStream (line 10) | struct BufferStream
type mlt::metadata::tileset (line 13) | namespace mlt::metadata::tileset {
type schema (line 16) | namespace schema {
type ColumnScope (line 18) | enum class ColumnScope {
type ScalarType (line 25) | enum class ScalarType {
type ComplexType (line 38) | enum class ComplexType {
type LogicalScalarType (line 47) | enum class LogicalScalarType {
type LogicalComplexType (line 52) | enum class LogicalComplexType {
type GeometryType (line 63) | enum class GeometryType {
type ScalarColumn (line 72) | struct ScalarColumn {
method hasPhysicalType (line 76) | bool hasPhysicalType() const { return std::holds_alternative<ScalarT...
method hasLogicalType (line 77) | bool hasLogicalType() const { return std::holds_alternative<LogicalS...
method isID (line 82) | bool isID() const { return hasLogicalType() && getLogicalType() == L...
type Column (line 87) | struct Column
method hasScalarType (line 115) | bool hasScalarType() const { return std::holds_alternative<ScalarCol...
method hasComplexType (line 116) | bool hasComplexType() const { return std::holds_alternative<ComplexC...
method isID (line 121) | bool isID() const { return hasScalarType() && getScalarType().isID(); }
method isGeometry (line 122) | bool isGeometry() const { return hasComplexType() && getComplexType(...
method isStruct (line 123) | bool isStruct() const { return hasComplexType() && getComplexType()....
type ComplexColumn (line 89) | struct ComplexColumn {
method hasChildren (line 97) | bool hasChildren() const { return !children.empty(); }
method hasPhysicalType (line 98) | bool hasPhysicalType() const { return std::holds_alternative<Complex...
method hasLogicalType (line 99) | bool hasLogicalType() const { return std::holds_alternative<LogicalC...
method isGeometry (line 104) | bool isGeometry() const { return hasPhysicalType() && getPhysicalTyp...
method isStruct (line 105) | bool isStruct() const { return hasPhysicalType() && getPhysicalType(...
type Column (line 109) | struct Column {
method hasScalarType (line 115) | bool hasScalarType() const { return std::holds_alternative<ScalarCol...
method hasComplexType (line 116) | bool hasComplexType() const { return std::holds_alternative<ComplexC...
method isID (line 121) | bool isID() const { return hasScalarType() && getScalarType().isID(); }
method isGeometry (line 122) | bool isGeometry() const { return hasComplexType() && getComplexType(...
method isStruct (line 123) | bool isStruct() const { return hasComplexType() && getComplexType()....
type FeatureTable (line 126) | struct FeatureTable {
FILE: cpp/include/mlt/metadata/type_map.hpp
type mlt::metadata::type_map (line 7) | namespace mlt::metadata::type_map {
type Tag0x01 (line 8) | struct Tag0x01 {
method encodeColumnType (line 18) | static std::optional<std::uint32_t> encodeColumnType(std::optional<S...
method decodeColumnType (line 49) | static std::optional<Column> decodeColumnType(std::uint32_t typeCode) {
method columnTypeHasName (line 81) | static bool columnTypeHasName(std::uint32_t typeCode) { return (10 <...
method columnTypeHasChildren (line 83) | static bool columnTypeHasChildren(std::uint32_t typeCode) { return (...
method hasStreamCount (line 85) | static bool hasStreamCount(const Column& column) {
method mapScalarType (line 125) | constexpr static std::optional<ScalarType> mapScalarType(std::uint32...
method mapScalarType (line 161) | constexpr static std::optional<std::uint32_t> mapScalarType(ScalarTy...
FILE: cpp/include/mlt/polyfill.hpp
type std (line 8) | namespace std {
function to_underlying (line 11) | constexpr auto to_underlying(E e) noexcept {
function T (line 18) | constexpr T byteswap(T value) noexcept {
FILE: cpp/include/mlt/projection.hpp
type mlt (line 11) | namespace mlt {
class Projection (line 16) | class Projection {
method Projection (line 18) | Projection() = delete;
method Projection (line 19) | Projection(const Projection&) noexcept = default;
method Projection (line 20) | Projection(Projection&&) noexcept = default;
method Projection (line 21) | Projection(Layer::extent_t extent, const TileCoordinate& tile)
method Coordinate (line 31) | Coordinate project(const Coordinate& coord) const noexcept { return ...
method projectX (line 34) | float projectX(float x) const noexcept { return ((x + x0) * s1) - 18...
method projectY (line 35) | float projectY(float y) const noexcept {
method degToRad (line 39) | static float degToRad(float deg) noexcept { return deg * std::number...
method radToDeg (line 40) | static float radToDeg(float rad) noexcept { return rad * 180 / std::...
FILE: cpp/include/mlt/properties.hpp
type mlt (line 14) | namespace mlt {
class StringDictViews (line 17) | class StringDictViews : util::noncopyable {
method StringDictViews (line 19) | StringDictViews() = default;
method StringDictViews (line 20) | StringDictViews(std::vector<std::uint8_t>&& data_, std::vector<std::...
method StringDictViews (line 23) | StringDictViews(std::shared_ptr<std::vector<std::uint8_t>> data_, st...
method StringDictViews (line 26) | StringDictViews(StringDictViews&&) noexcept = default;
method StringDictViews (line 27) | StringDictViews& operator=(StringDictViews&&) = default;
type detail (line 69) | namespace detail {
type PropertyCounter (line 70) | struct PropertyCounter {
function propertyCount (line 83) | static inline std::size_t propertyCount(const PropertyVec& vec, bool b...
class PresentProperties (line 88) | class PresentProperties : public util::noncopyable {
method PresentProperties (line 92) | PresentProperties() = delete;
method ScalarType (line 95) | ScalarType getType() const noexcept { return type; }
method isBoolean (line 96) | bool isBoolean() const noexcept { return type == ScalarType::BOOLEAN; }
method PropertyVec (line 97) | const PropertyVec& getProperties() const noexcept { return propertie...
method getPropertyCount (line 99) | std::size_t getPropertyCount() const { return propertyCount(properti...
FILE: cpp/include/mlt/tile.hpp
type mlt (line 8) | namespace mlt {
class MapLibreTile (line 10) | class MapLibreTile : public util::noncopyable {
method MapLibreTile (line 12) | MapLibreTile() = delete;
method MapLibreTile (line 13) | MapLibreTile(std::vector<Layer> layers_) noexcept
method MapLibreTile (line 15) | MapLibreTile(MapLibreTile&&) noexcept = default;
method MapLibreTile (line 16) | MapLibreTile& operator=(MapLibreTile&&) noexcept = default;
method Layer (line 20) | const Layer* getLayer(const std::string_view& name) const noexcept {
FILE: cpp/include/mlt/util/buffer_stream.hpp
type mlt (line 10) | namespace mlt {
type BufferStream (line 12) | struct BufferStream : public util::noncopyable {
method BufferStream (line 13) | BufferStream() = delete;
method BufferStream (line 14) | BufferStream(DataView data_) noexcept
method BufferStream (line 17) | BufferStream(BufferStream&&) = delete;
method BufferStream (line 18) | BufferStream& operator=(BufferStream&&) = delete;
method getSize (line 20) | auto getSize() const noexcept { return data.size(); }
method getOffset (line 21) | auto getOffset() const noexcept { return offset; }
method getRemaining (line 22) | auto getRemaining() const noexcept { return data.size() - offset; }
method available (line 23) | bool available(std::size_t size = 1) const noexcept { return size <=...
method BufferStream (line 26) | BufferStream getSubStream(std::size_t offset, std::size_t length) co...
method reset (line 34) | void reset() { offset = 0; }
method reset (line 35) | void reset(DataView data_) {
method T (line 41) | const T* getData() const noexcept {
method T (line 45) | const T* getReadPosition() const noexcept {
method read (line 50) | DataView::value_type read() {
method read (line 57) | void read(void* buffer, std::size_t size) {
method peek (line 64) | DataView::value_type peek() const {
method consume (line 69) | void consume(std::size_t count) {
method check (line 75) | void check(std::size_t count) const {
FILE: cpp/include/mlt/util/noncopyable.hpp
type mlt::util (line 3) | namespace mlt::util {
class noncopyable (line 5) | class noncopyable {
method noncopyable (line 7) | noncopyable(noncopyable&) = delete;
method noncopyable (line 8) | noncopyable(noncopyable&&) = default;
method noncopyable (line 9) | noncopyable& operator=(const noncopyable&) = delete;
method noncopyable (line 10) | noncopyable& operator=(noncopyable&&) noexcept = default;
method noncopyable (line 13) | constexpr noncopyable() noexcept = default;
FILE: cpp/include/mlt/util/packed_bitset.hpp
type mlt (line 10) | namespace mlt {
function testBit (line 16) | static inline bool testBit(const PackedBitset& bitset, std::size_t i) ...
function countSetBits (line 21) | static inline std::size_t countSetBits(const PackedBitset& bitset) {
function nextSetBit (line 33) | static inline std::optional<std::size_t> nextSetBit(const PackedBitset...
FILE: cpp/include/mlt/util/stl.hpp
type mlt::util (line 8) | namespace mlt::util {
function generateVector (line 15) | std::vector<T> generateVector(const std::size_t count, F generator) {
type overloaded (line 26) | struct overloaded : Ts... {
FILE: cpp/include/mlt/util/varint.hpp
type mlt::util::decoding (line 9) | namespace mlt::util::decoding {
function getVarintSize (line 14) | std::size_t getVarintSize(T value) {
function T (line 25) | T decodeVarint(BufferStream& tileData) {
function decodeVarint (line 30) | inline std::uint32_t decodeVarint(BufferStream& buffer) {
function decodeVarint (line 57) | inline std::uint64_t decodeVarint(BufferStream& buffer) {
function decodeVarints (line 81) | auto decodeVarints(BufferStream& buffer) {
function decodeVarints (line 94) | void decodeVarints(BufferStream& buffer, const std::uint32_t numValues...
FILE: cpp/src/mlt/decode/geometry.hpp
type mlt::decoder (line 17) | namespace mlt::decoder {
class GeometryDecoder (line 19) | class GeometryDecoder {
method GeometryDecoder (line 23) | GeometryDecoder(IntegerDecoder& intDecoder)
type VectorType (line 27) | enum class VectorType : std::uint32_t {
method VectorType (line 35) | VectorType getVectorTypeIntStream(const metadata::stream::StreamMeta...
method decodeGeometryColumn (line 59) | std::unique_ptr<GeometryVector> decodeGeometryColumn(BufferStream& t...
method decodeRootLengthStream (line 266) | void decodeRootLengthStream(const std::vector<metadata::tileset::Geo...
method decodeLevel1LengthStream (line 286) | void decodeLevel1LengthStream(const std::vector<metadata::tileset::G...
method decodeLevel1WithoutRingBufferLengthStream (line 324) | void decodeLevel1WithoutRingBufferLengthStream(const std::vector<met...
method decodeLevel2LengthStream (line 353) | void decodeLevel2LengthStream(const std::vector<metadata::tileset::G...
FILE: cpp/src/mlt/decode/int.cpp
type mlt::decoder (line 20) | namespace mlt::decoder {
type IntegerDecoder::Impl (line 22) | struct IntegerDecoder::Impl {
FILE: cpp/src/mlt/decode/int.hpp
type mlt::decoder (line 14) | namespace mlt::decoder {
class IntegerDecoder (line 16) | class IntegerDecoder : public util::noncopyable {
method IntegerDecoder (line 24) | IntegerDecoder(IntegerDecoder&&) = delete;
method IntegerDecoder (line 27) | IntegerDecoder& operator=(IntegerDecoder&&) = delete;
type Impl (line 87) | struct Impl
type BufWrapperBase (line 98) | struct BufWrapperBase : util::noncopyable {
method BufWrapperBase (line 99) | BufWrapperBase(IntegerDecoder& decoder_, std::uint8_t* ptr_) noexcept
method BufWrapperBase (line 106) | BufWrapperBase(BufWrapperBase&& other) noexcept
type BufWrapper (line 120) | struct BufWrapper : BufWrapperBase {
method BufWrapper (line 121) | BufWrapper(IntegerDecoder& decoder_, std::uint8_t* ptr_) noexcept
method T (line 123) | T* get() const noexcept { return reinterpret_cast<T*>(ptr); }
method getTempBuffer (line 129) | BufWrapper<T> getTempBuffer(std::size_t minSize) {
FILE: cpp/src/mlt/decode/int_template.hpp
type mlt::decoder (line 13) | namespace mlt::decoder {
function TTarget (line 146) | TTarget IntegerDecoder::decodeConstIntStream(BufferStream& tileData,
FILE: cpp/src/mlt/decode/property.hpp
type mlt::decoder (line 21) | namespace mlt::decoder {
class PropertyDecoder (line 23) | class PropertyDecoder {
method PropertyDecoder (line 25) | PropertyDecoder(IntegerDecoder& intDecoder_, StringDecoder& stringDe...
method PropertyVecMap (line 29) | PropertyVecMap decodePropertyColumn(BufferStream& tileData,
method skipColumn (line 48) | void skipColumn(BufferStream& tileData, std::uint32_t numStreams) {
method PresentProperties (line 63) | PresentProperties decodeScalarPropertyColumn(BufferStream& tileData,
FILE: cpp/src/mlt/decode/string.hpp
type mlt::decoder (line 17) | namespace mlt::decoder {
class StringDecoder (line 19) | class StringDecoder {
method StringDecoder (line 21) | StringDecoder(IntegerDecoder& intDecoder_)
method StringDictViews (line 31) | StringDictViews decode(BufferStream& tileData, std::uint32_t numStre...
method PropertyVecMap (line 90) | PropertyVecMap decodeSharedDictionary(BufferStream& tileData,
method decodeFSST (line 185) | static std::vector<std::uint8_t> decodeFSST(const std::vector<std::u...
method decodeFSST (line 198) | static std::vector<std::uint8_t> decodeFSST(const std::uint8_t* symb...
method view (line 251) | static std::string_view view(const char* bytes, std::size_t length) {
method decodePlain (line 259) | static void decodePlain(const std::vector<std::uint32_t>& lengthStream,
method decodeDictionary (line 273) | static void decodeDictionary(const std::vector<std::uint32_t>& lengt...
method decodeDictionary (line 285) | static void decodeDictionary(const std::vector<std::uint32_t>& lengt...
FILE: cpp/src/mlt/decoder.cpp
type mlt (line 26) | namespace mlt {
type Decoder::Impl (line 31) | struct Decoder::Impl {
method Impl (line 32) | Impl(std::unique_ptr<GeometryFactory>&& geometryFactory_, bool suppo...
function Layer (line 48) | Layer Decoder::Impl::parseBasicMVTEquivalent(BufferStream& tileData) {
function MapLibreTile (line 138) | MapLibreTile Decoder::decode(BufferStream tileData) {
function MapLibreTile (line 157) | MapLibreTile Decoder::decode(DataView tileData) {
FILE: cpp/src/mlt/feature.cpp
type mlt (line 6) | namespace mlt {
FILE: cpp/src/mlt/geometry_vector.cpp
type mlt::geometry (line 8) | namespace mlt::geometry {
function checkBuffer (line 11) | constexpr void checkBuffer(std::size_t index, std::size_t size, std::s...
function Coordinate (line 18) | inline Coordinate coord(std::int32_t x, std::int32_t y) {
function getLineStringCoords (line 22) | std::vector<Coordinate> getLineStringCoords(const std::vector<std::int...
function getDictionaryEncodedLineStringCoords (line 40) | std::vector<Coordinate> getDictionaryEncodedLineStringCoords(const std...
function getMortonEncodedLineStringCoords (line 59) | std::vector<Coordinate> getMortonEncodedLineStringCoords(const std::ve...
FILE: cpp/src/mlt/layer.cpp
type mlt (line 4) | namespace mlt {
FILE: cpp/src/mlt/metadata/stream.cpp
type mlt::metadata::stream (line 6) | namespace mlt::metadata::stream {
function decodeLogicalStreamType (line 9) | std::optional<LogicalStreamType> decodeLogicalStreamType(PhysicalStrea...
function StreamMetadata (line 76) | StreamMetadata StreamMetadata::decodeInternal(BufferStream& tileData) {
FILE: cpp/src/mlt/metadata/tileset.cpp
type mlt::metadata::tileset (line 9) | namespace mlt::metadata::tileset {
function decodeString (line 13) | std::string decodeString(BufferStream& tileData) {
function Column (line 23) | Column decodeColumn(BufferStream& tileData) {
function FeatureTable (line 46) | FeatureTable decodeFeatureTable(BufferStream& tileData) {
FILE: cpp/src/mlt/properties.cpp
type mlt (line 11) | namespace mlt {
type ExtractPropertyVisitor (line 16) | struct ExtractPropertyVisitor {
method ExtractPropertyVisitor (line 17) | ExtractPropertyVisitor(std::size_t i_, bool byteIsBooleans_)
function getPropertyValue (line 51) | auto getPropertyValue(const PropertyVec& layerProperties, std::size_t ...
function buildIndexVector (line 61) | std::vector<T> buildIndexVector(const PackedBitset& present) {
FILE: cpp/src/mlt/util/json_diff.hpp
type mlt::util (line 9) | namespace mlt::util {
type JSONComparer (line 13) | struct JSONComparer {
method getDouble (line 39) | static std::optional<double> getDouble(const json& v) {
function json (line 63) | static json diff(const json& source,
FILE: cpp/src/mlt/util/morton_curve.hpp
type mlt::util (line 5) | namespace mlt::util {
class MortonCurve (line 7) | class MortonCurve : public SpaceFillingCurve {
method MortonCurve (line 9) | MortonCurve(std::int32_t minVertexValue, std::int32_t maxVertexValue)
method encode (line 12) | std::uint32_t encode(const Coordinate& vertex) const override {
method Coordinate (line 17) | Coordinate decode(std::uint32_t mortonCode) const noexcept override {
method Coordinate (line 21) | static Coordinate decode(std::uint32_t mortonCode, std::uint32_t num...
method decode (line 26) | static std::int32_t decode(std::uint32_t code, std::uint32_t numBits...
method encodeMorton (line 35) | static std::uint32_t encodeMorton(const Coordinate& vertex,
FILE: cpp/src/mlt/util/raw.hpp
type mlt::util::decoding (line 9) | namespace mlt::util::decoding {
function decodeRaw (line 11) | inline void decodeRaw(BufferStream& tileData, std::vector<std::uint8_t...
function decodeRaw (line 20) | void decodeRaw(BufferStream& tileData,
FILE: cpp/src/mlt/util/rle.cpp
type mlt::util::decoding::rle (line 7) | namespace mlt::util::decoding::rle {
function decodeBoolean (line 9) | void decodeBoolean(BufferStream& tileData,
FILE: cpp/src/mlt/util/rle.hpp
type mlt::metadata::stream (line 10) | namespace mlt::metadata::stream {
class StreamMetadata (line 11) | class StreamMetadata
type mlt::util::decoding::rle (line 14) | namespace mlt::util::decoding::rle {
type detail (line 16) | namespace detail {
class ByteRleDecoder (line 19) | class ByteRleDecoder : public util::noncopyable {
method ByteRleDecoder (line 21) | ByteRleDecoder() = delete;
method ByteRleDecoder (line 22) | ByteRleDecoder(const std::uint8_t* buffer, size_t length) noexcept
method ByteRleDecoder (line 25) | ByteRleDecoder(ByteRleDecoder&&) = delete;
method ByteRleDecoder (line 26) | ByteRleDecoder& operator=(const ByteRleDecoder&) = delete;
method ByteRleDecoder (line 27) | ByteRleDecoder& operator=(ByteRleDecoder&&) = delete;
method getBufferRemaining (line 29) | std::size_t getBufferRemaining() const noexcept { return bufferEnd...
method next (line 31) | void next(std::uint8_t* data, std::uint64_t numValues) {
method readByte (line 66) | char readByte() {
method readHeader (line 73) | void readHeader() {
function decodeByte (line 100) | inline void decodeByte(BufferStream& tileData, std::uint8_t* out, std:...
function decodeInt (line 118) | void decodeInt(
FILE: cpp/src/mlt/util/space_filling_curve.hpp
type mlt::util (line 8) | namespace mlt::util {
class SpaceFillingCurve (line 10) | class SpaceFillingCurve {
method SpaceFillingCurve (line 12) | SpaceFillingCurve(std::int32_t minVertexValue, std::int32_t maxVerte...
method getNumBits (line 26) | std::uint32_t getNumBits() const noexcept { return numBits; }
method getCoordinateShift (line 28) | std::int32_t getCoordinateShift() const noexcept { return coordinate...
method validate (line 31) | void validate(const Coordinate& vertex) const {
FILE: cpp/src/mlt/util/vectorized.hpp
type mlt::util::decoding::vectorized (line 8) | namespace mlt::util::decoding::vectorized {
function T (line 13) | T unsigned_rshift(T t) {
function T (line 20) | T odd_sign(T t) {
function T (line 26) | T shift_and_xor(T t) {
function decodeComponentwiseDeltaVec2 (line 34) | inline void decodeComponentwiseDeltaVec2(T* const data, const std::siz...
FILE: cpp/src/mlt/util/zigzag.hpp
type mlt::util::decoding (line 7) | namespace mlt::util::decoding {
function T (line 11) | T decodeZigZag(T encoded) noexcept {
FILE: cpp/test/test_decode.cpp
function findFiles (line 25) | std::vector<std::filesystem::path> findFiles(const std::filesystem::path...
function loadFile (line 37) | std::vector<std::ifstream::char_type> loadFile(const std::filesystem::pa...
function writeFile (line 51) | bool writeFile(const std::filesystem::path& path, const std::string& dat...
function dump (line 63) | auto dump(const nlohmann::json& json) {
function loadTile (line 68) | std::pair<std::optional<mlt::MapLibreTile>, std::string> loadTile(const ...
function TEST (line 107) | TEST(Decode, SimplePointBoolean) {
function TEST (line 121) | TEST(Decode, SimpleLineBoolean) {
function TEST (line 127) | TEST(Decode, SimplePolygonBoolean) {
function TEST (line 144) | TEST(Decode, SimpleMultiPointBoolean) {
function TEST (line 149) | TEST(Decode, SimpleMultiLineBoolean) {
function TEST (line 154) | TEST(Decode, SimpleMultiPolygonBoolean) {
function TEST (line 159) | TEST(Decode, Bing) {
function TEST (line 164) | TEST(Decode, OMT) {
function TEST (line 170) | TEST(Decode, AllBing) {
function TEST (line 177) | TEST(Decode, AllAmazon) {
function TEST (line 184) | TEST(Decode, AllOMT) {
FILE: cpp/test/test_fastpfor.cpp
function TEST (line 23) | TEST(FastPfor, DecompressPartial) {
function simpleValueView (line 34) | auto simpleValueView(std::size_t n) {
function simpleValues (line 38) | auto simpleValues(std::size_t n) {
function TEST (line 47) | TEST(FastPfor, JavaV1) {
function testSIMDInterop (line 79) | void testSIMDInterop(int valuesCount) {
type SIMDInteropCase (line 115) | struct SIMDInteropCase {
function simdInteropCases (line 120) | std::vector<SIMDInteropCase> simdInteropCases() {
function simdInteropCaseName (line 136) | std::string simdInteropCaseName(const ::testing::TestParamInfo<SIMDInter...
class PFORSIMDInteropTest (line 140) | class PFORSIMDInteropTest : public ::testing::TestWithParam<SIMDInteropC...
function TEST_P (line 142) | TEST_P(PFORSIMDInteropTest, Interop) {
FILE: cpp/test/test_fsst.cpp
function TEST (line 8) | TEST(FSST, DecodeFromJava) {
FILE: cpp/test/test_packed_bitset.cpp
function TEST (line 7) | TEST(PackedBitset, TestBit) {
function TEST (line 19) | TEST(PackedBitset, NextBit) {
function TEST (line 39) | TEST(PackedBitset, CountBits) {
FILE: cpp/test/test_util.cpp
function TEST (line 5) | TEST(Util, ComponentwiseDeltaVec2) {
FILE: cpp/test/test_varint.cpp
function T (line 11) | T decode(std::vector<std::uint8_t> data) {
function TEST (line 17) | TEST(Varint, Size) {
function TEST (line 29) | TEST(Varint, Decode) {
FILE: cpp/tool/mlt-json.cpp
function loadFile (line 17) | std::vector<std::ifstream::char_type> loadFile(const std::string& path) {
function main (line 33) | int main(int argc, char** argv) {
FILE: cpp/tool/synthetic-geojson.cpp
type mlt::test (line 10) | namespace mlt::test {
function json (line 17) | json buildRawCoordValue(float v) {
function json (line 22) | json buildRawCoordinateArray(const Coordinate& coord) {
function json (line 26) | json buildRawCoordinatesArray(const CoordVec& coords) {
function json (line 30) | json buildRawPolygonCoords(const std::vector<CoordVec>& rings) {
function json (line 34) | json buildRawGeometryElement(const geometry::Geometry& geometry) {
function json (line 74) | json toFeatureCollection(const MapLibreTile& tile) {
FILE: cpp/tool/synthetic-geojson.hpp
type mlt::test (line 9) | namespace mlt::test {
FILE: cpp/tool/synthetic.test.ts
constant SKIPPED_TESTS (line 14) | const SKIPPED_TESTS = [];
function decodeMLT (line 38) | async function decodeMLT(mltFilePath: string) {
FILE: java/encoding-server/convert.mjs
function convertRequest (line 11) | function convertRequest(convertResponse) {
function convertURL (line 50) | function convertURL(urlString, type, req) {
function convertStyleResponse (line 67) | function convertStyleResponse(req, data, res) {
function convertSourceResponse (line 106) | function convertSourceResponse(req, data, res) {
function convertTileResponse (line 134) | function convertTileResponse(filePath, res) {
function convertTileCLI (line 205) | function convertTileCLI(args, callback) {
function convertTileCLIServer (line 210) | function convertTileCLIServer(args, callback) {
function convertTileRequest (line 232) | function convertTileRequest(req, res) {
function runCLISetup (line 297) | function runCLISetup() {
FILE: java/mlt-core/src/jmh/java/org/maplibre/mlt/BenchmarkUtils.java
class BenchmarkUtils (line 21) | public class BenchmarkUtils {
method BenchmarkUtils (line 22) | private BenchmarkUtils() {}
method encodeTile (line 24) | public static void encodeTile(
method getMvtFile (line 67) | private static Pair<byte[], MapboxVectorTile> getMvtFile(
FILE: java/mlt-core/src/jmh/java/org/maplibre/mlt/OmtDecoderBenchmark.java
class OmtDecoderBenchmark (line 28) | @State(Scope.Benchmark)
method setup (line 44) | @Setup
method resetInputStreams (line 61) | @Setup(Level.Invocation)
method encodeTile (line 68) | private void encodeTile(int z, int x, int y) throws IOException {
method decodeMvtMapboxZ2 (line 81) | @Benchmark
method decodeMvtMapboxZ3 (line 87) | @Benchmark
method decodeMvtMapboxZ4 (line 93) | @Benchmark
method decodeMvtMapboxZ5 (line 99) | @Benchmark
method decodeMvtMapboxZ6 (line 105) | @Benchmark
method decodeMvtMapboxZ7 (line 111) | @Benchmark
method decodeMvtMapboxZ8 (line 117) | @Benchmark
method decodeMvtMapboxZ9 (line 123) | @Benchmark
method decodeMvtMapboxZ10 (line 129) | @Benchmark
method decodeMvtMapboxZ11 (line 135) | @Benchmark
method decodeMvtMapboxZ12 (line 141) | @Benchmark
method decodeMvtMapboxZ13 (line 147) | @Benchmark
method decodeMvtMapboxZ14 (line 153) | @Benchmark
method decodeCompressedMvtMapboxZ2 (line 159) | @Benchmark
method decodeCompressedMvtMapboxZ3 (line 166) | @Benchmark
method decodeCompressedMvtMapboxZ4 (line 173) | @Benchmark
method decodeCompressedMvtMapboxZ5 (line 180) | @Benchmark
method decodeCompressedMvtMapboxZ6 (line 187) | @Benchmark
method decodeCompressedMvtMapboxZ7 (line 194) | @Benchmark
method decodeCompressedMvtMapboxZ8 (line 201) | @Benchmark
method decodeCompressedMvtMapboxZ9 (line 208) | @Benchmark
method decodeCompressedMvtMapboxZ10 (line 215) | @Benchmark
method decodeCompressedMvtMapboxZ11 (line 222) | @Benchmark
method decodeCompressedMvtMapboxZ12 (line 229) | @Benchmark
method decodeCompressedMvtMapboxZ13 (line 236) | @Benchmark
method decodeCompressedMvtMapboxZ14 (line 243) | @Benchmark
FILE: java/mlt-core/src/jmh/java/org/maplibre/mlt/converter/encodings/fsst/FsstBenchmark.java
class FsstBenchmark (line 16) | @State(Scope.Benchmark)
method encodeSmallJava (line 56) | @Benchmark
method encodeMediumJava (line 61) | @Benchmark
method encodeLargeJava (line 66) | @Benchmark
method encodeExtraLargeJava (line 71) | @Benchmark
method encodeSmallJni (line 76) | @Benchmark
method encodeMediumJni (line 81) | @Benchmark
method encodeLargeJni (line 86) | @Benchmark
method encodeExtraLargeJni (line 91) | @Benchmark
method decodeSmallJava (line 96) | @Benchmark
method decodeMediumJava (line 101) | @Benchmark
method decodeLargeJava (line 106) | @Benchmark
method decodeExtraLargeJava (line 111) | @Benchmark
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/compare/CompareHelper.java
class CompareHelper (line 24) | public final class CompareHelper {
method CompareHelper (line 25) | private CompareHelper() {}
type CompareMode (line 27) | public enum CompareMode {
method toString (line 43) | @Override
method compareTiles (line 70) | public static Optional<Difference> compareTiles(
method compareTiles (line 86) | public static Optional<Difference> compareTiles(
method compareTiles (line 107) | public static Optional<Difference> compareTiles(
method compareLayer (line 136) | private static Optional<Difference> compareLayer(
method compareFeatures (line 152) | public static Optional<Difference> compareFeatures(
method compareFeature (line 195) | private static Optional<Difference> compareFeature(
method compareGeometry (line 226) | private static Optional<Difference> compareGeometry(
method propertyValuesEqual (line 256) | private static boolean propertyValuesEqual(Property pa, Property pb, i...
method compareProperties (line 275) | private static Optional<Difference> compareProperties(
method getAsymmetricSetDiff (line 351) | private static <T> Set<T> getAsymmetricSetDiff(Set<T> a, Set<T> b) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/CollectionUtils.java
class CollectionUtils (line 5) | public class CollectionUtils {
method CollectionUtils (line 6) | private CollectionUtils() {}
method unboxInts (line 8) | public static int[] unboxInts(Collection<? extends Number> values) {
method unboxLongs (line 17) | public static long[] unboxLongs(Collection<? extends Number> values) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/ColumnMapping.java
class ColumnMapping (line 15) | public class ColumnMapping {
method getPrefix (line 16) | public Pattern getPrefix() {
method getDelimiter (line 20) | public Pattern getDelimiter() {
method getUseSharedDictionaryEncoding (line 24) | public boolean getUseSharedDictionaryEncoding() {
method hasColumnNames (line 28) | public boolean hasColumnNames() {
method getColumnNames (line 32) | public Collection<String> getColumnNames() {
method ColumnMapping (line 37) | public ColumnMapping(Pattern prefix, Pattern delimiter, boolean useSha...
method ColumnMapping (line 41) | public ColumnMapping(String prefix, String delimiter, boolean useShare...
method ColumnMapping (line 50) | public ColumnMapping(Collection<String> columnNames, boolean useShared...
method ColumnMapping (line 54) | private ColumnMapping(
method isMatch (line 65) | public boolean isMatch(String propertyName) {
method findMapping (line 83) | public static @Nullable ColumnMapping findMapping(
method findMapping (line 94) | public static @Nullable ColumnMapping findMapping(
method toString (line 99) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/ColumnMappingConfig.java
class ColumnMappingConfig (line 10) | @SuppressWarnings("serial")
method ColumnMappingConfig (line 12) | public ColumnMappingConfig() {
method of (line 16) | public static ColumnMappingConfig of(
method toString (line 23) | public @Override String toString() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/ConversionConfig.java
class ConversionConfig (line 12) | @Builder(builderClassName = "ConfigBuilder", toBuilder = true)
class ConfigBuilder (line 43) | public static class ConfigBuilder {
method ConfigBuilder (line 45) | public ConfigBuilder() {}
type TypeMismatchPolicy (line 48) | public enum TypeMismatchPolicy {
type IntegerEncodingOption (line 54) | public enum IntegerEncodingOption {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/MltConverter.java
class MltConverter (line 40) | public class MltConverter {
method createTilesetMetadata (line 47) | public static MltMetadata.TileSetMetadata createTilesetMetadata(
method createTilesetMetadata (line 66) | public static MltMetadata.TileSetMetadata createTilesetMetadata(
method createTilesetMetadata (line 81) | public static MltMetadata.TileSetMetadata createTilesetMetadata(
method createTilesetMetadata (line 99) | public static MltMetadata.TileSetMetadata createTilesetMetadata(
method createTilesetMetadata (line 116) | private static MltMetadata.FeatureTable createTilesetMetadata(
method resolveColumnType (line 206) | private static void resolveColumnType(
method checkUpgrade (line 287) | private static MltMetadata.Column checkUpgrade(
method resolveComplexColumnMapping (line 323) | private static Pair<String, MltMetadata.ComplexField> resolveComplexCo...
method createTilesetMetadataJSON (line 349) | public static String createTilesetMetadataJSON(MltMetadata.TileSetMeta...
method writeColumnOrFieldType (line 398) | private static void writeColumnOrFieldType(
method createEmbeddedMetadata (line 461) | public static byte[] createEmbeddedMetadata(MltMetadata.FeatureTable t...
method encode (line 498) | public static byte[] encode(
method encode (line 520) | public static <T extends OutputStream> T encode(
method encodePropertyColumns (line 638) | @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
method sortFeaturesAndEncodeGeometryColumn (line 659) | @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
method filterPropertyColumns (line 737) | private static List<MltMetadata.Column> filterPropertyColumns(
method sortFeaturesById (line 744) | private static Stream<Feature> sortFeaturesById(Collection<Feature> fe...
method generateSequenceIds (line 749) | private static Stream<Feature> generateSequenceIds(Collection<Feature>...
method createScalarColumnScheme (line 755) | private static MltMetadata.Column createScalarColumnScheme(
method createScalarFieldScheme (line 763) | private static MltMetadata.Field createScalarFieldScheme(
method createComplexColumnScheme (line 770) | private static MltMetadata.Column createComplexColumnScheme(
method createComplexColumn (line 778) | private static MltMetadata.ComplexField createComplexColumn() {
method createColumn (line 782) | private static MltMetadata.Column createColumn(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/MortonSettings.java
class MortonSettings (line 3) | public final class MortonSettings {
method MortonSettings (line 7) | public MortonSettings(int numBits, int coordinateShift) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/BooleanEncoder.java
class BooleanEncoder (line 11) | public class BooleanEncoder {
method BooleanEncoder (line 13) | private BooleanEncoder() {}
method encodeBooleanStream (line 18) | public static ArrayList<byte[]> encodeBooleanStream(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/ByteRleEncoder.java
class ByteRleEncoder (line 16) | public class ByteRleEncoder {
method ByteRleEncoder (line 27) | public ByteRleEncoder() {
method writeValues (line 31) | private void writeValues() throws IOException {
method write (line 46) | public void write(byte value) throws IOException {
method flush (line 87) | public void flush() throws IOException {
method toByteArray (line 91) | public byte[] toByteArray() throws IOException {
method encode (line 97) | public static byte[] encode(byte[] values) throws IOException {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/DoubleEncoder.java
class DoubleEncoder (line 11) | public class DoubleEncoder {
method DoubleEncoder (line 13) | private DoubleEncoder() {}
method encodeDoubleStream (line 15) | public static ArrayList<byte[]> encodeDoubleStream(List<Double> values...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/EncodingUtils.java
class EncodingUtils (line 25) | public class EncodingUtils {
method gzip (line 34) | public static byte[] gzip(byte[] buffer) throws IOException {
method unzip (line 44) | public static byte[] unzip(byte[] buffer) throws IOException {
method encodeFloatsLE (line 53) | public static byte[] encodeFloatsLE(float[] values) {
method encodeDoublesLE (line 62) | public static byte[] encodeDoublesLE(double[] values) {
method encodeVarints (line 72) | public static byte[] encodeVarints(int[] values, boolean zigZagEncode,...
method encodeVarints (line 92) | public static byte[] encodeVarints(long[] values, boolean zigZagEncode...
method encodeVarints (line 112) | public static byte[] encodeVarints(
method encodeLongVarints (line 117) | public static byte[] encodeLongVarints(long[] values, boolean zigZagEn...
method encodeVarint (line 122) | public static byte[] encodeVarint(int value, boolean zigZagEncode) thr...
method putVarInt (line 139) | public static ByteBuffer putVarInt(int v, ByteBuffer sink) throws IOEx...
method putVarInt (line 149) | static ByteBuffer putVarInt(long v, ByteBuffer sink) throws IOException {
method putVarInt (line 159) | @SuppressWarnings("UnusedReturnValue")
method getVarIntSize (line 169) | public static int getVarIntSize(int value) {
method getVarLongSize (line 174) | public static int getVarLongSize(long value) {
method putString (line 179) | @SuppressWarnings("UnusedReturnValue")
method encodeZigZag (line 187) | public static long[] encodeZigZag(long[] values) {
method encodeZigZag (line 195) | public static int[] encodeZigZag(int[] values) {
method encodeZigZag (line 203) | public static long encodeZigZag(long value) {
method encodeZigZag (line 207) | public static int encodeZigZag(int value) {
method encodeDeltas (line 211) | public static long[] encodeDeltas(long[] values) {
method encodeDeltas (line 222) | public static int[] encodeDeltas(int[] values) {
method encodeRle (line 236) | public static Pair<int[], int[]> encodeRle(int[] values) {
method encodeRle (line 263) | public static Pair<long[], long[]> encodeRle(long[] values) {
method encodeFastPfor128 (line 285) | public static byte[] encodeFastPfor128(int[] values, boolean zigZagEnc...
method encodeByteRle (line 319) | public static byte[] encodeByteRle(byte[] values) throws IOException {
method encodeBooleanRle (line 323) | public static byte[] encodeBooleanRle(BitSet bitSet, int numValues) th...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/FloatEncoder.java
class FloatEncoder (line 11) | public class FloatEncoder {
method FloatEncoder (line 13) | private FloatEncoder() {}
method encodeFloatStream (line 15) | public static ArrayList<byte[]> encodeFloatStream(List<Float> values) ...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/GeometryEncoder.java
class GeometryEncoder (line 53) | public class GeometryEncoder {
method GeometryEncoder (line 63) | private GeometryEncoder() {}
method encodeGeometryColumn (line 65) | public static EncodedGeometryColumn encodeGeometryColumn(
method getVertexLimits (line 287) | private static MinMax<Integer> getVertexLimits(List<Vertex> vertexBuff...
method prepareGeometry (line 303) | private static void prepareGeometry(
method encodePolygonPretessellationStreams (line 384) | private static int encodePolygonPretessellationStreams(
method appendLengthStream (line 439) | private static boolean appendLengthStream(
method appendLengthStream (line 450) | private static boolean appendLengthStream(
method containsPolygon (line 472) | private static boolean containsPolygon(List<Geometry> geometries) {
method containsOnlyPolygons (line 479) | public static boolean containsOnlyPolygons(List<Integer> geometryTypes) {
method addLineString (line 487) | private static void addLineString(
method zigZagDeltaEncodeVertices (line 497) | public static int[] zigZagDeltaEncodeVertices(@NotNull final Collectio...
method zigZagDeltaEncodeVertices (line 501) | public static int[] zigZagDeltaEncodeVertices(@NotNull final Vertex[] ...
method zigZagDeltaEncodeVertices (line 506) | private static int[] zigZagDeltaEncodeVertices(
method getVertexOffsets (line 524) | private static int[] getVertexOffsets(
method reverseMap (line 536) | private static Map<Integer, Integer> reverseMap(IntStream mortonEncode...
method reverseMap (line 545) | private static Map<Integer, Integer> reverseMap(Collection<Integer> mo...
method reverseMap (line 551) | private static Map<Integer, Integer> reverseMap(int[] mortonEncodedDic...
method compareTo (line 557) | @Override
method distinctByHilbertId (line 564) | private static Predicate<Indexed> distinctByHilbertId() {
method addVerticesToDictionary (line 581) | private static Pair<int[], Vertex[]> addVerticesToDictionary(
method addVerticesToMortonDictionary (line 600) | private static int[] addVerticesToMortonDictionary(
method flatLineString (line 605) | private static List<Vertex> flatLineString(LineString lineString) {
method ringToLineString (line 611) | private static LineString ringToLineString(LinearRing ring, GeometryFa...
method flatPolygon (line 616) | private static void flatPolygon(
method encodeVertexBuffer (line 644) | private static ArrayList<byte[]> encodeVertexBuffer(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/IntegerEncoder.java
class IntegerEncoder (line 30) | public class IntegerEncoder {
class IntegerEncodingResult (line 32) | public static class IntegerEncodingResult {
type LogicalLevelIntegerTechnique (line 41) | enum LogicalLevelIntegerTechnique {
method IntegerEncoder (line 48) | private IntegerEncoder() {}
method encodeMortonStream (line 50) | public static ArrayList<byte[]> encodeMortonStream(
method encodeIntStream (line 72) | public static ArrayList<byte[]> encodeIntStream(
method encodeIntStream (line 88) | public static ArrayList<byte[]> encodeIntStream(
method encodeIntStream (line 104) | public static ArrayList<byte[]> encodeIntStream(
method encodeIntStream (line 121) | public static ArrayList<byte[]> encodeIntStream(
method encodeLongStream (line 160) | public static ArrayList<byte[]> encodeLongStream(
method encodeLongStream (line 170) | public static ArrayList<byte[]> encodeLongStream(
method encodeMortonCodes (line 207) | public static IntegerEncodingResult encodeMortonCodes(
method encodeInt (line 233) | public static IntegerEncodingResult encodeInt(
method encodeInt (line 242) | public static IntegerEncodingResult encodeInt(
method encodeLong (line 402) | public static IntegerEncodingResult encodeLong(long[] values, boolean ...
method encodeLong (line 406) | public static IntegerEncodingResult encodeLong(
method encodeFastPfor (line 553) | public static byte[] encodeFastPfor(int[] values, boolean signed) {
method encodeVarint (line 557) | public static byte[] encodeVarint(int[] values, boolean signed) throws...
method encodeLongVarint (line 561) | public static byte[] encodeLongVarint(long[] values, boolean signed) t...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/LinearRegression.java
class LinearRegression (line 6) | public class LinearRegression {
method calculateDeltas (line 8) | public static double[] calculateDeltas(double[] indices, double[] actu...
method calculatePredictions (line 19) | public static double[] calculatePredictions(double[] x, double[] theta) {
method h (line 28) | private static double h(double x, double[] theta) {
method computeCost (line 32) | public static double computeCost(double[] x, double[] y, double[] thet...
method gradientDescent (line 40) | public static double[] gradientDescent(
method arrayDiff (line 59) | public static double[] arrayDiff(double[] arr1, double[] arr2) {
method arrayPow (line 68) | public static double[] arrayPow(double[] arr, int power) {
method arrayMultiplication (line 77) | public static double[] arrayMultiplication(double[] arr1, double[] arr...
method arraySum (line 86) | public static double arraySum(double[] arr) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/MltTypeMap.java
class MltTypeMap (line 8) | public class MltTypeMap {
class Tag0x01 (line 9) | public static class Tag0x01 {
method encodeColumnType (line 19) | public static Optional<Integer> encodeColumnType(
method decodeColumnType (line 65) | public static MltMetadata.FieldType decodeColumnType(int typeCode) {
method getScalarType (line 82) | private static MltMetadata.ScalarType getScalarType(int typeCode) {
method columnTypeHasName (line 98) | public static boolean columnTypeHasName(int typeCode) {
method columnTypeHasChildren (line 102) | public static boolean columnTypeHasChildren(int typeCode) {
method isID (line 106) | public static boolean isID(MltMetadata.Column column) {
method isID (line 110) | public static boolean isID(MltMetadata.FieldType type) {
method isGeometry (line 114) | public static boolean isGeometry(MltMetadata.Column column) {
method isGeometry (line 118) | public static boolean isGeometry(MltMetadata.FieldType type) {
method isStruct (line 122) | public static boolean isStruct(MltMetadata.Column column) {
method isStruct (line 126) | public static boolean isStruct(MltMetadata.FieldType type) {
method hasStreamCount (line 130) | public static boolean hasStreamCount(MltMetadata.Column column) {
method hasStreamCount (line 134) | public static boolean hasStreamCount(MltMetadata.FieldType type) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/PropertyEncoder.java
class PropertyEncoder (line 28) | public class PropertyEncoder {
method encodePropertyColumns (line 30) | public static ArrayList<byte[]> encodePropertyColumns(
method encodeStructPropertyColumn (line 81) | private static ArrayList<byte[]> encodeStructPropertyColumn(
method encodeScalarPropertyColumn (line 146) | private static ArrayList<byte[]> encodeScalarPropertyColumn(
method getBooleanPropertyValue (line 171) | private static Boolean getBooleanPropertyValue(@NotNull Feature featur...
method strictIntOrNull (line 179) | private static Integer strictIntOrNull(@Nullable Long value) {
method strictIntOrNull (line 183) | private static Integer strictIntOrNull(@Nullable U64 value) {
method strictIntOrNull (line 189) | private static Integer strictIntOrNull(@Nullable Float value) {
method strictIntOrNull (line 193) | private static Integer strictIntOrNull(@Nullable Double value) {
method strictLongOrNull (line 197) | private static Long strictLongOrNull(@Nullable Float value) {
method strictLongOrNull (line 201) | private static Long strictLongOrNull(@Nullable Double value) {
method strictFloatOrNull (line 205) | private static Float strictFloatOrNull(@Nullable Double value) {
method getIntPropertyValue (line 209) | private static Integer getIntPropertyValue(@NotNull Feature feature, @...
method getLongPropertyValue (line 229) | private static Long getLongPropertyValue(@NotNull Feature feature, @No...
method getFloatPropertyValue (line 248) | private static Float getFloatPropertyValue(@NotNull Feature feature, @...
method getDoublePropertyValue (line 266) | private static Double getDoublePropertyValue(@NotNull Feature feature,...
method getStringPropertyValue (line 284) | private static String getStringPropertyValue(
method encodeScalarPropertyColumn (line 298) | public static ArrayList<byte[]> encodeScalarPropertyColumn(
method encodeStringColumn (line 343) | private static ArrayList<byte[]> encodeStringColumn(
method encodeBooleanColumn (line 388) | private static ArrayList<byte[]> encodeBooleanColumn(
method encodeFloatColumn (line 440) | private static ArrayList<byte[]> encodeFloatColumn(
method encodeDoubleColumn (line 467) | private static ArrayList<byte[]> encodeDoubleColumn(
method encodeInt32Column (line 494) | private static ArrayList<byte[]> encodeInt32Column(
method encodeInt64Column (line 544) | private static ArrayList<byte[]> encodeInt64Column(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/StringEncoder.java
class StringEncoder (line 28) | public class StringEncoder {
method StringEncoder (line 30) | private StringEncoder() {}
method encodeSharedDictionary (line 34) | public static Pair<Integer, ArrayList<byte[]>> encodeSharedDictionary(
method encode (line 136) | public static Pair<Integer, ArrayList<byte[]>> encode(
method encodeFsstDictionary (line 173) | private static ArrayList<byte[]> encodeFsstDictionary(
method encodeFsst (line 209) | private static ArrayList<byte[]> encodeFsst(
method totalLengthOf (line 272) | private static int totalLengthOf(Collection<String> values) {
method encodeDictionary (line 276) | private static ArrayList<byte[]> encodeDictionary(
method encodePlain (line 346) | public static ArrayList<byte[]> encodePlain(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/Fsst.java
type Fsst (line 5) | public interface Fsst {
method encode (line 7) | SymbolTable encode(byte[] data);
method decode (line 9) | default byte[] decode(SymbolTable encoded) {
method decode (line 17) | default byte[] decode(
method decode (line 50) | @Deprecated
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstDebug.java
class FsstDebug (line 7) | class FsstDebug implements Fsst {
method encode (line 28) | @Override
method printStats (line 43) | public static String printStats() {
method printStatsOnce (line 63) | public static String printStatsOnce() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstEncoder.java
class FsstEncoder (line 3) | public class FsstEncoder {
method useNative (line 6) | public static boolean useNative(boolean value) {
method getInstance (line 20) | private static Fsst getInstance() {
method FsstEncoder (line 27) | private FsstEncoder() {}
method encode (line 29) | public static SymbolTable encode(byte[] data) {
method decode (line 33) | public static byte[] decode(
method decode (line 41) | @Deprecated
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstJava.java
class FsstJava (line 3) | class FsstJava implements Fsst {
method encode (line 5) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstJni.java
class FsstJni (line 5) | public class FsstJni implements Fsst {
method encode (line 28) | public SymbolTable encode(byte[] data) {
method isLoaded (line 32) | public static boolean isLoaded() {
method getLoadError (line 36) | public static UnsatisfiedLinkError getLoadError() {
method compress (line 40) | public static native SymbolTable compress(byte[] inputBytes);
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/Symbol.java
class Symbol (line 13) | class Symbol implements Comparable<Symbol> {
method Symbol (line 19) | private Symbol(byte[] bytes, int hashcode) {
method of (line 25) | public static Symbol of(int b) {
method concat (line 29) | public static Symbol concat(Symbol a, Symbol b) {
method equals (line 42) | @Override
method hashCode (line 47) | @Override
method length (line 52) | public int length() {
method bytes (line 56) | public byte[] bytes() {
method compareTo (line 60) | @Override
method first (line 77) | public int first() {
method match (line 85) | public boolean match(ByteBuffer text, int offset, int ignore) {
method toString (line 99) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/SymbolTable.java
method toString (line 16) | @Override
method weight (line 31) | public int weight() {
method equals (line 35) | @Override
method hashCode (line 44) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/SymbolTableBuilder.java
class SymbolTableBuilder (line 49) | class SymbolTableBuilder {
method SymbolTableBuilder (line 73) | private SymbolTableBuilder(int sampleSize) {
method encode (line 81) | public static SymbolTable encode(byte[] data) {
method buildSymbolTable (line 86) | public static SymbolTableBuilder buildSymbolTable(ByteBuffer data, int...
method sortSymbolsByLength (line 110) | private SymbolTableBuilder sortSymbolsByLength() {
method encode (line 130) | private SymbolTable encode(ByteBuffer text) {
method encodeText (line 143) | private byte[] encodeText(ByteBuffer text, int[] lens) {
method isEscapeCode (line 159) | private static boolean isEscapeCode(int code) {
method addOrInc (line 163) | private static void addOrInc(Map<Symbol, Long> cands, Symbol s, long c...
method add (line 170) | private void add(Symbol symbol) {
method findLongestSymbol (line 174) | private int findLongestSymbol(ByteBuffer text, int offset) {
method ranges (line 203) | private List<Range> ranges(int size) {
method compressCount (line 216) | private long compressCount(Counters counters, ByteBuffer text, boolean...
method makeTable (line 262) | private SymbolTableBuilder makeTable(Counters counters, boolean lastPa...
method finish (line 308) | public SymbolTableBuilder finish() {
method compareTo (line 332) | @Override
class Counters (line 338) | static class Counters {
method count1Inc (line 342) | public void count1Inc(int pos1) {
method count2Inc (line 346) | public void count2Inc(int pos1, int pos2) {
method count1GetNext (line 350) | public int count1GetNext(int pos1) {
method count2GetNext (line 354) | public int count2GetNext(int pos1, int pos2) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/GeometryType.java
type GeometryType (line 3) | public enum GeometryType {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/GeometryUtils.java
class GeometryUtils (line 11) | public class GeometryUtils {
method GeometryUtils (line 13) | private GeometryUtils() {}
method sortVertexOffsets (line 15) | public static void sortVertexOffsets(
method sortPoints (line 69) | public static void sortPoints(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/Hilbert.java
class Hilbert (line 8) | public class Hilbert {
method Hilbert (line 9) | private Hilbert() {
method deinterleave (line 13) | private static int deinterleave(int tx) {
method interleave (line 22) | private static int interleave(int tx) {
method prefixScan (line 30) | private static int prefixScan(int tx) {
method hilbertPositionToXY (line 42) | public static int[] hilbertPositionToXY(int level, int pos) {
method hilbertXYToIndex (line 62) | public static int hilbertXYToIndex(int level, int x, int y) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/HilbertCurve.java
class HilbertCurve (line 3) | public class HilbertCurve extends SpaceFillingCurve {
method HilbertCurve (line 5) | public HilbertCurve(int minVertexValue, int maxVertexValue) {
method encode (line 9) | public int encode(Vertex vertex) {
method decode (line 15) | public int[] decode(int hilbertIndex) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/SpaceFillingCurve.java
class SpaceFillingCurve (line 3) | public abstract class SpaceFillingCurve {
method isRangeSupported (line 13) | public static boolean isRangeSupported(int minVertexValue, int maxVert...
method SpaceFillingCurve (line 17) | public SpaceFillingCurve(int minVertexValue, int maxVertexValue) {
method validateCoordinates (line 35) | protected void validateCoordinates(Vertex vertex) {
method getCoordinateShift (line 46) | private static int getCoordinateShift(int minVertexValue) {
method encode (line 53) | public abstract int encode(Vertex vertex);
method decode (line 55) | public abstract int[] decode(int mortonCode);
method numBits (line 57) | public int numBits() {
method coordinateShift (line 61) | public int coordinateShift() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/ZOrderCurve.java
class ZOrderCurve (line 3) | public class ZOrderCurve extends SpaceFillingCurve {
method ZOrderCurve (line 5) | public ZOrderCurve(int minVertexValue, int maxVertexValue) {
method encode (line 9) | public int encode(Vertex vertex) {
method decode (line 20) | public int[] decode(int mortonCode) {
method decodeMorton (line 26) | private int decodeMorton(int code) {
method decode (line 34) | public static int[] decode(int mortonCode, int numBits, int coordinate...
method decodeMorton (line 40) | private static int decodeMorton(int code, int numBits) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/mvt/MvtUtils.java
class MvtUtils (line 21) | public class MvtUtils {
method decodeMvt (line 23) | public static MapboxVectorTile decodeMvt(Path mvtFilePath) throws IOEx...
method decodeMvtFast (line 29) | public static List<VectorTileDecoder.Feature> decodeMvtFast(byte[] mvt...
method decodeMvtMapbox (line 40) | public static Map<String, VectorTileLayer> decodeMvtMapbox(byte[] mvtT...
method decodeMvt (line 53) | public static MapboxVectorTile decodeMvt(byte[] mvtTile) throws IOExce...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/converter/tessellation/TessellationUtils.java
class TessellationUtils (line 21) | public class TessellationUtils {
method TessellationUtils (line 22) | private TessellationUtils() {}
method tessellatePolygon (line 24) | public static TessellatedPolygon tessellatePolygon(
method tessellatePolygonRemote (line 53) | private static int[] tessellatePolygonRemote(
method tessellateMultiPolygon (line 89) | public static TessellatedPolygon tessellateMultiPolygon(
method flatCoordinatesWithoutClosingPoint (line 113) | private static double[] flatCoordinatesWithoutClosingPoint(Polygon pol...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/Feature.java
class Feature (line 17) | @SuperBuilder(toBuilder = true)
method getProperties (line 31) | public Iterable<Property> getProperties() {
method getPropertyStream (line 35) | public Stream<Property> getPropertyStream() {
method findProperty (line 39) | public Optional<Property> findProperty(@NotNull Predicate<Property> pr...
method findProperty (line 43) | public Optional<Property> findProperty(@NotNull String name) {
method findProperty (line 47) | public Optional<Property> findProperty(
method idOrNull (line 62) | @Nullable
class FeatureBuilder (line 67) | public abstract static class FeatureBuilder<C extends Feature, B exten...
method id (line 68) | public B id(long id) {
method id (line 74) | public B id(@Nullable Long id) {
method toBuilder (line 79) | public abstract FeatureBuilder<?, ?> toBuilder();
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/FeatureInterface.java
type FeatureInterface (line 11) | public interface FeatureInterface {
method hasId (line 12) | boolean hasId();
method getId (line 14) | long getId();
method getGeometry (line 16) | @NotNull
method getProperties (line 19) | Iterable<Property> getProperties();
method getPropertyStream (line 21) | Stream<Property> getPropertyStream();
method getPropertyStream (line 23) | Stream<Property> getPropertyStream(boolean parallel);
method findProperty (line 25) | Optional<Property> findProperty(@NotNull Predicate<Property> predicate);
method findProperty (line 27) | Optional<Property> findProperty(@NotNull String name);
method findProperty (line 29) | Optional<Property> findProperty(@NotNull String name, @NotNull MltMeta...
method idOrNull (line 36) | @Nullable
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/IndexedProperty.java
class IndexedProperty (line 7) | public class IndexedProperty extends Property {
method IndexedProperty (line 10) | public IndexedProperty(
method getValue (line 16) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/LayerSource.java
type LayerSource (line 6) | public interface LayerSource {
method getLayerCount (line 7) | default long getLayerCount() {
method getLayers (line 11) | @NotNull
method getLayerStream (line 16) | @NotNull
method getLayerStream (line 21) | @NotNull
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/MLTFeature.java
class MLTFeature (line 14) | @SuperBuilder(toBuilder = true)
method findProperty (line 19) | @Override
method getPropertyStream (line 24) | @Override
method adapt (line 30) | static Property adapt(String name, Object value) {
method adapt (line 34) | static Property adapt(Map.Entry<String, Object> entry) {
method getType (line 38) | static MltMetadata.FieldType getType(Object value) {
class MLTFeatureBuilder (line 52) | public abstract static class MLTFeatureBuilder<
method rawProperties (line 61) | public B rawProperties(Map<String, Object> rawProperties) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/MVTFeature.java
class MVTFeature (line 16) | @SuperBuilder(toBuilder = true)
method getRawProperties (line 21) | public Map<String, Object> getRawProperties() {
method findProperty (line 25) | @Override
method getPropertyStream (line 30) | @Override
method adapt (line 36) | static Property adapt(String name, Object value) {
method adapt (line 42) | static Property adapt(Map.Entry<String, Object> entry) {
method getType (line 46) | static MltMetadata.ScalarType getType(Object value) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/MapLibreTile.java
class MapLibreTile (line 7) | public class MapLibreTile implements LayerSource {
method MapLibreTile (line 10) | public MapLibreTile(@NotNull Collection<Layer> layers) {
method getLayerStream (line 14) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/MapboxVectorTile.java
class MapboxVectorTile (line 9) | public class MapboxVectorTile implements LayerSource {
method MapboxVectorTile (line 13) | public MapboxVectorTile(@NotNull SequencedCollection<Layer> layers) {
method MapboxVectorTile (line 17) | public MapboxVectorTile(
method setTileId (line 24) | public void setTileId(@Nullable Triple<Integer, Integer, Integer> tile...
method tileId (line 28) | public @Nullable Triple<Integer, Integer, Integer> tileId() {
method getLayerCount (line 32) | @Override
method getLayerStream (line 37) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/Property.java
class Property (line 9) | public class Property {
method Property (line 22) | public Property(@NotNull MltMetadata.FieldType type, String name, Obje...
method getValue (line 41) | public Object getValue(int featureIndex) {
method isNested (line 45) | private static boolean isNested(MltMetadata.FieldType type) {
method isNested (line 53) | public boolean isNested() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/unsigned/U32.java
method of (line 5) | public static U32 of(long value) {
method byteValue (line 12) | @Override
method intValue (line 21) | @Override
method longValue (line 26) | @Override
method toString (line 31) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/unsigned/U64.java
method of (line 7) | public static U64 of(BigInteger value) {
method byteValue (line 14) | @Override
method intValue (line 23) | @Override
method longValue (line 32) | @Override
method toString (line 37) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/unsigned/U8.java
method of (line 5) | public static U8 of(int value) {
method byteValue (line 12) | @Override
method intValue (line 17) | @Override
method longValue (line 22) | @Override
method toString (line 27) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/data/unsigned/Unsigned.java
type Unsigned (line 10) | public sealed interface Unsigned permits U8, U32, U64 {
method byteValue (line 11) | Byte byteValue();
method intValue (line 13) | Integer intValue();
method longValue (line 15) | Long longValue();
method toString (line 17) | @Override
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/ByteRleDecoder.java
class ByteRleDecoder (line 15) | public class ByteRleDecoder {
method ByteRleDecoder (line 24) | public ByteRleDecoder(byte[] data, int offset, int length) {
method readValues (line 28) | private void readValues() {
method next (line 45) | public byte next() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/DecodingUtils.java
class DecodingUtils (line 19) | public class DecodingUtils {
method DecodingUtils (line 21) | private DecodingUtils() {}
method decodeVarints (line 24) | public static int[] decodeVarints(byte[] src, IntWrapper pos, int numV...
method decodeLongVarints (line 35) | public static long[] decodeLongVarints(byte[] src, IntWrapper pos, int...
method decodeLongVarint (line 44) | public static long decodeLongVarint(byte[] bytes, IntWrapper pos) {
method decodeVarint (line 77) | private static int decodeVarint(byte[] src, int srcOffset, int[] dst, ...
method decodeVarintWithLength (line 86) | public static Pair<Integer, Integer> decodeVarintWithLength(InputStrea...
method decodeVarint (line 117) | public static int decodeVarint(InputStream stream) throws IOException {
method decodeString (line 121) | public static String decodeString(InputStream stream) throws IOExcepti...
method decodeZigZag (line 126) | public static int decodeZigZag(int encoded) {
method decodeZigZag (line 130) | public static long decodeZigZag(long encoded) {
method decodeFastPfor (line 134) | public static int[] decodeFastPfor(
method decodeFastPforDeltaCoordinates (line 158) | public static int[] decodeFastPforDeltaCoordinates(
method decodeByteRle (line 204) | public static byte[] decodeByteRle(byte[] buffer, int numBytes, int by...
method decodeBooleanRle (line 216) | public static BitSet decodeBooleanRle(
method decodeUnsignedRLE (line 224) | public static int[] decodeUnsignedRLE(int[] data, int numRuns, int num...
method decodeUnsignedRLE (line 239) | public static long[] decodeUnsignedRLE(long[] data, int numRuns, int n...
method decodeFloatsLE (line 254) | public static float[] decodeFloatsLE(byte[] encodedValues, IntWrapper ...
method decodeDoublesLE (line 265) | public static double[] decodeDoublesLE(byte[] encodedValues, IntWrappe...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/DoubleDecoder.java
class DoubleDecoder (line 10) | public class DoubleDecoder {
method DoubleDecoder (line 11) | private DoubleDecoder() {}
method decodeDoubleStream (line 13) | public static List<Double> decodeDoubleStream(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/FloatDecoder.java
class FloatDecoder (line 8) | public class FloatDecoder {
method FloatDecoder (line 9) | private FloatDecoder() {}
method decodeFloatStream (line 11) | public static List<Float> decodeFloatStream(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/GeometryDecoder.java
class GeometryDecoder (line 24) | public class GeometryDecoder {
method GeometryDecoder (line 36) | private GeometryDecoder() {}
method decodeGeometryColumn (line 38) | public static GeometryColumn decodeGeometryColumn(byte[] tile, int num...
method decodeGeometry (line 123) | public static Geometry[] decodeGeometry(GeometryColumn geometryColumn) {
method getLinearRing (line 314) | private static LinearRing getLinearRing(
method decodeDictionaryEncodedLinearRing (line 320) | private static LinearRing decodeDictionaryEncodedLinearRing(
method getLineString (line 332) | private static Coordinate[] getLineString(
method decodeDictionaryEncodedLineString (line 347) | private static Coordinate[] decodeDictionaryEncodedLineString(
method decodeMortonDictionaryEncodedLineString (line 372) | private static Coordinate[] decodeMortonDictionaryEncodedLineString(
method containsPolygon (line 396) | public static boolean containsPolygon(List<Integer> geometryTypes) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/IntegerDecoder.java
class IntegerDecoder (line 16) | public class IntegerDecoder {
method IntegerDecoder (line 18) | private IntegerDecoder() {}
method decodeMortonStream (line 20) | public static List<Integer> decodeMortonStream(
method decodeMortonDelta (line 41) | private static List<Integer> decodeMortonDelta(int[] data, int numBits...
method decodeMortonCodes (line 55) | private static List<Integer> decodeMortonCodes(int[] data, int numBits...
method decodeMortonCode (line 66) | private static int[] decodeMortonCode(int mortonCode, int numBits, int...
method decodeMorton (line 72) | private static int decodeMorton(int code, int numBits) {
method decodeIntStream (line 80) | public static List<Integer> decodeIntStream(
method decodeIntArray (line 99) | private static List<Integer> decodeIntArray(
method decodeLongStream (line 142) | public static List<Long> decodeLongStream(
method decodeLongArray (line 148) | private static List<Long> decodeLongArray(
method decodeRLE (line 183) | private static List<Integer> decodeRLE(int[] data, int numRuns, int nu...
method decodeRLE (line 197) | private static List<Long> decodeRLE(long[] data, int numRuns, int numR...
method decodeZigZagDelta (line 210) | private static List<Integer> decodeZigZagDelta(int[] data) {
method decodeZigZagDelta (line 223) | private static List<Long> decodeZigZagDelta(long[] data) {
method decodeZigZag (line 236) | private static List<Long> decodeZigZag(long[] data) {
method decodeZigZag (line 245) | private static List<Integer> decodeZigZag(int[] data) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/MltDecoder.java
class MltDecoder (line 27) | public class MltDecoder {
method MltDecoder (line 29) | private MltDecoder() {}
method parseBasicMVTEquivalent (line 31) | private static Layer parseBasicMVTEquivalent(int layerSize, InputStrea...
method decodeMlTile (line 43) | public static MapLibreTile decodeMlTile(byte[] tileData) throws IOExce...
method decodeMltLayer (line 65) | public static Layer decodeMltLayer(
method sizeList (line 158) | private static void sizeList(
method convertToLayer (line 169) | private static Layer convertToLayer(
method mergeFail (line 199) | private static Property mergeFail(Property a, Property ignored) {
method decodeColumn (line 203) | private static MltMetadata.Column decodeColumn(InputStream stream) thr...
method parseEmbeddedMetadata (line 230) | public static Pair<MltMetadata.FeatureTable, Integer> parseEmbeddedMet...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/PropertyDecoder.java
class PropertyDecoder (line 13) | public class PropertyDecoder {
method PropertyDecoder (line 15) | private PropertyDecoder() {}
method unpack (line 18) | private static <T> List<T> unpack(
method unpack (line 32) | private static List<Boolean> unpack(
method decodeScalarPropertyColumn (line 44) | private static Object decodeScalarPropertyColumn(
method toUnsignedBigInteger (line 124) | private static BigInteger toUnsignedBigInteger(Long value) {
method decodePropertyColumn (line 131) | public static Object decodePropertyColumn(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/StringDecoder.java
class StringDecoder (line 21) | public final class StringDecoder {
method StringDecoder (line 23) | private StringDecoder() {}
method decodeSharedDictionary (line 25) | public static Triple<HashMap<String, Integer>, HashMap<String, BitSet>...
method decodeDictionary (line 137) | private static List<String> decodeDictionary(List<Integer> lengthStrea...
method decode (line 151) | public static Triple<Integer, BitSet, List<String>> decode(
method decodePlain (line 228) | private static List<String> decodePlain(
method decodeDictionary (line 252) | private static List<String> decodeDictionary(
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/decoder/vectorized/VectorizedDecodingUtils.java
class VectorizedDecodingUtils (line 13) | public class VectorizedDecodingUtils {
method VectorizedDecodingUtils (line 14) | private VectorizedDecodingUtils() {}
method decodeFastPfor (line 18) | public static IntBuffer decodeFastPfor(
method decodeComponentwiseDeltaVec2 (line 47) | public static void decodeComponentwiseDeltaVec2(int[] data) {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/json/Json.java
class Json (line 23) | public final class Json {
method Json (line 36) | private Json() {}
method toJson (line 47) | public static String toJson(MapboxVectorTile tile, boolean pretty) {
method toJson (line 60) | public static String toJson(MapLibreTile tile, boolean pretty) {
method toGeoJson (line 72) | public static String toGeoJson(MapLibreTile tile, boolean pretty) {
method createGson (line 77) | private static Gson createGson(boolean pretty) {
method floatToken (line 88) | private static Object floatToken(Float value) {
method doubleToken (line 99) | private static Object doubleToken(Double value) {
method floatsAsStrings (line 111) | private static Object floatsAsStrings(Object obj) {
method toJsonObjects (line 129) | private static Map<String, Object> toJsonObjects(MapLibreTile mlTile) {
method toJson (line 133) | private static Map<String, Object> toJson(Layer layer) {
method toJson (line 141) | private static Map<String, Object> toJson(Feature feature) {
method toGeoJsonObjects (line 164) | public static Map<String, Object> toGeoJsonObjects(MapLibreTile mlTile...
method featureToGeoJson (line 179) | private static Map<String, Object> featureToGeoJson(Layer layer, Featu...
method failOnDuplicate (line 196) | private static Object failOnDuplicate(Object a, Object b) {
method getSortedNonNullProperties (line 200) | private static SortedMap<String, Object> getSortedNonNullProperties(Fe...
method geometryToGeoJson (line 212) | private static Map<String, Object> geometryToGeoJson(Geometry geometry...
method intifyCoordinates (line 226) | private static Object intifyCoordinates(Object obj) {
method toJsonObjects (line 241) | private static Map<String, Object> toJsonObjects(MapboxVectorTile mvTi...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/DictionaryType.java
type DictionaryType (line 3) | public enum DictionaryType {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/LengthType.java
type LengthType (line 3) | public enum LengthType {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/LogicalLevelTechnique.java
type LogicalLevelTechnique (line 3) | public enum LogicalLevelTechnique {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/LogicalStreamType.java
class LogicalStreamType (line 3) | public class LogicalStreamType {
method LogicalStreamType (line 8) | public LogicalStreamType(DictionaryType dictionaryType) {
method LogicalStreamType (line 12) | public LogicalStreamType(OffsetType offsetType) {
method LogicalStreamType (line 16) | public LogicalStreamType(LengthType lengthType) {
method dictionaryType (line 20) | public DictionaryType dictionaryType() {
method offsetType (line 24) | public OffsetType offsetType() {
method lengthType (line 28) | public LengthType lengthType() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/MortonEncodedStreamMetadata.java
class MortonEncodedStreamMetadata (line 9) | public class MortonEncodedStreamMetadata extends StreamMetadata {
method MortonEncodedStreamMetadata (line 14) | public MortonEncodedStreamMetadata(
method encode (line 36) | public ArrayList<byte[]> encode() throws IOException {
method decodePartial (line 42) | public static MortonEncodedStreamMetadata decodePartial(
method numBits (line 57) | public int numBits() {
method coordinateShift (line 61) | public int coordinateShift() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/OffsetType.java
type OffsetType (line 3) | public enum OffsetType {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/PhysicalLevelTechnique.java
type PhysicalLevelTechnique (line 3) | public enum PhysicalLevelTechnique {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/PhysicalStreamType.java
type PhysicalStreamType (line 3) | public enum PhysicalStreamType {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/RleEncodedStreamMetadata.java
class RleEncodedStreamMetadata (line 9) | public class RleEncodedStreamMetadata extends StreamMetadata {
method RleEncodedStreamMetadata (line 22) | public RleEncodedStreamMetadata(
method encode (line 44) | public ArrayList<byte[]> encode() throws IOException {
method decodePartial (line 50) | public static RleEncodedStreamMetadata decodePartial(
method runs (line 65) | public int runs() {
method numRleValues (line 69) | public int numRleValues() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/StreamMetadata.java
class StreamMetadata (line 10) | public class StreamMetadata {
method StreamMetadata (line 21) | public StreamMetadata(
method getLogicalType (line 38) | private int getLogicalType() {
method encode (line 54) | public ArrayList<byte[]> encode() throws IOException {
method encode (line 58) | public ArrayList<byte[]> encode(int estimatedAdditionalStreams) throws...
method decode (line 79) | public static StreamMetadata decode(byte[] tile, IntWrapper offset) th...
method physicalStreamType (line 110) | public PhysicalStreamType physicalStreamType() {
method logicalStreamType (line 114) | public LogicalStreamType logicalStreamType() {
method logicalLevelTechnique1 (line 118) | public LogicalLevelTechnique logicalLevelTechnique1() {
method logicalLevelTechnique2 (line 122) | public LogicalLevelTechnique logicalLevelTechnique2() {
method physicalLevelTechnique (line 126) | public PhysicalLevelTechnique physicalLevelTechnique() {
method numValues (line 130) | public int numValues() {
method byteLength (line 134) | public int byteLength() {
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/stream/StreamMetadataDecoder.java
class StreamMetadataDecoder (line 6) | public class StreamMetadataDecoder {
method decode (line 8) | public static StreamMetadata decode(byte[] tile, IntWrapper offset) th...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/metadata/tileset/MltMetadata.java
class MltMetadata (line 11) | public final class MltMetadata {
method MltMetadata (line 12) | private MltMetadata() {}
method scalarFieldType (line 14) | public static FieldType scalarFieldType(@NotNull ScalarType type, bool...
method idFieldType (line 18) | public static FieldType idFieldType(boolean hasLongId, boolean isNulla...
method structFieldType (line 22) | public static FieldType structFieldType(@Nullable SequencedCollection<...
method geometryFieldType (line 26) | public static FieldType geometryFieldType() {
method complexFieldType (line 30) | public static FieldType complexFieldType(@NotNull ComplexType type, bo...
type ColumnScope (line 35) | public enum ColumnScope {
type ScalarType (line 43) | public enum ScalarType {
type ComplexType (line 57) | public enum ComplexType {
type LogicalScalarType (line 64) | public enum LogicalScalarType {
type LogicalComplexType (line 69) | public enum LogicalComplexType {
class TileSetMetadata (line 80) | public static final class TileSetMetadata {
method FeatureTable (line 104) | public FeatureTable(String name) {
method FeatureTable (line 108) | public FeatureTable(String name, int initialColumnCapacity) {
method FieldType (line 129) | public FieldType(@Nullable ScalarField scalarType, boolean isNullable) {
method FieldType (line 136) | public FieldType(@Nullable ComplexField complexType, boolean isNullabl...
method is (line 143) | public boolean is(ScalarType type) {
method is (line 150) | public boolean is(LogicalScalarType type) {
method is (line 157) | public boolean is(ComplexType type) {
method is (line 164) | public boolean is(LogicalComplexType type) {
method getScalarType (line 171) | public Optional<ScalarType> getScalarType() {
method getLogicalScalarType (line 178) | public Optional<LogicalScalarType> getLogicalScalarType() {
method getComplexType (line 185) | public Optional<ComplexType> getComplexType() {
method getLogicalComplexType (line 194) | public Optional<LogicalComplexType> getLogicalComplexType() {
method getChildren (line 202) | public Optional<SequencedCollection<Field>> getChildren() {
method Field (line 215) | public Field(@NotNull FieldType type) {
method Column (line 236) | public Column(Field field) {
method Column (line 242) | public Column(FieldType type) {
method getName (line 248) | public String getName() {
method isNullable (line 254) | public boolean isNullable() {
method isScalar (line 260) | public boolean isScalar() {
method isComplex (line 266) | public boolean isComplex() {
method is (line 273) | public boolean is(ScalarType type) {
method is (line 280) | public boolean is(LogicalScalarType type) {
method is (line 287) | public boolean is(ComplexType type) {
method is (line 294) | public boolean is(LogicalComplexType type) {
method getScalarType (line 301) | public Optional<ScalarType> getScalarType() {
method getLogicalScalarType (line 308) | public Optional<LogicalScalarType> getLogicalScalarType() {
method getComplexType (line 315) | public Optional<ComplexType> getComplexType() {
method getLogicalComplexType (line 322) | public Optional<LogicalComplexType> getLogicalComplexType() {
method getChildren (line 328) | public Optional<SequencedCollection<Field>> getChildren() {
method ScalarField (line 351) | public ScalarField(@NotNull ScalarType type) {
method ScalarField (line 358) | public ScalarField(@NotNull LogicalScalarType type, boolean hasLongId) {
method ComplexField (line 382) | public ComplexField(@NotNull ComplexType type) {
method ComplexField (line 389) | public ComplexField(@NotNull ComplexType type, @Nullable SequencedColl...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/util/ByteArrayUtil.java
class ByteArrayUtil (line 8) | public final class ByteArrayUtil {
method ByteArrayUtil (line 9) | private ByteArrayUtil() {}
method totalLength (line 11) | public static int totalLength(Collection<byte[]> buffers) {
method concat (line 15) | public static <T extends OutputStream> T concat(T stream, Collection<b...
method concat (line 23) | public static byte[] concat(Collection<byte[]> buffers) throws IOExcep...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/util/ExceptionUtil.java
class ExceptionUtil (line 6) | public class ExceptionUtil {
type ThrowingFunction (line 7) | @FunctionalInterface
method apply (line 9) | R apply(T t) throws E;
method unchecked (line 14) | public static <T, R, E extends Exception> Function<T, R> unchecked(Thr...
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/util/OptionalUtil.java
class OptionalUtil (line 8) | public class OptionalUtil {
method isLessThan (line 11) | @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
method isLessThan (line 19) | @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
method map (line 33) | @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
FILE: java/mlt-core/src/main/java/org/maplibre/mlt/util/StreamUtil.java
class StreamUtil (line 15) | public final class StreamUtil {
method StreamUtil (line 16) | private StreamUtil() {}
method zip (line 37) | public static <A, B, C> Stream<C> zip(
class ZipIterator (line 65) | private static final class ZipIterator<A, B, C> implements Iterator<C> {
method ZipIterator (line 70) | ZipIterator(
method hasNext (line 79) | @Override
method next (line 85) | @Override
method zip (line 92) | public static <A, B> Stream<Pair<A, B>> zip(Stream<? extends A> a, Str...
method zipEach (line 98) | public static <A, B> long zipEach(
method ofType (line 115) | public static <Target extends Base, Base> Function<Base, Stream<Target...
method optionalOfType (line 126) | public static <Target extends Base, Base> Function<Base, Optional<Targ...
FILE: java/mlt-core/src/main/java/springmeyer/Pbf.java
class Pbf (line 9) | public class Pbf {
method Pbf (line 22) | public Pbf(byte[] buf) {
method readFields (line 29) | public <T> T readFields(ReadField<T> readField, T result, int end) {
method readFloat (line 45) | public float readFloat() {
method readFixed64 (line 51) | public long readFixed64() {
method readDouble (line 59) | public double readDouble() {
method readVarint (line 65) | public int readVarint() {
method readVarint (line 69) | public int readVarint(boolean isSigned) {
method readVarintRemainder (line 91) | private int readVarintRemainder(int val, boolean isSigned) {
method toNum (line 114) | private static int toNum(int low, int high, boolean isSigned) {
method readVarint64 (line 121) | public long readVarint64() {
method readSVarint (line 125) | public int readSVarint() {
method readBoolean (line 130) | public boolean readBoolean() {
method readString (line 134) | public String readString() {
method readBytes (line 141) | public byte[] readBytes() {
method skip (line 149) | public void skip(int val) {
method readUInt32 (line 164) | private static int readUInt32(byte[] buf, int pos) {
method readInt32 (line 171) | private static int readInt32(byte[] buf, int pos) {
type ReadField (line 178) | @FunctionalInterface
method read (line 180) | void read(int tag, T result, Pbf pbf);
FILE: java/mlt-core/src/main/java/springmeyer/Point.java
class Point (line 3) | public class Point {
method Point (line 7) | public Point(int x, int y) {
method clone (line 12) | public Point clone() {
method toString (line 16) | public String toString() {
FILE: java/mlt-core/src/main/java/springmeyer/VectorTile.java
class VectorTile (line 8) | public class VectorTile {
method VectorTile (line 11) | public VectorTile(Pbf pbf, int end) throws IllegalArgumentException {
method readTile (line 15) | private static void readTile(int tag, Map<String, VectorTileLayer> lay...
FILE: java/mlt-core/src/main/java/springmeyer/VectorTileFeature.java
class VectorTileFeature (line 8) | public class VectorTileFeature {
method VectorTileFeature (line 21) | @SuppressWarnings("this-escape")
method readFeature (line 35) | private void readFeature(int tag, VectorTileFeature feature, Pbf pbf) {
method readTag (line 47) | private void readTag(Pbf pbf, VectorTileFeature feature) {
method loadGeometry (line 57) | public List<List<Point>> loadGeometry() {
FILE: java/mlt-core/src/main/java/springmeyer/VectorTileLayer.java
class VectorTileLayer (line 6) | public class VectorTileLayer {
method VectorTileLayer (line 19) | @SuppressWarnings("this-escape")
method readLayer (line 26) | private static void readLayer(int tag, VectorTileLayer layer, Pbf pbf)
method readValueMessage (line 52) | private static Object readValueMessage(Pbf pbf) throws IllegalArgument...
method feature (line 77) | public VectorTileFeature feature(int i) throws IllegalArgumentException {
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/MltGenerator.java
class MltGenerator (line 37) | public class MltGenerator {
method generateMltTileset (line 66) | @Test
method generateSpecificMlTiles (line 95) | @Test
method generateSpecificMlTilesFromMbtiles (line 142) | @Test
method getOptimizations (line 175) | private Map<String, FeatureTableOptimizations> getOptimizations() {
method defaultConfigBuilder (line 194) | private ConversionConfig.ConfigBuilder defaultConfigBuilder() {
method convertMvtToMlt (line 204) | private byte[] convertMvtToMlt(
method writeTile (line 218) | private static void writeTile(
class MbtilesRepository (line 231) | class MbtilesRepository implements Iterable<MapboxVectorTile>, Closeable {
method MbtilesRepository (line 238) | MbtilesRepository(String url, int minZoom, int maxZoom)
method getTile (line 247) | protected MapboxVectorTile getTile(Triple<Integer, Integer, Integer> t...
method getRawTile (line 268) | protected byte[] getRawTile(Triple<Integer, Integer, Integer> tileId)
method getLargestTilesPerZoom (line 285) | public List<Triple<byte[], MapboxVectorTile, Triple<Integer, Integer, ...
method getTileIds (line 317) | public Queue<Triple<Integer, Integer, Integer>> getTileIds() {
method close (line 340) | public void close() {
method iterator (line 349) | @NotNull
class MbtilesIterator (line 355) | private class MbtilesIterator implements Iterator<MapboxVectorTile> {
method hasNext (line 358) | @Override
method next (line 367) | @Override
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/TestSettings.java
class TestSettings (line 6) | public class TestSettings {
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/TestUtils.java
class TestUtils (line 15) | public class TestUtils {
type Optimization (line 16) | public enum Optimization {
method compareFeatures (line 22) | private static int compareFeatures(
method compareTilesSequential (line 32) | public static int compareTilesSequential(
type TileFilter (line 42) | public static interface TileFilter {
method test (line 43) | default boolean test(Layer layer, Feature feature, String propertyKe...
method test (line 47) | default boolean test(Layer layer) {
method test (line 51) | default boolean test(Layer layer, Feature feature) {
method filterTile (line 57) | public static MapboxVectorTile filterTile(
method filterLayers (line 67) | private static @NotNull Layer filterLayers(@NotNull Layer layer, @NotN...
method filterFeatures (line 78) | private static @NotNull Feature filterFeatures(
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/benchmarks/CompressionBenchmarksTest.java
class CompressionBenchmarksTest (line 32) | @Tag("benchmark")
method omtCompressionBenchmarks_Sort (line 37) | @ParameterizedTest
method omtCompressionBenchmarks_OptimizedIds (line 50) | @ParameterizedTest
method runBenchmarks (line 63) | private static Triple<Double, Double, Double> runBenchmarks(
method getBenchmarksAndVerifyTiles (line 111) | private static Pair<Integer, Integer> getBenchmarksAndVerifyTiles(
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/benchmarks/MltDecoderBenchmarkTest.java
class MltDecoderBenchmarkTest (line 25) | @Tag("benchmark")
method decodeMlTileVectorized_Z2 (line 35) | @Test
method decodeMlTileVectorized_Z3 (line 41) | @Test
method decodeMlTileVectorized_Z4 (line 47) | @Test
method decodeMlTileVectorized_Z5 (line 56) | @Test
method decodeMlTileVectorized_Z6 (line 65) | @Test
method decodeMlTileVectorized_Z7 (line 71) | @Test
method decodeMlTileVectorized_Z8 (line 77) | @Test
method decodeMlTileVectorized_Z9 (line 83) | @Test
method decodeMlTileVectorized_Z10 (line 89) | @Test
method decodeMlTileVectorized_Z11 (line 95) | @Test
method decodeMlTileVectorized_Z12 (line 101) | @Test
method decodeMlTileVectorized_Z13 (line 107) | @Test
method decodeMlTileVectorized_Z14 (line 113) | @Test
method benchmarkSuite (line 122) | @Test
method benchmarkDecoding (line 152) | private void benchmarkDecoding(String tileId) throws IOException {
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/compare/CompareHelperTest.java
class CompareHelperTest (line 20) | class CompareHelperTest {
method identicalEmptyTilesAreEqual (line 21) | @Test
method identicalTilesWithFeaturesAreEqual (line 27) | @Test
method identicalTilesWithMultipleLayersAreEqual (line 34) | @Test
method differentLayerCountIsDetected (line 42) | @Test
method emptyMvtLayersAreIgnoredInLayerCount (line 54) | @Test
method differentLayerNames (line 64) | @Test
method differentFeatureCountInLayer (line 73) | @Test
method differentFeatureIds (line 84) | @Test
method featureWithIdVsFeatureWithoutIdDiffer (line 93) | @Test
method featuresWithoutIdAreEqual (line 101) | @Test
method differentGeometriesInGeometryMode (line 109) | @Test
method geometryDifferencesAreNotCheckedInLayersOnlyMode (line 120) | @Test
method geometryDifferencesAreNotCheckedInPropertiesMode (line 130) | @Test
method differentPropertyKeys (line 140) | @Test
method differentPropertyValues (line 149) | @Test
method propertyDifferencesNotCheckedInGeometryMode (line 158) | @Test
method nullPropertyValueInMltTreatedAsAbsent (line 166) | @Test
method numericValuesWithSameStringRepresentationEqual (line 176) | @Test
method layerFilterIncludesOnlyMatchingLayers (line 186) | @Test
method layerFilterExcludesMatchingLayersWhenInverted (line 202) | @Test
method layerFilterDetectsDifferenceInMatchingLayer (line 218) | @Test
method nullLayerFilterComparesAllLayers (line 229) | @Test
method differenceMessageIncludesLayerName (line 238) | @Test
method differenceMessageIncludesFeatureIndex (line 247) | @Test
method featuresWithIdsMatchEvenWhenOrderDiffers (line 268) | @Test
method featuresWithoutIdsDoNotMatchWhenOrderDiffers (line 286) | @Test
method sortingByIdStillDetectsPropertyDifferences (line 304) | @Test
method mltOf (line 322) | private static MapLibreTile mltOf(@NotNull Layer... layers) {
method mvtOf (line 326) | private static MapboxVectorTile mvtOf(@NotNull Layer... layers) {
method createLayer (line 330) | private static Layer createLayer(@NotNull String name, @NotNull MVTFea...
method createPointFeature (line 334) | private static MVTFeature createPointFeature(long id, Map<String, Obje...
method createPointFeature (line 338) | private static MVTFeature createPointFeature(long id, Map<String, Obje...
method createFeature (line 347) | private static MVTFeature createFeature(long id, Geometry geom) {
method createFeature (line 351) | private static MVTFeature createFeature(long id, Geometry geom, int in...
method createPointFeature (line 355) | private static MVTFeature createPointFeature(Map<String, Object> props) {
method createPointFeature (line 359) | private static MVTFeature createPointFeature(Map<String, Object> props...
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/ConversionConfigTest.java
class ConversionConfigTest (line 16) | public class ConversionConfigTest {
method sampleOptimizations (line 18) | private static Map<String, FeatureTableOptimizations> sampleOptimizati...
method assertConfigEquals (line 24) | private static void assertConfigEquals(ConversionConfig expected, Conv...
method testDefaults_fromNoArgConstructor (line 51) | @Test
method testConstructor_preservesPassedOptimizationsAndOutline (line 71) | @Test
method testBuilder_setsAllFields_andBuildProducesEquivalentConfig (line 96) | @Test
method testAsBuilder_roundTrip (line 131) | @Test
method testLayerFilterPatternAndInvert_behavior (line 152) | @Test
method testIntegerEncodingOption_defaultsAndCustom (line 166) | @Test
method testGeometryEncodingOption_defaultsAndCustom (line 178) | @Test
method testIntegerEncodingOnlyConstructor_geometryStaysAuto (line 201) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/MltConverterTest.java
class MltConverterTest (line 17) | class MltConverterTest {
method coerceValuesToString (line 18) | @Test
method elideValues (line 35) | @Test
method failOnMismatchedValues (line 52) | @Test
method createTileWithMixedTypes (line 62) | private static MapboxVectorTile createTileWithMixedTypes() {
method generateMetadataJSON (line 89) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/encodings/EncodingUtilsTest.java
class EncodingUtilsTest (line 14) | public class EncodingUtilsTest {
method encodeRle_MixedRunsAndLiterals_ValidEncoding (line 16) | @Test
method encodeRle_OnlyLiterals_ValidEncoding (line 28) | @Test
method encodeRle_OnlyRuns_ValidEncoding (line 40) | @Test
method encodeBooleanRle (line 52) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/encodings/LinearRegressionTest.java
class LinearRegressionTest (line 20) | public class LinearRegressionTest {
method test (line 22) | @Test
method test2 (line 94) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/encodings/MltTypeMapTest.java
class MltTypeMapTest (line 12) | public class MltTypeMapTest {
method roundTrips (line 14) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/encodings/VarintTest.java
class VarintTest (line 14) | public class VarintTest {
method testVarIntEncoding (line 48) | @Test
method testVarLongEncoding (line 66) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/encodings/fsst/FsstTest.java
class FsstTest (line 19) | class FsstTest {
method printStats (line 24) | @AfterAll
method decode_simpleString_ValidEncodedAndDecoded (line 29) | @Test
method decodeLongRepeated (line 35) | @Test
method empty (line 41) | @Test
method repeatedStrings (line 47) | @Test
method allBytes (line 55) | @Test
method tiles (line 65) | static List<Path> tiles() throws IOException {
method fsstEncodeTile (line 73) | @ParameterizedTest
method test (line 82) | private static void test(String input) {
method assertSymbolSortOrder (line 86) | private static void assertSymbolSortOrder(SymbolTable table) {
method test (line 111) | @SuppressWarnings("deprecation")
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/encodings/fsst/SymbolTest.java
class SymbolTest (line 14) | class SymbolTest {
method testBytes (line 23) | @Test
method testMatch (line 40) | @Test
method testMatch (line 48) | @ParameterizedTest
method testCompare (line 63) | @Test
method assertSymbol (line 74) | private static void assertSymbol(Symbol s, int... ints) {
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/geometry/HilbertCurveTest.java
class HilbertCurveTest (line 11) | public class HilbertCurveTest {
method level1_hasExpectedStandardOrder (line 13) | @Test
method encodeDecode_roundTripsForRepresentativeLevels (line 22) | @ParameterizedTest(name = "level={0}")
method consecutiveIndices_areAxisAdjacentAtLevel6 (line 28) | @Test
method throwsWhenLevelIsAboveMaximumAllowed (line 45) | @Test
method assertRoundTripForLevel (line 50) | private static void assertRoundTripForLevel(int level) {
method assertRoundTrip (line 68) | private static void assertRoundTrip(HilbertCurve curve, int x, int y) {
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/geometry/SpaceFillingCurveTest.java
class SpaceFillingCurveTest (line 8) | public class SpaceFillingCurveTest {
method numBits_positiveBounds (line 10) | @Test
method numBits_zeroAndPositiveBounds (line 17) | @Test
method numBits_positiveAndNegativeBounds (line 23) | @Test
class TestSpaceFillingCurve (line 29) | private static class TestSpaceFillingCurve extends SpaceFillingCurve {
method TestSpaceFillingCurve (line 30) | public TestSpaceFillingCurve(int minVertexValue, int maxVertexValue) {
method encode (line 34) | @Override
method decode (line 39) | @Override
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/geometry/ZOrderCurveTest.java
class ZOrderCurveTest (line 10) | public class ZOrderCurveTest {
method level1_hasExpectedStandardOrder (line 12) | @Test
method encodeDecode_roundTripsForRepresentativeLevels (line 21) | @ParameterizedTest(name = "level={0}")
method staticDecode_matchesInstanceDecodeForRepresentativeLevels (line 27) | @ParameterizedTest(name = "level={0}")
method throwsWhenLevelIsAboveMaximumAllowed (line 33) | @Test
method assertRoundTripForLevel (line 38) | private static void assertRoundTripForLevel(int level) {
method assertStaticDecodeMatchesInstanceDecode (line 56) | private static void assertStaticDecodeMatchesInstanceDecode(int level) {
method assertRoundTrip (line 70) | private static void assertRoundTrip(ZOrderCurve curve, int x, int y) {
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/converter/tessellation/TessellationUtilsTest.java
class TessellationUtilsTest (line 15) | public class TessellationUtilsTest {
method TessellationUtilsTest (line 16) | private TessellationUtilsTest() {}
method tessellateMultiPolygon_PolygonsWithoutHoles (line 18) | @Test
method tessellateMultiPolygon_PolygonsWithHoles (line 52) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/data/unsigned/UnsignedTest.java
class UnsignedTest (line 11) | class UnsignedTest {
method testU8OfValidValues (line 12) | @Test
method testU8OfNegativeValue (line 30) | @Test
method testU8OfValueTooLarge (line 36) | @Test
method testU8ValidRange (line 41) | @ParameterizedTest
method testU8RecordProperties (line 49) | @Test
method testU8ToString (line 54) | @Test
method testU8Equality (line 61) | @Test
method testU8ImplementsUnsigned (line 71) | @Test
method testU32OfValidValues (line 80) | @Test
method testU32OfNegativeValue (line 95) | @Test
method testU32OfValueTooLarge (line 101) | @Test
method testU32ValidRange (line 109) | @ParameterizedTest
method testU32RecordProperties (line 115) | @Test
method testU32ToString (line 120) | @Test
method testU32Equality (line 127) | @Test
method testU32ImplementsUnsigned (line 137) | @Test
method testU32ByteValueReturnsNullWhenOutOfRange (line 145) | @Test
method testU32ByteValueBoundary (line 154) | @Test
method testU64OfValidValues (line 163) | @Test
method testU64OfNegativeValue (line 174) | @Test
method testU64OfValueTooLarge (line 182) | @Test
method testU64ValidRange (line 189) | @ParameterizedTest
method testU64RecordProperties (line 196) | @Test
method testU64ToString (line 202) | @Test
method testU64Equality (line 209) | @Test
method testU64ImplementsUnsigned (line 219) | @Test
method testU64ByteValueReturnsNullWhenOutOfRange (line 226) | @Test
method testU64IntValueReturnsNullWhenOutOfRange (line 235) | @Test
method testU64ByteAndIntValueBoundaries (line 244) | @Test
method testConversionBetweenTypes (line 266) | @Test
method testU8WithHighByteValue (line 277) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/decoder/ByteRleTest.java
class ByteRleTest (line 13) | public class ByteRleTest {
method testEncodeDecodeRun (line 15) | @Test
method testEncodeDecodeLiterals (line 33) | @Test
method testEncodeDecodeMixed (line 51) | @Test
method testEncodeDecodeLongRun (line 69) | @Test
method testEncodeSingleByte (line 92) | @Test
method testEncodeEmpty (line 104) | @Test
method testEncoderFlush (line 113) | @Test
method testCompatibilityWithDecodingUtils (line 129) | @Test
method testMinimalRun (line 143) | @Test
method testMaxLiteralSize (line 157) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/decoder/DecodingUtilsTest.java
class DecodingUtilsTest (line 12) | public class DecodingUtilsTest {
method decodeLongVarints (line 14) | @Test
method decodeZigZag_LongValue (line 32) | @Test
method decodeFastPfor (line 46) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/decoder/DoubleDecoderTest.java
class DoubleDecoderTest (line 13) | public class DoubleDecoderTest {
method decodeDoubleStream_DoubleEncodedValues_ReturnsExactValues (line 15) | @Test
method decodeDoubleStream_FloatEncodedValues_ReturnsConvertedDoubleValues (line 24) | @Test
method decodeDoubleStream_EmptyStream_ReturnsEmptyList (line 35) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/decoder/IntegerDecoderTest.java
class IntegerDecoderTest (line 20) | public class IntegerDecoderTest {
method encode_Int_Limits (line 21) | @Test
method encode_Int_Limits_ZigZag (line 30) | @Test
method encodeIntStream (line 40) | private static ArrayList<byte[]> encodeIntStream(
method decodeIntStream_SignedIntegerValues_PlainFastPforEncode (line 51) | @Test
method decodeIntStream_SignedIntegerValues_PlainVarintEncode (line 67) | @Test
method decodeIntStream_SignedIntegerValues_FastPforDeltaRleEncode (line 83) | @Test
method decodeIntStream_SignedIntegerValues_VarintDeltaRleEncode (line 99) | @Test
method decodeIntStream_SignedIntegerValues_FastPforRleEncode (line 115) | @Test
method decodeIntStream_SignedIntegerValues_VarintRleEncode (line 132) | @Test
method decodeIntStream_UnsignedIntegerValues_VarintRleEncode (line 149) | @Test
method encodeLongStream (line 166) | private static ArrayList<byte[]> encodeLongStream(
method decodeLongStream_SignedIntegerValues_PlainEncode (line 176) | @Test
method decodeLongStream_SignedIntegerValues_DeltaRleEncode (line 192) | @Test
method decodeLongStream_SignedIntegerValues_RleEncode (line 207) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/decoder/MltDecoderTest.java
type TriConsumer (line 27) | @FunctionalInterface
method apply (line 29) | void apply(A a, B b, C c) throws IOException;
class MltDecoderTest (line 32) | public class MltDecoderTest {
method bingMapsTileIdProvider (line 34) | private static Stream<Triple<Integer, Integer, Integer>> bingMapsTileI...
method omtTileIdProvider (line 39) | private static Stream<Triple<Integer, Integer, Integer>> omtTileIdProv...
method decodeMlTile_UnsortedOMT (line 60) | @DisplayName("Decode scalar unsorted OpenMapTiles schema based vector ...
method testTileSequential (line 74) | private void testTileSequential(
method testTile (line 95) | private void testTile(
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/decoder/MltDecoderTest2.java
type DecoderType (line 27) | enum DecoderType {
type EncodingType (line 33) | enum EncodingType {
class MltDecoderTest2 (line 41) | public class MltDecoderTest2 {
method decodeBingTilesSortedFail (line 47) | @Test
method bingProvider (line 59) | private static Stream<String> bingProvider() {
method decodeBingTiles (line 65) | @DisplayName("Decode Bing Tiles")
method currentlyFailingBingDecoding1 (line 84) | @Disabled
method decodeOMTTilesSortedFail (line 106) | @Test
method omtProvider (line 122) | private static Stream<String> omtProvider() {
method decodeOMTTiles (line 145) | @DisplayName("Decode OMT Tiles (advanced encodings, non-sorted)")
method decodeOMTTiles2 (line 158) | @DisplayName("Decode OMT Tiles (non-advanced encodings)")
method testTile (line 190) | private DecodingResult testTile(
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/decoder/StringDecoderTest.java
class StringDecoderTest (line 33) | public class StringDecoderTest {
method encodeSharedDictionary (line 35) | public static Pair<Integer, ArrayList<byte[]>> encodeSharedDictionary(
method decodeSharedDictionary_FsstDictionaryEncoded (line 43) | @Test
method decodeSharedDictionary_DictionaryEncoded (line 78) | @Test
method createField (line 101) | private MltMetadata.Field createField(
method createComplexColumn (line 108) | private MltMetadata.ComplexField createComplexColumn(MltMetadata.Field...
method decodeSharedDictionary_NullValues_DictionaryEncoded (line 112) | @Test
method decodeSharedDictionary_NullValues_FsstDictionaryEncoded (line 156) | @Test
method decodeSharedDictionary_Mvt (line 218) | @ParameterizedTest
method decodeSharedDictionary_MvtWithNestedColumns (line 255) | @ParameterizedTest
method decodeColumnMap_Mvt_prefix_multi (line 348) | @Test
method decodeColumnMap_Mvt_explicit (line 386) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/json/JsonTest.java
class JsonTest (line 23) | class JsonTest {
method propertyValues (line 26) | @Test
method mvtSerializesLayers (line 50) | @Test
method featureCollectionWithLayerMetadata (line 76) | @Test
method floatAndDoublePropertiesToTokens (line 101) | @Test
method nullGeometry (line 141) | @Test
method integerCoordinates (line 155) | @Test
method propertiesAlphabetical (line 177) | @Test
method jsonElementStableOrder (line 207) | @Test
method mltOf (line 236) | private static MapLibreTile mltOf(Layer... layers) {
method mvtOf (line 240) | private static MapboxVectorTile mvtOf(Layer... layers) {
method layer (line 244) | private static Layer layer(String name, int extent, Feature... feature...
method feature (line 248) | private static Feature feature(Geometry geometry, Map<String, Object> ...
method feature (line 252) | private static Feature feature(long id, Geometry geometry, Map<String,...
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/metadata/tileset/MltMetadataColumnTest.java
class MltMetadataColumnTest (line 13) | class MltMetadataColumnTest {
method createScalarColumn (line 14) | @Test
method createComplexColumn (line 27) | @Test
method acceptsNullChildren (line 45) | @Test
method defaultsToFeatureScope (line 53) | @Test
method rejectsInvalidScope (line 60) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/synthetics/SyntheticsTest.java
class SyntheticsTest (line 21) | public class SyntheticsTest {
method checkSynthetics (line 22) | @Test
method findFiles (line 71) | private static SequencedCollection<Path> findFiles(String root, PathMa...
method compareJsonObjects (line 79) | private boolean compareJsonObjects(Object expected, Object actual) {
method numericsEqual (line 108) | private boolean numericsEqual(Object a, Object b) {
method compareFloats (line 121) | private boolean compareFloats(Number a, Number b) {
method compareDecimals (line 130) | private boolean compareDecimals(Object a, Object b) {
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/util/OptionalUtilTest.java
class OptionalUtilTest (line 11) | class OptionalUtilTest {
method isLessThanBothEmpty (line 12) | @Test
method isLessThan_whenLeftEmptyAndRightPresent_returnsFalse (line 17) | @Test
method isLessThan_whenLeftPresentAndRightEmpty_returnsTrue (line 22) | @Test
method isLessThanLess (line 27) | @Test
method isLessThanEqual (line 32) | @Test
method isLessThanGreater (line 37) | @Test
method isLessThanSupportsComparableTypes (line 42) | @Test
method isLessThanThrowsWhenOptional1Nulls (line 48) | @Test
method isLessThanThrowsWhenOptional2Null (line 53) | @Test
method mapReturnsMappedValue (line 58) | @Test
method mapEmptyWhenOptional1Empty (line 64) | @Test
method mapEmptyWhenOptional2Empty (line 70) | @Test
method mapBothEmpty (line 76) | @Test
method mapThrowsWhenOptional1Null (line 83) | @Test
method mapThrowsWhenOptional2Null (line 89) | @Test
method mapThrowsWhenFunctionNull (line 95) | @Test
FILE: java/mlt-core/src/test/java/org/maplibre/mlt/util/StreamUtilTest.java
class StreamUtilTest (line 13) | class StreamUtilTest {
method zipWithEqualSizedStreams (line 14) | @Test
method zipPairs (line 25) | @Test
method zipWithEmptyStreams (line 34) | @Test
method zipWithFirstStreamShorter (line 39) | @Test
method zipWithSecondStreamShorter (line 48) | @Test
method zipWithTransformationFunction (line 57) | @Test
method zipPreservesStreamCharacteristics (line 67) | @Test
method zipWithParallelStreams (line 76) | void zipWithParallelStreams(boolean first, boolean second) {
method zipWithFirstParallelStream (line 91) | @Test
method zipWithSecondParallelStream (line 96) | @Test
method zipWithBothParallelStreams (line 101) | @Test
method zipWithNullTransformationFunction (line 106) | @Test
method zipWithNullFirstStream (line 113) | @Test
method zipWithNullSecondStream (line 119) | @Test
method zipEachProcessesAllPairs (line 125) | @Test
method zipEachWithEmptyStreams (line 134) | @Test
method zipEachWithMismatchedKnownStreamSizes (line 139) | @Test
method zipEachWithMismatchedUnknownStreamSizes (line 150) | @Test
method zipEachWithNullFirstStream (line 162) | @Test
method zipEachWithNullSecondStream (line 168) | @Test
method zipWithLargeStreams (line 174) | @Test
method zipHandlesNullValuesInStreams (line 185) | @Test
method zipWithDifferentObjectTypes (line 196) | @Test
method zipStreamIsLazy (line 208) | @Test
method zipWithInfiniteFirstStream (line 234) | @Test
method zipWithInfiniteSecondStream (line 244) | @Test
FILE: java/mlt-tools/src/main/java/org/maplibre/mlt/tools/SyntheticMltGenerator.java
class SyntheticMltGenerator (line 55) | public class SyntheticMltGenerator {
method main (line 57) | public static void main(String[] args) throws IOException {
method generatePoints (line 78) | private static void generatePoints() throws IOException {
method generateLines (line 82) | private static void generateLines() throws IOException {
method generatePolygons (line 91) | private static void generatePolygons() throws IOException {
method generateMultiPoints (line 175) | private static void generateMultiPoints() throws IOException {
method generateMultiLineStrings (line 184) | private static void generateMultiLineStrings() throws IOException {
method generateMixCombination (line 195) | private static void generateMixCombination(List<GeomType> current) thr...
method generateMixedCombine (line 215) | private static void generateMixedCombine(GeomType[] arr, int k, int st...
method generateMixed (line 231) | private static void generateMixed() throws IOException {
method generateExtent (line 270) | private static void generateExtent() throws IOException {
method generateIds (line 278) | private static void generateIds() throws IOException {
method generateProperties (line 320) | @SuppressWarnings("cast")
method generateFpfAlignments (line 536) | private static void generateFpfAlignments() throws IOException {
method generateSharedDictionaries (line 549) | private static void generateSharedDictionaries() throws IOException {
FILE: java/mlt-tools/src/main/java/org/maplibre/mlt/tools/SyntheticMltUtil.java
class SyntheticMltUtil (line 40) | class SyntheticMltUtil {
class Cfg (line 85) | static class Cfg extends ConversionConfig.ConfigBuilder {
method ids (line 86) | public Cfg ids() {
method fastPFOR (line 91) | public Cfg fastPFOR() {
method fsst (line 96) | public Cfg fsst() {
method geomEnc (line 101) | public Cfg geomEnc(ConversionConfig.IntegerEncodingOption encoding) {
method coercePropValues (line 106) | public Cfg coercePropValues() {
method tessellate (line 111) | public Cfg tessellate() {
method morton (line 116) | public Cfg morton() {
method filterInvert (line 121) | public Cfg filterInvert() {
method sharedDictPrefix (line 130) | public Cfg sharedDictPrefix(String prefix, String delimiter) {
method sharedDictColumnGroups (line 144) | public Cfg sharedDictColumnGroups(List<List<String>> columnGroups) {
method cfg (line 155) | static Cfg cfg() {
method cfg (line 159) | static Cfg cfg(ConversionConfig.IntegerEncodingOption encoding) {
method array (line 181) | @SafeVarargs
method c (line 187) | static Coordinate c(int x, int y) {
method buildMortonCurve (line 192) | static Coordinate[] buildMortonCurve(int numPoints, int scale, int mor...
method line (line 206) | static LineString line(Coordinate... coords) {
method ring (line 210) | static LinearRing ring(Coordinate... coords) {
method poly (line 214) | static Polygon poly(Coordinate... coords) {
method poly (line 218) | static Polygon poly(LinearRing shell, LinearRing... holes) {
method multi (line 222) | static MultiPoint multi(Coordinate... coords) {
method multi (line 227) | static MultiPolygon multi(Polygon... polys) {
method multi (line 231) | static MultiLineString multi(LineString... lines) {
method kv (line 237) | static KeyVal kv(String key, Object value) {
method prop (line 241) | static Map<String, Object> prop(String key, Object value) {
method props (line 245) | static Map<String, Object> props(KeyVal... keyValues) {
method feat (line 253) | static Feature feat(Geometry geom) {
method feat (line 257) | static MLTFeature feat(Geometry geom, Map<String, Object> props) {
method idFeat (line 262) | static Feature idFeat(long id) {
method idFeat (line 267) | static Feature idFeat() {
method layer (line 271) | static Layer layer(String name, Feature... features) {
method layer (line 275) | static Layer layer(String name, int extent, Feature... features) {
method write (line 279) | static void write(String name, Feature feat, ConversionConfig.ConfigBu...
method write (line 284) | static void write(Layer layer, ConversionConfig.ConfigBuilder cfg) thr...
method write (line 290) | static void write(String fileName, List<Layer> layers, ConversionConfi...
method buildColumnMappings (line 308) | private static ColumnMappingConfig buildColumnMappings(ConversionConfi...
FILE: java/resources/FsstWrapper.cpp
type SymbolTableStruct (line 8) | struct SymbolTableStruct {
function SymbolTableStruct (line 15) | SymbolTableStruct fsstCompress(std::vector<unsigned char> inputBytes) {
function JNIEXPORT (line 67) | JNIEXPORT jobject JNICALL Java_com_mlt_converter_encodings_fsst_FsstJni_...
FILE: qgis/mlt_plugin/__init__.py
function classFactory (line 4) | def classFactory(iface):
FILE: qgis/mlt_plugin/loader.py
function _canonical_geom_type (line 43) | def _canonical_geom_type(geom_type_str: str) -> str:
function _ensure_mlt (line 55) | def _ensure_mlt():
function _infer_field_type (line 64) | def _infer_field_type(value) -> int:
function _qgs_geom_type_string (line 68) | def _qgs_geom_type_string(wkb_type) -> str:
function _group_features_by_geom_type (line 80) | def _group_features_by_geom_type(mlt_layer):
function _discover_fields (line 88) | def _discover_fields(features) -> QgsFields:
function _make_qgs_features (line 102) | def _make_qgs_features(features, vl, field_names) -> List[QgsFeature]:
function _decode_file (line 118) | def _decode_file(file_path, zxy=None, tms=True):
function _create_and_populate_layer (line 125) | def _create_and_populate_layer(
function load_mlt_file (line 167) | def load_mlt_file(
function load_mlt_files_merged (line 193) | def load_mlt_files_merged(
FILE: qgis/mlt_plugin/plugin.py
class MltPlugin (line 19) | class MltPlugin:
method __init__ (line 20) | def __init__(self, iface):
method initGui (line 24) | def initGui(self):
method unload (line 31) | def unload(self):
method open_file_dialog (line 36) | def open_file_dialog(self):
method _load_single (line 51) | def _load_single(self, path: str):
method _load_multiple (line 68) | def _load_multiple(self, paths: list):
method _report_result (line 108) | def _report_result(self, layers, paths, georeferenced):
method _report_error (line 127) | def _report_error(self, exc):
FILE: qgis/mlt_plugin/tile_coords.py
function parse_zxy_from_path (line 26) | def parse_zxy_from_path(file_path: str) -> Optional[ZXY]:
class TileCoordDialog (line 52) | class TileCoordDialog(QDialog):
method __init__ (line 55) | def __init__(self, parent=None, initial: Optional[ZXY] = None):
method _on_skip (line 105) | def _on_skip(self):
method skipped (line 110) | def skipped(self) -> bool:
method zxy (line 113) | def zxy(self) -> ZXY:
method tms (line 117) | def tms(self) -> bool:
class MultipleTileCoordDialog (line 121) | class MultipleTileCoordDialog(QDialog):
method __init__ (line 124) | def __init__(
method _on_skip (line 204) | def _on_skip(self):
method skipped (line 209) | def skipped(self) -> bool:
method tms (line 213) | def tms(self) -> bool:
method merge (line 217) | def merge(self) -> bool:
method file_coords (line 220) | def file_coords(self) -> Dict[str, Optional[ZXY]]:
FILE: rust/mlt-core/benches/bench_utils.rs
constant BENCHMARKED_ZOOM_LEVELS (line 8) | pub const BENCHMARKED_ZOOM_LEVELS: [u8; 1] = [0];
constant BENCHMARKED_ZOOM_LEVELS (line 10) | pub const BENCHMARKED_ZOOM_LEVELS: [u8; 3] = [4, 7, 13];
function walk_dir (line 13) | fn walk_dir(dir: &Path, extension: &str, out: &mut Vec<(String, Vec<u8>)...
function load_all_mvt_bytes (line 38) | pub fn load_all_mvt_bytes() -> Vec<(String, Vec<u8>)> {
function load_mlt_tiles (line 54) | pub fn load_mlt_tiles(zoom: u8) -> Vec<(String, Vec<u8>)> {
function load_tiles (line 59) | pub fn load_tiles(zoom: u8, test_subpath: &str, extension: &str) -> Vec<...
function total_bytes (line 89) | pub fn total_bytes(tiles: &[(String, Vec<u8>)]) -> usize {
FILE: rust/mlt-core/benches/decoding_e2e.rs
function load_proto_tiles (line 11) | fn load_proto_tiles(zoom: u8) -> Vec<(String, Vec<u8>)> {
function compress_gzip (line 15) | fn compress_gzip(data: &[u8]) -> Vec<u8> {
function decompress_gzip (line 21) | fn decompress_gzip(data: &[u8]) -> Vec<u8> {
function compress_zstd (line 30) | fn compress_zstd(data: &[u8]) -> Vec<u8> {
function decompress_zstd (line 34) | fn decompress_zstd(data: &[u8]) -> Vec<u8> {
function compress_brotli (line 38) | fn compress_brotli(data: &[u8]) -> Vec<u8> {
function decompress_brotli (line 47) | fn decompress_brotli(data: &[u8]) -> Vec<u8> {
function compress_tiles (line 56) | fn compress_tiles(
function mvt_parse (line 66) | fn mvt_parse(data: Vec<u8>) {
function mvt_decode (line 71) | fn mvt_decode(data: Vec<u8>) {
type Codec (line 85) | type Codec = (&'static str, fn(&[u8]) -> Vec<u8>, fn(&[u8]) -> Vec<u8>);
function identity (line 87) | fn identity(data: &[u8]) -> Vec<u8> {
constant CODECS (line 91) | const CODECS: &[Codec] = &[
function bench_parse (line 98) | fn bench_parse(c: &mut Criterion) {
function bench_decode_all (line 144) | fn bench_decode_all(c: &mut Criterion) {
FILE: rust/mlt-core/benches/decoding_strings.rs
constant BENCHMARKED_LENGTHS (line 15) | pub const BENCHMARKED_LENGTHS: [usize; 1] = [1];
constant BENCHMARKED_LENGTHS (line 17) | pub const BENCHMARKED_LENGTHS: [usize; 6] = [1, 20, 64, 256, 1024, 2048];
function limit (line 19) | fn limit<T>(values: impl Iterator<Item = T>) -> impl Iterator<Item = T> {
function make_strings (line 29) | fn make_strings(n: usize) -> Vec<String> {
function make_nullable_strings (line 64) | fn make_nullable_strings(n: usize) -> Vec<Option<String>> {
function make_geometry (line 75) | fn make_geometry(n: usize) -> GeometryValues {
function encode_layer (line 84) | fn encode_layer(n: usize, props: Vec<StagedProperty>, cfg: ExplicitEncod...
function sum_str_lens (line 106) | fn sum_str_lens(parsed: &ParsedLayer01<'_>) -> usize {
function bench_plain_length_encoding (line 126) | fn bench_plain_length_encoding(c: &mut Criterion) {
function bench_fsst_length_encoding (line 166) | fn bench_fsst_length_encoding(c: &mut Criterion) {
function bench_encoding_type (line 206) | fn bench_encoding_type(c: &mut Criterion) {
function bench_presence (line 255) | fn bench_presence(c: &mut Criterion) {
function bench_vs_shared_dict (line 318) | fn bench_vs_shared_dict(c: &mut Criterion) {
FILE: rust/mlt-core/benches/decoding_utils.rs
constant NUM_BITS (line 7) | const NUM_BITS: u32 = 15;
constant COORDINATE_SHIFT (line 8) | const COORDINATE_SHIFT: u32 = 1 << (NUM_BITS - 1);
constant BENCHMARKED_LENGTHS (line 12) | pub const BENCHMARKED_LENGTHS: [u32; 1] = [1];
constant BENCHMARKED_LENGTHS (line 14) | pub const BENCHMARKED_LENGTHS: [u32; 3] = [64, 256, 1024];
function encode_morton_15 (line 22) | pub fn encode_morton_15(x: u32, y: u32) -> u32 {
function make_morton_codes (line 31) | fn make_morton_codes(n: u32) -> Vec<u32> {
function make_morton_deltas (line 41) | fn make_morton_deltas(n: u32) -> Vec<u32> {
function bench_impls (line 54) | fn bench_impls<I: Clone, O>(
function bench_morton (line 75) | fn bench_morton(c: &mut Criterion) {
FILE: rust/mlt-core/benches/encoding_e2e.rs
function limit (line 17) | fn limit<T>(values: impl Iterator<Item = T>) -> impl Iterator<Item = T> {
function decode_to_owned (line 29) | fn decode_to_owned(tiles: &[(String, Vec<u8>)], tessellate: bool) -> Vec...
function bench_encode (line 49) | fn bench_encode(c: &mut Criterion) {
FILE: rust/mlt-core/benches/encoding_from_mvt.rs
function load_mvt_tiles (line 13) | fn load_mvt_tiles(zoom: u8) -> Vec<(String, Vec<u8>)> {
function parse_mvt_to_tile_layers (line 21) | fn parse_mvt_to_tile_layers(mvt_files: &[(String, Vec<u8>)]) -> Vec<Tile...
function bench_encode_from_mvt (line 33) | fn bench_encode_from_mvt(c: &mut Criterion) {
FILE: rust/mlt-core/fuzz/src/decoded_layer.rs
type DecodedLayerInput (line 9) | pub struct DecodedLayerInput {
method arbitrary (line 14) | fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result...
method fuzz_roundtrip (line 21) | pub fn fuzz_roundtrip(self) {
method fmt (line 55) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
function encode_decode (line 35) | fn encode_decode(staged: StagedLayer) -> TileLayer {
FILE: rust/mlt-core/fuzz/src/layer.rs
type LayerInput (line 5) | pub struct LayerInput {
method fmt (line 9) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
method fuzz_roundtrip (line 14) | pub fn fuzz_roundtrip(self) {
FILE: rust/mlt-core/fuzz/tests/reproduce.rs
function fuzz_roundtrip (line 9) | fn fuzz_roundtrip() {
FILE: rust/mlt-core/src/codecs/bytes.rs
function encode_bools_to_bytes (line 6) | pub fn encode_bools_to_bytes(
function decode_bytes_to_u64s (line 21) | pub fn decode_bytes_to_u64s<'a>(
function decode_bytes_to_u32s (line 51) | pub fn decode_bytes_to_u32s<'a>(
function decode_bytes_to_bools (line 79) | pub fn decode_bytes_to_bools(
function debug_assert_length (line 99) | pub fn debug_assert_length<T>(buffer: &[T], expected_len: usize) {
function test_bytes_to_u32s_valid (line 145) | fn test_bytes_to_u32s_valid() {
function test_bytes_to_u32s_empty (line 159) | fn test_bytes_to_u32s_empty() {
function test_bytes_to_u32s_buffer_underflow (line 169) | fn test_bytes_to_u32s_buffer_underflow() {
function test_bytes_to_u32s_partial_consumption (line 180) | fn test_bytes_to_u32s_partial_consumption() {
function test_decode_u32 (line 194) | fn test_decode_u32() {
function test_decode_u64 (line 202) | fn test_decode_u64() {
function test_decode_bytes_to_u32s_empty (line 210) | fn test_decode_bytes_to_u32s_empty() {
FILE: rust/mlt-core/src/codecs/fastpfor.rs
function decode_fastpfor (line 16) | pub fn decode_fastpfor(data: &[u8], num_values: u32, dec: &mut Decoder) ...
function test_decode_fastpfor_empty (line 86) | fn test_decode_fastpfor_empty() {
FILE: rust/mlt-core/src/codecs/fsst.rs
function decode_fsst (line 19) | pub fn decode_fsst(raw: RawFsstData<'_>, dec: &mut Decoder) -> MltResult...
type FsstRawData (line 60) | pub struct FsstRawData {
function compress_fsst (line 85) | pub fn compress_fsst<S: AsRef<str>>(values: &[S]) -> FsstRawData {
function compress_fsst_with (line 92) | pub fn compress_fsst_with<S: AsRef<str>>(
function roundtrip (line 148) | fn roundtrip(values: &[&str]) -> (String, Vec<u32>) {
function test_fsst_roundtrip_empty (line 209) | fn test_fsst_roundtrip_empty() {
function automatic_optimization_roundtrip (line 218) | fn automatic_optimization_roundtrip(#[case] values: &[&str]) {
FILE: rust/mlt-core/src/codecs/hilbert.rs
function hilbert_xy_to_index (line 11) | pub fn hilbert_xy_to_index(level: u32, coord: Coord<u32>) -> u32 {
function hilbert_sort_key (line 29) | pub fn hilbert_sort_key(c: Coord<i32>, params: CurveParams) -> u32 {
function hilbert_curve_params_from_bounds (line 58) | pub fn hilbert_curve_params_from_bounds(min_val: i32, max_val: i32) -> C...
function c (line 88) | const fn c(x: i32, y: i32) -> Coord<i32> {
function p (line 92) | const fn p(shift: u32, bits: u32) -> CurveParams {
function hilbert_position_to_xy (line 101) | fn hilbert_position_to_xy(level: u32, pos: u32) -> Coord<u32> {
function hilbert_origin_always_zero (line 108) | fn hilbert_origin_always_zero() {
function hilbert_round_trip_level1 (line 117) | fn hilbert_round_trip_level1() {
function hilbert_round_trip_level2 (line 129) | fn hilbert_round_trip_level2() {
function hilbert_round_trip_level4 (line 141) | fn hilbert_round_trip_level4() {
function hilbert_indices_are_a_bijection_at_level2 (line 153) | fn hilbert_indices_are_a_bijection_at_level2() {
function hilbert_indices_are_a_bijection_at_level4 (line 167) | fn hilbert_indices_are_a_bijection_at_level4() {
function hilbert_level1_covers_indices_0_to_3 (line 180) | fn hilbert_level1_covers_indices_0_to_3() {
function hilbert_sort_key_origin_zero (line 192) | fn hilbert_sort_key_origin_zero() {
function hilbert_sort_key_negative_coords_shift_correctly (line 197) | fn hilbert_sort_key_negative_coords_shift_correctly() {
function hilbert_sort_key_matches_xy_to_index (line 203) | fn hilbert_sort_key_matches_xy_to_index() {
function curve_params_empty_bounds (line 225) | fn curve_params_empty_bounds() {
function curve_params_all_zero (line 233) | fn curve_params_all_zero() {
function curve_params_positive_only (line 241) | fn curve_params_positive_only() {
function curve_params_negative_min (line 249) | fn curve_params_negative_min() {
function curve_params_power_of_two_extent (line 257) | fn curve_params_power_of_two_extent() {
function curve_params_single_axis_negative (line 265) | fn curve_params_single_axis_negative() {
function curve_params_clamped_at_16_bits (line 273) | fn curve_params_clamped_at_16_bits() {
function hilbert_and_morton_both_sort_nearby_points_close_together (line 283) | fn hilbert_and_morton_both_sort_nearby_points_close_together() {
FILE: rust/mlt-core/src/codecs/morton.rs
constant LANES (line 8) | const LANES: usize = 8;
function interleave_bits (line 19) | pub fn interleave_bits(coord: Coord<u32>) -> u32 {
function morton_sort_key (line 50) | pub fn morton_sort_key(c: Coord<i32>, params: CurveParams) -> u32 {
method from_vertices (line 73) | pub fn from_vertices(vertices: &[i32]) -> MltResult<Self> {
method encode_morton (line 101) | pub fn encode_morton(self, x: i32, y: i32) -> MltResult<u32> {
method decode_one (line 117) | fn decode_one(self, morton_code: u32) -> Coord<i32> {
method decode_codes (line 136) | pub fn decode_codes(self, data: &[u32], dec: &mut Decoder) -> MltResult<...
method decode_delta (line 167) | pub fn decode_delta(self, data: &[u32], dec: &mut Decoder) -> MltResult<...
method decode_chunk (line 202) | fn decode_chunk(self, buf: [u32; LANES], shift_vec: u32x8, out: &mut Vec...
function c (line 234) | const fn c(x: i32, y: i32) -> Coord<i32> {
function p (line 238) | const fn p(shift: u32, bits: u32) -> CurveParams {
function spread_bits (line 246) | fn spread_bits(mut tx: u32) -> u32 {
function compact_bits (line 256) | fn compact_bits(mut tx: u32) -> u32 {
function spread_then_compact_is_identity (line 266) | fn spread_then_compact_is_identity() {
function spread_bits_places_bit0_at_position0 (line 273) | fn spread_bits_places_bit0_at_position0() {
function spread_bits_places_bit1_at_position2 (line 278) | fn spread_bits_places_bit1_at_position2() {
function spread_bits_places_bit2_at_position4 (line 283) | fn spread_bits_places_bit2_at_position4() {
function origin_maps_to_zero (line 288) | fn origin_maps_to_zero() {
function x_axis_produces_even_bits (line 293) | fn x_axis_produces_even_bits() {
function y_axis_produces_odd_bits (line 301) | fn y_axis_produces_odd_bits() {
function negative_coords_shift_correctly (line 309) | fn negative_coords_shift_correctly() {
function spatial_locality_z_order (line 317) | fn spatial_locality_z_order() {
function interleave_round_trips_via_deinterleave (line 329) | fn interleave_round_trips_via_deinterleave() {
constant NUM_BITS (line 348) | const NUM_BITS: u32 = 15;
constant COORD_SHIFT (line 349) | const COORD_SHIFT: u32 = 1 << (NUM_BITS - 1);
constant MORTON (line 350) | const MORTON: Morton = Morton {
function encode_morton_15 (line 361) | pub fn encode_morton_15(coord: Coord<u32>) -> u32 {
function test_decode_morton_codes_empty (line 371) | fn test_decode_morton_codes_empty() {
function test_decode_morton_codes_origin (line 376) | fn test_decode_morton_codes_origin() {
function test_decode_morton_codes_known_values (line 384) | fn test_decode_morton_codes_known_values() {
function test_decode_morton_codes_scalar_tail (line 396) | fn test_decode_morton_codes_scalar_tail() {
function test_decode_morton_codes_full_simd_chunk (line 406) | fn test_decode_morton_codes_full_simd_chunk() {
function test_decode_morton_codes_simd_plus_tail (line 425) | fn test_decode_morton_codes_simd_plus_tail() {
function test_decode_morton_delta_empty (line 439) | fn test_decode_morton_delta_empty() {
function test_decode_morton_delta_identity_with_zero_deltas (line 444) | fn test_decode_morton_delta_identity_with_zero_deltas() {
function test_decode_morton_delta_matches_codes_after_prefix_sum (line 453) | fn test_decode_morton_delta_matches_codes_after_prefix_sum() {
function test_decode_morton_delta_scalar_tail (line 468) | fn test_decode_morton_delta_scalar_tail() {
function test_decode_morton_delta_wrapping (line 482) | fn test_decode_morton_delta_wrapping() {
function expected_coords (line 498) | fn expected_coords(pairs: &[Coord<u32>]) -> Vec<i32> {
function signed_deltas (line 511) | fn signed_deltas(codes: &[u32]) -> Vec<u32> {
FILE: rust/mlt-core/src/codecs/rle.rs
function encode_rle (line 8) | pub fn encode_rle<T: PrimInt>(data: &[T]) -> (Vec<T>, Vec<T>) {
function encode_byte_rle (line 40) | pub fn encode_byte_rle<'a>(data: &[u8], target: &'a mut Vec<u8>) -> &'a ...
function decode_byte_rle (line 99) | pub fn decode_byte_rle(input: &[u8], num_bytes: usize, dec: &mut Decoder...
function test_encode_rle_empty (line 156) | fn test_encode_rle_empty() {
function test_encode_byte_rle_empty (line 163) | fn test_encode_byte_rle_empty() {
function test_decode_byte_rle_empty (line 169) | fn test_decode_byte_rle_empty() {
FILE: rust/mlt-core/src/codecs/varint.rs
function parse_varint (line 12) | pub fn parse_varint<T: VarInt>(input: &[u8]) -> MltRefResult<'_, T> {
function parse_varint_vec (line 33) | pub fn parse_varint_vec<'a, T, U>(
function test_varint_parsing (line 71) | fn test_varint_parsing(#[case] bytes: &[u8], #[case] expected: MltResult...
function test_parse_varint_vec (line 83) | fn test_parse_varint_vec() {
FILE: rust/mlt-core/src/codecs/zigzag.rs
function encode_zigzag (line 10) | pub fn encode_zigzag<'a, T: ZigZag>(data: &[T], target: &'a mut Vec<T::U...
function encode_zigzag_delta (line 20) | pub fn encode_zigzag_delta<'a, T: Copy + ZigZag + WrappingSub<Output = T>>(
function encode_componentwise_delta_vec2s (line 41) | pub fn encode_componentwise_delta_vec2s<'a, T>(
function decode_zigzag (line 62) | pub fn decode_zigzag<T: ZigZag>(data: &[T::UInt], dec: &mut Decoder) -> ...
function decode_zigzag_delta (line 68) | pub fn decode_zigzag_delta<T: Copy + ZigZag + WrappingAdd + AsPrimitive<...
function decode_componentwise_delta_vec2s (line 84) | pub fn decode_componentwise_delta_vec2s<T: ZigZag + WrappingAdd>(
function test_encode_zigzag_empty (line 151) | fn test_encode_zigzag_empty() {
function test_encode_zigzag_delta_empty (line 157) | fn test_encode_zigzag_delta_empty() {
function test_decode_zigzag_i32 (line 164) | fn test_decode_zigzag_i32() {
function test_decode_zigzag_i64 (line 172) | fn test_decode_zigzag_i64() {
function test_decode_zigzag_empty (line 180) | fn test_decode_zigzag_empty() {
function test_decode_zigzag_delta_empty (line 185) | fn test_decode_zigzag_delta_empty() {
function test_decode_componentwise_delta_vec2s (line 194) | fn test_decode_componentwise_delta_vec2s() {
FILE: rust/mlt-core/src/convert/geojson.rs
type FeatureCollection (line 16) | pub struct FeatureCollection {
method from_layers (line 25) | pub fn from_layers<'a>(layers: impl IntoIterator<Item = ParsedLayer<'a...
method equals (line 56) | pub fn equals(&self, other: &Self) -> Result<bool, serde_json::Error> {
type Err (line 64) | type Err = serde_json::Error;
method from_str (line 66) | fn from_str(s: &str) -> Result<Self, Self::Err> {
type Feature (line 73) | pub struct Feature {
type Geom32Wire (line 83) | struct Geom32Wire<'a>(&'a Geometry<i32>);
method serialize (line 85) | fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Erro...
method serialize (line 92) | fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok...
type Arr (line 116) | type Arr = [i32; 2];
function ls_arr (line 118) | fn ls_arr(ls: &LineString<i32>) -> Vec<Arr> {
function poly_arr (line 122) | fn poly_arr(poly: &Polygon<i32>) -> Vec<Vec<Arr>> {
function arr_ls (line 129) | fn arr_ls(v: Vec<Arr>) -> LineString<i32> {
function arr_poly (line 133) | fn arr_poly(rings: Vec<Vec<Arr>>) -> Polygon<i32> {
function serialize (line 139) | pub fn serialize<S: Serializer>(g: &Geometry<i32>, s: S) -> Result<S::Ok...
function deserialize (line 165) | pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Geometry<i...
function f32_to_json (line 213) | pub fn f32_to_json(f: f32) -> Value {
function f64_to_json (line 227) | pub fn f64_to_json(f: f64) -> Value {
method from (line 240) | fn from(v: PropValueRef<'_>) -> Self {
function normalize_tiny_floats (line 257) | fn normalize_tiny_floats(value: Value) -> Value {
function json_values_equal (line 283) | fn json_values_equal(a: &Value, b: &Value) -> bool {
FILE: rust/mlt-core/src/convert/mvt.rs
type MvtLayer (line 20) | struct MvtLayer {
function read_mvt_layers (line 30) | fn read_mvt_layers(data: Vec<u8>) -> MltResult<Vec<MvtLayer>> {
function mvt_to_feature_collection (line 51) | pub fn mvt_to_feature_collection(data: Vec<u8>) -> MltResult<FeatureColl...
function mvt_to_tile_layers (line 88) | pub fn mvt_to_tile_layers(data: Vec<u8>) -> MltResult<Vec<TileLayer>> {
function mvt_layer_to_tile (line 95) | fn mvt_layer_to_tile(layer: MvtLayer) -> MltResult<TileLayer> {
function coord (line 153) | fn coord(c: impl AsRef<Coord<f32>>) -> Coord<i32> {
function convert_geometry (line 162) | fn convert_geometry(geom: &Geom<f32>) -> MltResult<Geometry<i32>> {
function convert_polygon (line 195) | fn convert_polygon(poly: &Polygon<f32>) -> Polygon<i32> {
function convert_value (line 205) | fn convert_value(val: &MvtValue) -> Value {
type InferredType (line 219) | enum InferredType {
method from_mvt (line 230) | fn from_mvt(val: &MvtValue) -> Self {
method merge (line 243) | fn merge(self, other: Self) -> Self {
method typed_null (line 265) | fn typed_null(self) -> PropValue {
method convert (line 277) | fn convert(self, val: MvtValue) -> PropValue {
FILE: rust/mlt-core/src/decoder/analyze.rs
method collect_statistic (line 14) | fn collect_statistic(&self, stat: StatType) -> usize {
method for_each_stream (line 26) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 34) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method collect_statistic (line 41) | fn collect_statistic(&self, stat: StatType) -> usize {
method collect_statistic (line 59) | fn collect_statistic(&self, _stat: StatType) -> usize {
method for_each_stream (line 65) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 72) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 80) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 86) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 93) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 102) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 122) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 129) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 136) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 143) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 152) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method for_each_stream (line 159) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
FILE: rust/mlt-core/src/decoder/column.rs
function from_bytes (line 11) | pub(crate) fn from_bytes<'a>(
method from_bytes (line 37) | pub(crate) fn from_bytes(input: &[u8]) -> MltRefResult<'_, Self> {
method write_to (line 43) | pub(crate) fn write_to<W: Write>(self, writer: &mut W) -> io::Result<()> {
method has_name (line 51) | pub(crate) fn has_name(self) -> bool {
method is_optional (line 60) | pub(crate) fn is_optional(self) -> bool {
FILE: rust/mlt-core/src/decoder/fuzzing.rs
type LayerOrdering (line 18) | pub enum LayerOrdering {
method from (line 26) | fn from(typ: ColumnType) -> Self {
type ArbitraryGeometry (line 40) | enum ArbitraryGeometry {
function from (line 46) | fn from(value: ArbitraryGeometry) -> Self {
method arbitrary (line 54) | fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
FILE: rust/mlt-core/src/decoder/geometry/decode.rs
function push_consecutive_offsets (line 12) | fn push_consecutive_offsets(
function decode_geometry_types (line 26) | pub fn decode_geometry_types(
function decode_root_length_stream (line 41) | pub fn decode_root_length_stream(
function decode_level1_without_ring_buffer_length_stream (line 73) | pub fn decode_level1_without_ring_buffer_length_stream(
function decode_level1_length_stream (line 114) | pub fn decode_level1_length_stream(
function decode_level2_length_stream (line 160) | pub fn decode_level2_length_stream(
function from_bytes (line 220) | pub fn from_bytes(input: &'a [u8], parser: &mut Parser) -> crate::MltRef...
function decode (line 252) | fn decode(self, dec: &mut Decoder) -> MltResult<GeometryValues> {
FILE: rust/mlt-core/src/decoder/geometry/geotype.rs
method is_polygon (line 17) | pub fn is_polygon(self) -> bool {
method is_linestring (line 21) | pub fn is_linestring(self) -> bool {
method is_multi (line 25) | pub fn is_multi(self) -> bool {
method vector_types (line 36) | pub fn vector_types(&self) -> &[GeometryType] {
method geometry_offsets (line 43) | pub fn geometry_offsets(&self) -> Option<&[u32]> {
method part_offsets (line 51) | pub fn part_offsets(&self) -> Option<&[u32]> {
method ring_offsets (line 58) | pub fn ring_offsets(&self) -> Option<&[u32]> {
method index_buffer (line 65) | pub fn index_buffer(&self) -> Option<&[u32]> {
method triangles (line 72) | pub fn triangles(&self) -> Option<&[u32]> {
method vertices (line 78) | pub fn vertices(&self) -> Option<&[i32]> {
method to_geojson (line 85) | pub fn to_geojson(&self, index: usize) -> MltResult<Geometry<i32>> {
FILE: rust/mlt-core/src/decoder/geometry/model.rs
type Geometry (line 13) | pub type Geometry<'a, S = Lazy> = <S as DecodeState>::LazyOrParsed<RawGe...
type RawGeometry (line 17) | pub struct RawGeometry<'a> {
type GeometryValues (line 24) | pub struct GeometryValues {
type GeometryType (line 59) | pub enum GeometryType {
FILE: rust/mlt-core/src/decoder/id/decode.rs
function decode (line 7) | fn decode(self, dec: &mut Decoder) -> MltResult<ParsedId<'a>> {
FILE: rust/mlt-core/src/decoder/id/model.rs
type Id (line 12) | pub type Id<'a, S = Lazy> = <S as DecodeState>::LazyOrParsed<RawId<'a>, ...
type RawId (line 16) | pub struct RawId<'a> {
type RawIdValue (line 23) | pub enum RawIdValue<'a> {
type ParsedId (line 39) | pub struct ParsedId<'a>(pub(crate) Presence<'a, u64>);
type Target (line 42) | type Target = Presence<'a, u64>;
method deref (line 45) | fn deref(&self) -> &Self::Target {
FILE: rust/mlt-core/src/decoder/iterators.rs
type LendingIterator (line 40) | pub trait LendingIterator {
method next (line 47) | fn next(&mut self) -> Option<Self::Item<'_>>;
type Item (line 475) | type Item<'this>
method next (line 480) | fn next(&mut self) -> Option<Self::Item<'_>> {
function iterate_prop_names (line 58) | pub fn iterate_prop_names(&self) -> impl Iterator<Item = PropName<'a>> +...
function iter_features (line 102) | pub fn iter_features(&self) -> Layer01FeatureIter<'_, 'a> {
function iterate_prop_names (line 108) | pub fn iterate_prop_names(&self) -> impl Iterator<Item = PropName<'a>> +...
type PropName (line 123) | pub struct PropName<'a>(&'a str, &'a str);
function fmt (line 126) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
function eq (line 133) | fn eq(&self, other: &PropName<'_>) -> bool {
function eq (line 146) | fn eq(&self, other: &str) -> bool {
function eq (line 152) | fn eq(&self, other: &PropName<'_>) -> bool {
function eq (line 158) | fn eq(&self, other: &&str) -> bool {
function eq (line 164) | fn eq(&self, other: &PropName<'_>) -> bool {
type PropValueRef (line 174) | pub enum PropValueRef<'a> {
type ColumnRef (line 206) | pub struct ColumnRef<'a> {
type FeatureRef (line 216) | pub struct FeatureRef<'feat, 'layer: 'feat> {
function iter_all_properties (line 236) | pub fn iter_all_properties(&self) -> impl Iterator<Item = Option<PropVal...
function iter_properties (line 244) | pub fn iter_properties(&self) -> impl Iterator<Item = ColumnRef<'layer>>...
function get_property (line 255) | pub fn get_property(&self, name: &str) -> Option<PropValueRef<'layer>> {
type Layer01PropNamesIter (line 268) | pub(crate) struct Layer01PropNamesIter<'a, 'p> {
function new (line 275) | pub(crate) fn new(props: &'a [ParsedProperty<'p>]) -> Self {
type Item (line 285) | type Item = PropName<'a>;
method next (line 287) | fn next(&mut self) -> Option<PropName<'a>> {
function parsed_col_name (line 304) | fn parsed_col_name<'p>(prop: &ParsedProperty<'p>, dict_idx: &mut usize) ...
function raw_col_name (line 332) | fn raw_col_name<'p>(prop: &RawProperty<'p>, dict_idx: &mut usize) -> Opt...
type ColValIter (line 359) | type ColValIter<'l> = Box<dyn Iterator<Item = Option<PropValueRef<'l>>> ...
function build_col_iters (line 365) | fn build_col_iters<'p>(columns: &'p [ParsedProperty<'p>]) -> Vec<ColValI...
function scalar_col_iter (line 418) | fn scalar_col_iter<'p, T>(scalar: &'p ParsedScalar<'p, T>) -> ColValIter...
type Layer01FeatureIter (line 435) | pub struct Layer01FeatureIter<'layer, 'data: 'layer> {
function new (line 448) | fn new(layer: &'layer Layer01<'data, Parsed>) -> Self {
function len (line 463) | pub fn len(&self) -> usize {
function is_empty (line 469) | pub fn is_empty(&self) -> bool {
function layer_buf (line 520) | fn layer_buf(staged: StagedLayer) -> Vec<u8> {
function three_points (line 528) | fn three_points() -> GeometryValues {
function empty_layer (line 536) | fn empty_layer(name: &str) -> StagedLayer {
function prop_name_display_concatenates_parts (line 547) | fn prop_name_display_concatenates_parts() {
function prop_name_eq_str_matches_concatenation (line 554) | fn prop_name_eq_str_matches_concatenation() {
function prop_name_structural_eq_is_part_wise (line 563) | fn prop_name_structural_eq_is_part_wise() {
function prop_name_eq_prop_name_semantic_equality (line 569) | fn prop_name_eq_prop_name_semantic_equality() {
function prop_value_ref_scalars_convert_to_json (line 581) | fn prop_value_ref_scalars_convert_to_json() {
function prop_value_ref_float_finite_is_number (line 606) | fn prop_value_ref_float_finite_is_number() {
function prop_value_ref_float_non_finite_becomes_string_sentinel (line 618) | fn prop_value_ref_float_non_finite_becomes_string_sentinel() {
function empty_layer_yields_no_features (line 638) | fn empty_layer_yields_no_features() {
function len_decreases_with_each_next (line 653) | fn len_decreases_with_each_next() {
function feature_ids_are_preserved (line 678) | fn feature_ids_are_preserved() {
function geometry_values_match_input (line 699) | fn geometry_values_match_input() {
function null_scalar_values_are_skipped (line 722) | fn null_scalar_values_are_skipped() {
function null_string_values_are_skipped (line 764) | fn null_string_values_are_skipped() {
function multiple_columns_independently_nullable (line 795) | fn multiple_columns_independently_nullable() {
function geometry_error_does_not_misalign_ids (line 836) | fn geometry_error_does_not_misalign_ids() {
function get_property_absent_column_returns_none (line 876) | fn get_property_absent_column_returns_none() {
function shared_dict_columns_are_expanded (line 894) | fn shared_dict_columns_are_expanded() {
FILE: rust/mlt-core/src/decoder/layer.rs
function as_layer01 (line 9) | pub fn as_layer01(&self) -> Option<&Layer01<'a, S>> {
function into_layer01 (line 18) | pub fn into_layer01(self) -> Option<Layer01<'a, S>> {
function from_bytes (line 29) | pub(crate) fn from_bytes(input: &'a [u8], parser: &mut Parser) -> MltRef...
function decode_all (line 52) | pub fn decode_all(self, dec: &mut Decoder) -> MltResult<ParsedLayer<'a>> {
FILE: rust/mlt-core/src/decoder/model.rs
type Layer (line 14) | pub enum Layer<'a, S: DecodeState = Lazy> {
type ParsedLayer (line 20) | pub type ParsedLayer<'a> = Layer<'a, Parsed>;
function fmt (line 26) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
type Unknown (line 40) | pub struct Unknown<'a> {
function tag (line 48) | pub fn tag(&self) -> u32 {
function data (line 54) | pub fn data(&self) -> &'a [u8] {
type Column (line 61) | pub struct Column<'a> {
type ColumnType (line 70) | pub enum ColumnType {
type Layer01 (line 109) | pub struct Layer01<'a, S: DecodeState = Lazy> {
type ParsedLayer01 (line 119) | pub type ParsedLayer01<'a> = Layer01<'a, Parsed>;
function fmt (line 128) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
method clone (line 148) | fn clone(&self) -> Self {
type TileLayer (line 167) | pub struct TileLayer {
type TileFeature (line 177) | pub struct TileFeature {
type PropValue (line 194) | pub enum PropValue {
type PropKind (line 209) | pub enum PropKind {
method from (line 222) | fn from(prop: &PropValue) -> Self {
FILE: rust/mlt-core/src/decoder/property/decode.rs
function from_parts (line 6) | pub fn from_parts(
function decode (line 24) | fn decode(self, dec: &mut Decoder) -> MltResult<ParsedProperty<'a>> {
FILE: rust/mlt-core/src/decoder/property/geojson.rs
function name (line 5) | pub fn name(&self) -> &str {
FILE: rust/mlt-core/src/decoder/property/model.rs
type Property (line 14) | pub type Property<'a, S = Lazy> =
type RawScalar (line 19) | pub struct RawScalar<'a> {
type RawStrings (line 27) | pub struct RawStrings<'a> {
type RawStringsEncoding (line 37) | pub enum RawStringsEncoding<'a> {
type RawSharedDictEncoding (line 60) | pub enum RawSharedDictEncoding<'a> {
type RawSharedDict (line 69) | pub struct RawSharedDict<'a> {
type RawProperty (line 77) | pub enum RawProperty<'a> {
type ParsedProperty (line 95) | pub enum ParsedProperty<'a> {
type ParsedScalar (line 116) | pub struct ParsedScalar<'a, T: Copy + PartialEq> {
type Target (line 121) | type Target = Presence<'a, T>;
method deref (line 123) | fn deref(&self) -> &Self::Target {
type DictRange (line 135) | pub struct DictRange {
constant NULL (line 141) | pub const NULL: Self = Self { start: -1, end: -1 };
type ParsedSharedDictItem (line 147) | pub struct ParsedSharedDictItem<'a> {
type ParsedStrings (line 160) | pub struct ParsedStrings<'a> {
type ParsedSharedDict (line 182) | pub struct ParsedSharedDict<'a> {
type RawSharedDictItem (line 190) | pub struct RawSharedDictItem<'a> {
type RawPlainData (line 198) | pub struct RawPlainData<'a> {
type RawFsstData (line 205) | pub struct RawFsstData<'a> {
type RawPresence (line 214) | pub struct RawPresence<'a>(pub Option<RawStream<'a>>);
FILE: rust/mlt-core/src/decoder/property/strings.rs
function new (line 16) | pub fn new(name: &'a str, lengths: Vec<i32>, data: Cow<'a, str>) -> Self {
function feature_count (line 25) | pub fn feature_count(&self) -> usize {
function presence_bools (line 30) | pub fn presence_bools(&self) -> Vec<bool> {
function get (line 35) | pub fn get(&self, idx: u32) -> Option<&str> {
function dense_values (line 54) | pub fn dense_values(&self) -> Vec<String> {
function materialize (line 72) | pub fn materialize(&self) -> Vec<Option<String>> {
function decode_shared_dict_range (line 79) | pub(crate) fn decode_shared_dict_range(range: DictRange) -> Option<(u32,...
function shared_dict_spans (line 87) | pub(crate) fn shared_dict_spans(lengths: &[u32], dec: &mut Decoder) -> M...
function resolve_dict_spans (line 98) | pub(crate) fn resolve_dict_spans(
function dict_span_str (line 144) | fn dict_span_str(dict_data: &str, span: (u32, u32)) -> MltResult<&str> {
function corpus (line 157) | pub fn corpus(&self) -> &str {
function get (line 162) | pub fn get(&self, span: (u32, u32)) -> Option<&str> {
function get (line 171) | pub fn get<'a>(&self, shared_dict: &'a ParsedSharedDict<'_>, i: usize) -...
function new (line 181) | pub fn new(lengths: RawStream<'a>, data: RawStream<'a>) -> MltResult<Sel...
function decode (line 195) | pub fn decode(self, dec: &mut Decoder) -> MltResult<(&'a str, Vec<u32>)> {
function new (line 204) | pub fn new(
function decode (line 225) | pub fn decode(self, dec: &mut Decoder) -> MltResult<(String, Vec<u32>)> {
function plain (line 232) | pub fn plain(plain_data: RawPlainData<'a>) -> Self {
function dictionary (line 236) | pub fn dictionary(plain_data: RawPlainData<'a>, offsets: RawStream<'a>) ...
function fsst_plain (line 245) | pub fn fsst_plain(fsst_data: RawFsstData<'a>) -> Self {
function fsst_dictionary (line 249) | pub fn fsst_dictionary(fsst_data: RawFsstData<'a>, offsets: RawStream<'a...
function plain (line 258) | pub fn plain(plain_data: RawPlainData<'a>) -> Self {
function fsst_plain (line 264) | pub fn fsst_plain(fsst_data: RawFsstData<'a>) -> Self {
function new (line 271) | pub fn new(name: &'a str, presence: RawPresence<'a>, encoding: RawString...
function decode (line 280) | pub fn decode(self, dec: &mut Decoder) -> MltResult<ParsedStrings<'a>> {
function to_absolute_lengths (line 329) | fn to_absolute_lengths(
function decode_dictionary_strings (line 366) | fn decode_dictionary_strings<'a>(
function encode_null_end (line 396) | pub(crate) fn encode_null_end(end: i32) -> i32 {
function decode_end (line 400) | fn decode_end(end: i32) -> u32 {
function checked_string_end (line 408) | pub(crate) fn checked_string_end(current_end: i32, byte_len: usize) -> M...
function checked_absolute_end (line 413) | pub(crate) fn checked_absolute_end(current_end: i32, delta: u32) -> MltR...
function new (line 420) | pub fn new(
function decode (line 433) | pub fn decode(self, dec: &mut Decoder) -> MltResult<ParsedSharedDict<'a>> {
function encode_shared_dict_range (line 485) | pub(crate) fn encode_shared_dict_range(start: u32, end: u32) -> MltResul...
FILE: rust/mlt-core/src/decoder/root.rs
constant DEFAULT_MAX_BYTES (line 19) | const DEFAULT_MAX_BYTES: u32 = 20 * 1024 * 1024;
type Decoder (line 38) | pub struct Decoder {
method with_max_size (line 52) | pub fn with_max_size(max_bytes: u32) -> Self {
method decode_all (line 59) | pub fn decode_all<'a>(
method alloc (line 72) | pub(crate) fn alloc<T>(&mut self, capacity: usize) -> MltResult<Vec<T>> {
method consume (line 82) | pub(crate) fn consume(&mut self, size: u32) -> MltResult<()> {
method consume_items (line 88) | pub(crate) fn consume_items<T>(&mut self, count: usize) -> MltResult<(...
method adjust (line 94) | pub(crate) fn adjust(&mut self, adjustment: u32) {
method adjust_alloc (line 106) | pub(crate) fn adjust_alloc<T>(&mut self, buf: &[T], alloc_size: usize)...
method consumed (line 123) | pub fn consumed(&self) -> u32 {
method reset_budget (line 141) | pub fn reset_budget(&mut self) {
type Parser (line 170) | pub struct Parser {
method with_max_size (line 177) | pub fn with_max_size(max_bytes: u32) -> Self {
method parse_layers (line 184) | pub fn parse_layers<'a>(&mut self, mut input: &'a [u8]) -> MltResult<V...
method reserve (line 196) | pub(crate) fn reserve(&mut self, size: u32) -> MltResult<()> {
method reserved (line 201) | pub fn reserved(&self) -> u32 {
type MemBudget (line 207) | struct MemBudget {
method reset (line 151) | fn reset(&mut self) {
method with_max_size (line 224) | fn with_max_size(max_bytes: u32) -> Self {
method adjust (line 233) | fn adjust(&mut self, adjustment: u32) {
method consume (line 239) | fn consume(&mut self, size: u32) -> MltResult<()> {
method consumed (line 257) | fn consumed(&self) -> u32 {
method default (line 216) | fn default() -> Self {
function from_bytes (line 264) | pub(crate) fn from_bytes(input: &'a [u8], parser: &mut Parser) -> MltRes...
function decode_all (line 391) | pub fn decode_all(self, dec: &mut Decoder) -> MltResult<ParsedLayer01<'a...
function parse_struct_children (line 408) | fn parse_struct_children<'a>(
function parse_optional (line 434) | fn parse_optional<'a>(
function parse_geometry_column (line 447) | fn parse_geometry_column<'a>(
function parse_str_column (line 469) | fn parse_str_column<'a>(
function parse_shared_dict_column (line 522) | fn parse_shared_dict_column<'a>(
function parse_columns_meta (line 590) | fn parse_columns_meta<'a>(
function scalar (line 638) | fn scalar<'a>(name: &'a str, opt: Option<RawStream<'a>>, value: RawStrea...
FILE: rust/mlt-core/src/decoder/stream/analyze.rs
method collect_statistic (line 5) | fn collect_statistic(&self, stat: StatType) -> usize {
method for_each_stream (line 9) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method collect_statistic (line 15) | fn collect_statistic(&self, stat: StatType) -> usize {
FILE: rust/mlt-core/src/decoder/stream/decode.rs
function decode_bitvec (line 22) | pub(crate) fn decode_bitvec(self, dec: &mut Decoder) -> MltResult<Cow<'a...
function decode_bools (line 44) | pub fn decode_bools(self, dec: &mut Decoder) -> MltResult<Vec<bool>> {
function decode_i8s (line 54) | pub fn decode_i8s(self, dec: &mut Decoder) -> MltResult<Vec<i8>> {
function decode_u8s (line 62) | pub fn decode_u8s(self, dec: &mut Decoder) -> MltResult<Vec<u8>> {
function decode_i32s (line 70) | pub fn decode_i32s(self, dec: &mut Decoder) -> MltResult<Vec<i32>> {
function decode_u32s (line 81) | pub fn decode_u32s(self, dec: &mut Decoder) -> MltResult<Vec<u32>> {
function decode_u64s (line 99) | pub fn decode_u64s(self, dec: &mut Decoder) -> MltResult<Vec<u64>> {
function decode_i64s (line 117) | pub fn decode_i64s(self, dec: &mut Decoder) -> MltResult<Vec<i64>> {
function decode_f32s (line 129) | pub fn decode_f32s(self, dec: &mut Decoder) -> MltResult<Vec<f32>> {
function decode_f64s (line 145) | pub fn decode_f64s(self, dec: &mut Decoder) -> MltResult<Vec<f64>> {
function decode_bits_u32 (line 165) | pub fn decode_bits_u32(self, buf: &mut Vec<u32>, dec: &mut Decoder) -> M...
function decode_bits_u64 (line 189) | pub fn decode_bits_u64(self, buf: &mut Vec<u64>, dec: &mut Decoder) -> M...
FILE: rust/mlt-core/src/decoder/stream/logical.rs
method decode (line 16) | pub fn decode<T: PrimInt + Debug>(self, data: &[T], dec: &mut Decoder) -...
method calc_size (line 35) | fn calc_size<T: PrimInt + Debug>(run_lens: &[T]) -> MltResult<u32> {
method parse (line 45) | pub fn parse(value: u8) -> MltResult<Self> {
method new (line 52) | pub fn new(meta: StreamMeta) -> Self {
method decode_i32 (line 60) | pub fn decode_i32(self, data: &[u32], dec: &mut Decoder) -> MltResult<Ve...
method decode_u32 (line 87) | pub fn decode_u32(self, data: &[u32], dec: &mut Decoder) -> MltResult<Ve...
method decode_i64 (line 111) | pub fn decode_i64(self, data: &[u64], dec: &mut Decoder) -> MltResult<Ve...
method decode_u64 (line 135) | pub fn decode_u64(self, data: &[u64], dec: &mut Decoder) -> MltResult<Ve...
function test_decode_rle_empty (line 164) | fn test_decode_rle_empty() {
function test_decode_rle_invalid_stream_size (line 173) | fn test_decode_rle_invalid_stream_size() {
FILE: rust/mlt-core/src/decoder/stream/model.rs
type LogicalTechnique (line 10) | pub enum LogicalTechnique {
type RleMeta (line 25) | pub struct RleMeta {
type Morton (line 32) | pub struct Morton {
method new (line 40) | pub fn new(bits: u32, shift: u32) -> MltResult<Self> {
type LogicalEncoding (line 51) | pub enum LogicalEncoding {
type LogicalValue (line 69) | pub struct LogicalValue {
type DictionaryType (line 78) | pub enum DictionaryType {
type OffsetType (line 90) | pub enum OffsetType {
type LengthType (line 100) | pub enum LengthType {
type StreamType (line 112) | pub enum StreamType {
type PhysicalEncoding (line 122) | pub enum PhysicalEncoding {
type IntEncoding (line 135) | pub struct IntEncoding {
type StreamMeta (line 142) | pub struct StreamMeta {
type RawStream (line 152) | pub struct RawStream<'a> {
FILE: rust/mlt-core/src/decoder/stream/parse.rs
method new (line 16) | pub(crate) const fn new(logical: LogicalEncoding, physical: PhysicalEnco...
method none (line 21) | pub(crate) const fn none() -> Self {
method new (line 28) | pub(crate) fn new(stream_type: StreamType, encoding: IntEncoding, num_va...
method new2 (line 37) | pub(crate) fn new2(
method new_none (line 48) | pub(crate) fn new_none(stream_type: StreamType, num_values: usize) -> Ml...
method from_bytes (line 61) | pub(crate) fn from_bytes<'a>(
method write_to (line 139) | pub(crate) fn write_to<W: io::Write>(
function new (line 189) | pub(crate) fn new(meta: StreamMeta, data: &'a [u8]) -> Self {
function from_bytes (line 193) | pub(crate) fn from_bytes(input: &'a [u8], parser: &mut Parser) -> MltRef...
function parse_multiple (line 197) | pub(crate) fn parse_multiple(
function parse_bool (line 211) | pub(crate) fn parse_bool(input: &'a [u8], parser: &mut Parser) -> MltRef...
function from_bytes_internal (line 219) | fn from_bytes_internal(
function validate_rle_varint_stream (line 243) | fn validate_rle_varint_stream(data: &[u8], runs: u32, num_rle_values: u3...
FILE: rust/mlt-core/src/decoder/stream/physical.rs
method from_bytes (line 7) | pub fn from_bytes(input: &'_ [u8]) -> MltRefResult<'_, Self> {
method from_u8 (line 13) | fn from_u8(value: u8) -> Option<Self> {
method as_u8 (line 29) | pub fn as_u8(self) -> u8 {
FILE: rust/mlt-core/src/decoder/tile.rs
function geometry_values (line 24) | pub fn geometry_values(&self) -> &GeometryValues {
function into_tile (line 30) | pub fn into_tile(self, dec: &mut Decoder) -> MltResult<TileLayer> {
function feature_count (line 66) | pub fn feature_count(&self) -> usize {
function into_tile (line 73) | pub fn into_tile(self, dec: &mut Decoder) -> MltResult<TileLayer> {
function prop_value_from_ref (line 80) | fn prop_value_from_ref(value: PropValueRef<'_>) -> PropValue {
function typed_nulls (line 101) | fn typed_nulls(properties: &[ParsedProperty<'_>]) -> Vec<PropValue> {
function charge_str_props (line 128) | fn charge_str_props(dec: &mut Decoder, props: &[PropValue]) -> MltResult...
FILE: rust/mlt-core/src/encoder/analyze.rs
method for_each_stream (line 10) | fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta)) {
method collect_statistic (line 16) | fn collect_statistic(&self, stat: StatType) -> usize {
method collect_statistic (line 27) | fn collect_statistic(&self, stat: StatType) -> usize {
method collect_statistic (line 38) | fn collect_statistic(&self, stat: StatType) -> usize {
FILE: rust/mlt-core/src/encoder/fuzzing.rs
method arbitrary (line 9) | fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
method arbitrary (line 18) | fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
method arbitrary (line 64) | fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
method arbitrary (line 91) | fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
method arbitrary (line 100) | fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
function bounded_string (line 109) | pub fn bounded_string(u: &mut Unstructured<'_>, max_len: u8) -> Result<S...
function generate_strings (line 116) | fn generate_strings(u: &mut Unstructured) -> Result<Vec<Option<String>>> {
FILE: rust/mlt-core/src/encoder/geometry/encode.rs
function build_morton_dict (line 29) | fn build_morton_dict(vertices: &[i32], meta: Morton) -> MltResult<(Vec<u...
function build_hilbert_dict (line 64) | fn build_hilbert_dict(
function extend_offsets (line 123) | fn extend_offsets(lengths: &mut Vec<u32>, offsets: &[u32]) -> usize {
function encode_root_length_stream (line 137) | fn encode_root_length_stream(
function encode_level1_length_stream (line 162) | fn encode_level1_length_stream(
function encode_ring_lengths_for_mixed (line 190) | fn encode_ring_lengths_for_mixed(
function encode_level2_length_stream (line 212) | fn encode_level2_length_stream(
function encode_level1_without_ring_buffer_length_stream (line 251) | fn encode_level1_without_ring_buffer_length_stream(
function normalize_geometry_offsets (line 271) | fn normalize_geometry_offsets(vector_types: &[GeometryType], geom_offset...
function normalize_part_offsets_for_rings (line 308) | fn normalize_part_offsets_for_rings(
function dict_may_be_beneficial (line 353) | fn dict_may_be_beneficial(vertices: &[i32], enc: &Encoder) -> bool {
function get_morton (line 375) | fn get_morton(enc: &Encoder) -> Morton {
function get_hilbert_params (line 382) | fn get_hilbert_params(enc: &Encoder) -> CurveParams {
function encode_vec2_vertex_stream (line 389) | fn encode_vec2_vertex_stream(
function encode_morton_vertex_streams (line 402) | fn encode_morton_vertex_streams(
function encode_hilbert_vertex_streams (line 424) | fn encode_hilbert_vertex_streams(
function write_geo_u32_stream (line 472) | fn write_geo_u32_stream(
function write_geo_precomputed_stream (line 490) | fn write_geo_precomputed_stream(
method write_to (line 527) | pub fn write_to(self, enc: &mut Encoder, codecs: &mut Codecs) -> MltResu...
function encode_morton_deltas (line 724) | fn encode_morton_deltas<'a>(codes: &[u32], buffer: &'a mut Vec<u32>) -> ...
function test_build_morton_dict (line 738) | fn test_build_morton_dict() {
function test_encode_root_length_stream (line 754) | fn test_encode_root_length_stream() {
FILE: rust/mlt-core/src/encoder/geometry/geotype.rs
type Error (line 7) | type Error = ();
method try_from (line 9) | fn try_from(geom: &Geometry<i32>) -> Result<Self, Self::Error> {
function earcut_into (line 29) | fn earcut_into(polygon: &Polygon<i32>, vertex_offset: u32, index_buf: &m...
method new_tessellated (line 53) | pub fn new_tessellated() -> Self {
method tessellate_polygon (line 62) | fn tessellate_polygon(&mut self, polygon: &Polygon<i32>) {
method tessellate_multi_polygon (line 77) | fn tessellate_multi_polygon(&mut self, mp: &MultiPolygon<i32>) {
method with_geom (line 95) | pub fn with_geom(mut self, geom: &Geometry<i32>) -> Self {
method push_geom (line 101) | pub fn push_geom(&mut self, geom: &Geometry<i32>) {
method push_point (line 120) | fn push_point(&mut self, coord: Coord<i32>) {
method push_linestring (line 127) | fn push_linestring(&mut self, ls: &LineString<i32>) {
method push_polygon (line 142) | fn push_polygon(&mut self, poly: &Polygon<i32>) {
method init_polygon_offsets (line 161) | fn init_polygon_offsets(&mut self) {
method push_multi_point (line 171) | fn push_multi_point(&mut self, mp: &MultiPoint<i32>) {
method push_multi_linestring (line 182) | fn push_multi_linestring(&mut self, mls: &MultiLineString<i32>) {
method push_multi_polygon (line 198) | fn push_multi_polygon(&mut self, mp: &MultiPolygon<i32>) {
method push_geometry_count (line 215) | fn push_geometry_count(&mut self, count: u32) {
function init_offsets (line 223) | fn init_offsets(v: &mut Vec<u32>) {
function push_polygon_rings (line 231) | fn push_polygon_rings(
function push_ring (line 246) | fn push_ring(ring: &LineString<i32>, verts: &mut Vec<i32>, rings: &mut V...
function push_linestrings (line 261) | fn push_linestrings<'a>(
function roundtrip (line 298) | fn roundtrip(decoded: &GeometryValues) -> GeometryValues {
function roundtrip_via_push (line 324) | fn roundtrip_via_push(geoms: &[Geometry<i32>]) -> (GeometryValues, Geome...
function arb_coord (line 334) | fn arb_coord() -> impl Strategy<Value = Coord<i32>> {
function arb_geom (line 338) | fn arb_geom() -> impl Strategy<Value = Geometry<i32>> {
function arb_mixed_linestring_geoms (line 372) | fn arb_mixed_linestring_geoms() -> impl Strategy<Value = Vec<Geometry<i3...
function arb_mixed_point_geoms (line 396) | fn arb_mixed_point_geoms() -> impl Strategy<Value = Vec<Geometry<i32>>> {
function arb_mixed_polygon_geoms (line 418) | fn arb_mixed_polygon_geoms() -> impl Strategy<Value = Vec<Geometry<i32>>> {
function arb_cross_point_mls_geoms (line 442) | fn arb_cross_point_mls_geoms() -> impl Strategy<Value = Vec<Geometry<i32...
function arb_cross_point_mpoly_geoms (line 465) | fn arb_cross_point_mpoly_geoms() -> impl Strategy<Value = Vec<Geometry<i...
function arb_cross_ls_mpoly_geoms (line 488) | fn arb_cross_ls_mpoly_geoms() -> impl Strategy<Value = Vec<Geometry<i32>...
function test_morton_vertex_dictionary_expansion (line 562) | fn test_morton_vertex_dictionary_expansion() {
function earcut_polygon_indices_in_range (line 639) | fn earcut_polygon_indices_in_range() {
function earcut_vertex_offset_for_multi_polygon_parts (line 654) | fn earcut_vertex_offset_for_multi_polygon_parts() {
FILE: rust/mlt-core/src/encoder/geometry/model.rs
type VertexBufferType (line 5) | pub enum VertexBufferType {
FILE: rust/mlt-core/src/encoder/geometry/tests.rs
function automatic_optimization_roundtrip (line 18) | fn automatic_optimization_roundtrip(#[case] decoded: GeometryValues) {
function auto_mode_streams (line 28) | fn auto_mode_streams(decoded: &GeometryValues) -> Vec<StreamType> {
function automatic_optimization_distinct_points_picks_vec2 (line 44) | fn automatic_optimization_distinct_points_picks_vec2() {
function automatic_optimization_repeated_points_picks_dict (line 63) | fn automatic_optimization_repeated_points_picks_dict() {
function encoded_output_always_has_meta_stream (line 86) | fn encoded_output_always_has_meta_stream() {
function encoded_polygon_has_topology_streams (line 103) | fn encoded_polygon_has_topology_streams() {
function forced_vertex_strategy_streams (line 129) | fn forced_vertex_strategy_streams(
function repeated_multipoint (line 152) | fn repeated_multipoint() -> GeometryValues {
function forced_vec2_streams (line 159) | fn forced_vec2_streams() {
function forced_morton_streams (line 177) | fn forced_morton_streams() {
function forced_hilbert_streams (line 198) | fn forced_hilbert_streams() {
function manual_encode_works (line 219) | fn manual_encode_works() {
function assert_geometry_roundtrip (line 235) | fn assert_geometry_roundtrip(data: &[u8], expected: &GeometryValues) {
function push_geoms (line 247) | fn push_geoms(geoms: &[Geometry<i32>]) -> GeometryValues {
function encoded_stream_types (line 256) | fn encoded_stream_types(data: &[u8]) -> HashSet<StreamType> {
FILE: rust/mlt-core/src/encoder/id/staged_id.rs
type StagedId (line 11) | pub enum StagedId {
method from_optional (line 25) | pub fn from_optional(ids: Vec<Option<u64>>) -> Self {
method from_optional_with_presence (line 81) | pub(crate) fn from_optional_with_presence(
method from_dense (line 99) | fn from_dense(ids: impl IntoIterator<Item = u64>, values_fit_u32: bool...
method from_optional_sparse (line 113) | fn from_optional_sparse(
method u32 (line 145) | pub fn u32(values: Vec<u32>) -> Self {
method opt_u32 (line 153) | pub fn opt_u32(values: impl IntoIterator<Item = Option<u32>>) -> Self {
method u64 (line 158) | pub fn u64(values: Vec<u64>) -> Self {
method opt_u64 (line 166) | pub fn opt_u64(values: impl IntoIterator<Item = Option<u64>>) -> Self {
method write_to (line 172) | pub fn write_to(self, enc: &mut Encoder, codecs: &mut Codecs) -> MltRe...
function id_roundtrip_via_layer (line 198) | fn id_roundtrip_via_layer(decoded: &StagedId, int_enc: IntEncoder) -> St...
function id_roundtrip_auto (line 229) | fn id_roundtrip_auto(decoded: &StagedId) -> StagedId {
function create_u32_range_ids (line 269) | fn create_u32_range_ids() -> StagedId {
function create_u64_range_ids (line 273) | fn create_u64_range_ids() -> StagedId {
function create_ids_with_nulls (line 278) | fn create_ids_with_nulls() -> StagedId {
function create_constant_ids (line 282) | fn create_constant_ids() -> StagedId {
function feature_count (line 286) | fn feature_count(ids: &StagedId) -> usize {
function id_values (line 296) | fn id_values(ids: &StagedId) -> Vec<Option<u64>> {
function test_automatic_encoding_skipped (line 322) | fn test_automatic_encoding_skipped(#[case] input: StagedId) {
function test_automatic_encoding_produces_output (line 340) | fn test_automatic_encoding_produces_output(#[case] input: StagedId) {
function test_automatic_optimization_roundtrip_empty (line 351) | fn test_automatic_optimization_roundtrip_empty() {
function test_automatic_optimization_roundtrip (line 364) | fn test_automatic_optimization_roundtrip(#[case] decoded: StagedId) {
function test_manual_optimization_applies_encoder (line 370) | fn test_manual_optimization_applies_encoder() {
function test_manual_u32_roundtrip (line 378) | fn test_manual_u32_roundtrip() {
function test_manual_fastpfor_roundtrip (line 386) | fn test_manual_fastpfor_roundtrip() {
function test_auto_fastpfor_beats_varint_for_large_u32_ids (line 395) | fn test_auto_fastpfor_beats_varint_for_large_u32_ids() {
function test_auto_roundtrip_large_u64_ids (line 418) | fn test_auto_roundtrip_large_u64_ids() {
function test_config_produces_correct_variant (line 432) | fn test_config_produces_correct_variant(#[case] column_type: CT, #[case]...
function test_roundtrip (line 463) | fn test_roundtrip(#[case] ids: StagedId) {
function test_sequential_ids (line 469) | fn test_sequential_ids(
function assert_roundtrip (line 535) | fn assert_roundtrip(ids: &StagedId, int_enc: IntEncoder) {
function prop_assert_roundtrip (line 539) | fn prop_assert_roundtrip(ids: &StagedId, int_enc: IntEncoder) -> Result<...
function roundtrip_id_values (line 547) | fn roundtrip_id_values(decoded: &StagedId, int_enc: IntEncoder) -> MltRe...
function with_encoded_raw_id (line 584) | fn with_encoded_raw_id<R>(
function assert_produces_correct_variant (line 618) | fn assert_produces_correct_variant(
FILE: rust/mlt-core/src/encoder/model.rs
type EncodedUnknown (line 9) | pub struct EncodedUnknown {
type CurveParams (line 17) | pub struct CurveParams {
method from_vertices (line 31) | pub fn from_vertices(vertices: &[i32]) -> Self {
method default (line 23) | fn default() -> Self {
type StagedLayer (line 49) | pub struct StagedLayer {
type EncoderConfig (line 63) | pub struct EncoderConfig {
method default (line 80) | fn default() -> Self {
type StrEncoding (line 102) | pub enum StrEncoding {
type ColumnKind (line 110) | pub enum ColumnKind {
type StreamCtx (line 118) | pub struct StreamCtx<'a> {
function new (line 128) | pub const fn new(
function id (line 144) | pub const fn id(stream_type: StreamType) -> Self {
function geom (line 150) | pub const fn geom(stream_type: StreamType, name: &'a str) -> Self {
function prop (line 156) | pub const fn prop(stream_type: StreamType, name: &'a str) -> Self {
function prop_data (line 162) | pub const fn prop_data(name: &'a str) -> Self {
function prop2 (line 169) | pub const fn prop2(stream_type: StreamType, prefix: &'a str, suffix: &'a...
type ExplicitEncoder (line 182) | pub struct ExplicitEncoder {
FILE: rust/mlt-core/src/encoder/optimizer.rs
method encode_into (line 19) | pub fn encode_into(self, mut enc: Encoder, codecs: &mut Codecs) -> MltRe...
function seed_curve_caches (line 45) | fn seed_curve_caches(enc: &mut Encoder, curve_params: CurveParams) {
constant SORT_TRIAL_THRESHOLD (line 52) | const SORT_TRIAL_THRESHOLD: usize = 512;
method encode (line 65) | pub fn encode(self, cfg: EncoderConfig) -> MltResult<Vec<u8>> {
type Presence (line 138) | pub enum Presence {
method from_bits (line 151) | pub fn from_bits(bits: &BitVec<u8>, existing: &[(BitVec<u8>, usize)]) ...
type SharedDictRole (line 166) | pub enum SharedDictRole {
type PropertyStats (line 177) | pub struct PropertyStats {
type LayerStats (line 184) | pub struct LayerStats {
type PropertyTypedStats (line 191) | pub enum PropertyTypedStats {
method values_fit_u32 (line 213) | pub fn values_fit_u32(&self) -> bool {
method shared_dict (line 222) | pub fn shared_dict(&self) -> SharedDictRole {
method set_shared_dict (line 229) | pub(crate) fn set_shared_dict(&mut self, role: SharedDictRole) {
method push (line 236) | pub(crate) fn push(
method merge_signed (line 272) | fn merge_signed(
method merge_unsigned (line 294) | fn merge_unsigned(
method merge_string (line 316) | fn merge_string(&mut self, column_idx: usize, property_name: &str) -> ...
method merge_same_kind (line 329) | fn merge_same_kind(
method analyze (line 349) | pub(crate) fn analyze(&self, allow_shared_dict: bool) -> MltResult<Layer...
method analyze_ids (line 359) | fn analyze_ids(&self, property_bits: &[(BitVec<u8>, usize)]) -> Option<P...
method analyze_properties (line 383) | fn analyze_properties(
function mixed_prop_err (line 425) | fn mixed_prop_err<T>(column_idx: usize, property_name: &str) -> MltResul...
FILE: rust/mlt-core/src/encoder/property/encode.rs
function write_properties (line 9) | pub fn write_properties(
function write_prop (line 22) | fn write_prop(prop: &StagedProperty, enc: &mut Encoder, codecs: &mut Cod...
method begin_opt_col (line 107) | fn begin_opt_col(
method write_u32_scalar_col (line 118) | pub(crate) fn write_u32_scalar_col(
method write_opt_u32_scalar_col (line 129) | pub(crate) fn write_opt_u32_scalar_col(
method write_u64_scalar_col (line 141) | pub(crate) fn write_u64_scalar_col(
method write_opt_u64_scalar_col (line 152) | pub(crate) fn write_opt_u64_scalar_col(
function begin_scalar_col (line 166) | fn begin_scalar_col(ct: ColumnType, name: Option<&str>, enc: &mut Encode...
function scalar_ctx (line 174) | fn scalar_ctx(name: Option<&str>) -> StreamCtx<'_> {
method bool (line 183) | pub fn bool(name: impl Into<String>, values: Vec<bool>) -> Self {
method i8 (line 190) | pub fn i8(name: impl Into<String>, values: Vec<i8>) -> Self {
method u8 (line 197) | pub fn u8(name: impl Into<String>, values: Vec<u8>) -> Self {
method i32 (line 204) | pub fn i32(name: impl Into<String>, values: Vec<i32>) -> Self {
method u32 (line 211) | pub fn u32(name: impl Into<String>, values: Vec<u32>) -> Self {
method i64 (line 218) | pub fn i64(name: impl Into<String>, values: Vec<i64>) -> Self {
method u64 (line 225) | pub fn u64(name: impl Into<String>, values: Vec<u64>) -> Self {
method f32 (line 232) | pub fn f32(name: impl Into<String>, values: Vec<f32>) -> Self {
method f64 (line 239) | pub fn f64(name: impl Into<String>, values: Vec<f64>) -> Self {
method str (line 246) | pub fn str(name: impl Into<String>, values: impl IntoIterator<Item = imp...
method opt_str (line 251) | pub fn opt_str(
method opt_bool (line 261) | pub fn opt_bool(
method opt_i8 (line 268) | pub fn opt_i8(name: impl Into<String>, values: impl IntoIterator<Item = ...
method opt_u8 (line 272) | pub fn opt_u8(name: impl Into<String>, values: impl IntoIterator<Item = ...
method opt_i32 (line 276) | pub fn opt_i32(name: impl Into<String>, values: impl IntoIterator<Item =...
method opt_u32 (line 280) | pub fn opt_u32(name: impl Into<String>, values: impl IntoIterator<Item =...
method opt_i64 (line 284) | pub fn opt_i64(name: impl Into<String>, values: impl IntoIterator<Item =...
method opt_u64 (line 288) | pub fn opt_u64(name: impl Into<String>, values: impl IntoIterator<Item =...
method opt_f32 (line 292) | pub fn opt_f32(name: impl Into<String>, values: impl IntoIterator<Item =...
method opt_f64 (line 296) | pub fn opt_f64(name: impl Into<String>, values: impl IntoIterator<Item =...
method name (line 301) | pub fn name(&self) -> &str {
function from_optional (line 331) | pub fn from_optional(
function from_parts (line 350) | pub(crate) fn from_parts(name: impl Into<String>, presence: Vec<bool>, v...
FILE: rust/mlt-core/src/encoder/property/model.rs
type StagedProperty (line 9) | pub enum StagedProperty {
type StagedScalar (line 38) | pub struct StagedScalar<T: Copy + PartialEq> {
type StagedOptScalar (line 49) | pub struct StagedOptScalar<T: Copy + PartialEq> {
type StagedStrings (line 57) | pub struct StagedStrings {
type StagedSharedDict (line 66) | pub struct StagedSharedDict {
type StagedSharedDictItem (line 74) | pub struct StagedSharedDictItem {
FILE: rust/mlt-core/src/encoder/property/shared_dict.rs
constant MINHASH_PERMUTATIONS (line 24) | const MINHASH_PERMUTATIONS: usize = 128;
constant MINHASH_SIMILARITY_THRESHOLD (line 28) | const MINHASH_SIMILARITY_THRESHOLD: f64 = 0.075;
type StringProfile (line 30) | struct StringProfile<'a> {
method group_string_properties (line 42) | pub(crate) fn group_string_properties(&self, properties: &mut [PropertyS...
function minhash_similarity (line 114) | fn minhash_similarity(a: &[u64], b: &[u64]) -> f64 {
function cluster_by_similarity (line 122) | fn cluster_by_similarity(profiles: Vec<StringProfile<'_>>) -> Vec<Vec<St...
function common_prefix_name (line 162) | fn common_prefix_name(profiles: &[StringProfile<'_>]) -> String {
method corpus (line 182) | pub fn corpus(&self) -> &str {
method get (line 187) | pub fn get(&self, span: (u32, u32)) -> Option<&str> {
function collect_staged_shared_dict_spans (line 192) | pub fn collect_staged_shared_dict_spans(items: &[StagedSharedDictItem]) ...
method feature_count (line 204) | pub fn feature_count(&self) -> usize {
method has_presen
Condensed preview — 1794 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (6,541K chars).
[
{
"path": ".clang-format",
"chars": 492,
"preview": "---\nBasedOnStyle: Google\nAccessModifierOffset: -4\nAllowShortEnumsOnASingleLine: false\nAllowShortFunctionsOnASingleLine: "
},
{
"path": ".cursor/rules/karpathy-guidelines.mdc",
"chars": 2407,
"preview": "---\ndescription: \nalwaysApply: true\n---\n\n# Karpathy behavioral guidelines\n\nBehavioral guidelines to reduce common LLM co"
},
{
"path": ".gitattributes",
"chars": 19,
"preview": "* text=auto eol=lf\n"
},
{
"path": ".github/FUNDING.yml",
"chars": 45,
"preview": "github: [maplibre]\nopen_collective: maplibre\n"
},
{
"path": ".github/actions/mlt-setup-java/action.yml",
"chars": 310,
"preview": "name: mlt-setup-java\ndescription: Setup Java requirements\n\ninputs: {}\n\nruns:\n using: \"composite\"\n steps:\n\n - name: "
},
{
"path": ".github/actions/mlt-setup-node/action.yml",
"chars": 348,
"preview": "name: mlt-setup-node\ndescription: Setup Node-JS requirements\n\ninputs: {}\n\nruns:\n using: \"composite\"\n steps:\n\n - nam"
},
{
"path": ".github/actions/mlt-setup-rust/action.yml",
"chars": 1266,
"preview": "name: mlt-setup-rust\ndescription: Setup Rust requirements\n\ninputs:\n toolchain:\n description: 'Rust toolchain to inst"
},
{
"path": ".github/dependabot.yml",
"chars": 2001,
"preview": "# To get started with Dependabot version updates, you'll need to specify which\n# package ecosystems to update and where "
},
{
"path": ".github/workflows/autofix.yml",
"chars": 4558,
"preview": "name: autofix.ci # See https://autofix.ci/security why this name\n\non:\n pull_request:\n types: [labeled, opened, synch"
},
{
"path": ".github/workflows/ci.yml",
"chars": 2204,
"preview": "name: CI\n\non:\n pull_request:\n push:\n branches: [main]\n workflow_dispatch:\n\njobs:\n changes:\n runs-on: ubuntu-la"
},
{
"path": ".github/workflows/cpp.yml",
"chars": 1395,
"preview": "name: C++ CI\n\non:\n workflow_call:\n workflow_dispatch:\n\njobs:\n cpp-build:\n permissions:\n id-token: write # fo"
},
{
"path": ".github/workflows/dependabot.yml",
"chars": 929,
"preview": "name: Dependabot auto-merge\non: pull_request\n\npermissions: write-all\n\njobs:\n dependabot:\n runs-on: ubuntu-latest\n "
},
{
"path": ".github/workflows/gh-pages.yml",
"chars": 720,
"preview": "name: Publish docs\n\non:\n workflow_call:\n workflow_dispatch:\n\njobs:\n gh-pages:\n runs-on: ubuntu-latest\n steps:\n "
},
{
"path": ".github/workflows/hotpath-comment.yml",
"chars": 1361,
"preview": "name: Rust Hotpath Comment\n\non:\n workflow_run:\n workflows: [\"Rust Hotpath Profile\"]\n types:\n - completed\n\npe"
},
{
"path": ".github/workflows/hotpath-profile.yml",
"chars": 2273,
"preview": "name: Rust Hotpath Profile\n\non:\n pull_request:\n paths:\n - \"rust/**\"\n\npermissions:\n contents: read\n\njobs:\n pro"
},
{
"path": ".github/workflows/java-release.yml",
"chars": 1925,
"preview": "name: Java - Release\n\non:\n push:\n tags:\n - 'java-v*.*.*'\n workflow_dispatch:\n\njobs:\n release:\n runs-on: ub"
},
{
"path": ".github/workflows/java.yml",
"chars": 1334,
"preview": "name: Java CI\n\non:\n workflow_call:\n workflow_dispatch:\n\ndefaults:\n run:\n shell: bash\n\njobs:\n test-java:\n permi"
},
{
"path": ".github/workflows/python-release.yml",
"chars": 7070,
"preview": "# This file is autogenerated by maturin v1.12.4\n# To update, run the following command, but make sure to keep the adjust"
},
{
"path": ".github/workflows/rust.yml",
"chars": 10996,
"preview": "name: Rust CI\n\non:\n workflow_call:\n inputs:\n run-release:\n type: boolean\n default: false\n workfl"
},
{
"path": ".github/workflows/ts-bump-version.yml",
"chars": 1156,
"preview": "name: Manual TypeScript Version Bump\n\non:\n workflow_dispatch:\n inputs:\n release_type:\n type: choice\n "
},
{
"path": ".github/workflows/ts-release.yml",
"chars": 2577,
"preview": "name: TypeScript - Release\n\npermissions:\n id-token: write # Required for trusted publishing\n contents: write\n\non:\n p"
},
{
"path": ".github/workflows/ts.yml",
"chars": 768,
"preview": "name: TypeScript CI\n\non:\n workflow_call:\n workflow_dispatch:\n\ndefaults:\n run:\n shell: bash\n\njobs:\n test-js:\n r"
},
{
"path": ".gitignore",
"chars": 192,
"preview": "*.class\n*.diff.geojson\n*.gcov\n*.log\n*.new.geojson\n*.actual.json\n.DS_Store\n.cache/\n.idea/\n.kotlin\n.venv\n.vscode/\nMODULE.b"
},
{
"path": ".gitmodules",
"chars": 431,
"preview": "[submodule \"cpp/vendor/googletest\"]\n\tpath = cpp/vendor/googletest\n\turl = https://github.com/google/googletest.git\n[submo"
},
{
"path": ".pre-commit-config.yaml",
"chars": 2011,
"preview": "# See https://pre-commit.com for more information\n# See https://pre-commit.com/hooks.html for more hooks\n\n# exclusions s"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 180,
"preview": "# Code of conduct\n\n[](https:/"
},
{
"path": "LICENSE-APACHE",
"chars": 10841,
"preview": " Apache License\n Version 2.0, January 2004\n http"
},
{
"path": "LICENSE-CC0",
"chars": 7048,
"preview": "Creative Commons Legal Code\n\nCC0 1.0 Universal\n\n CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n"
},
{
"path": "LICENSE-MIT",
"chars": 1078,
"preview": "MIT License\n\nCopyright (c) 2024 MapLibre contributors\n\nPermission is hereby granted, free of charge, to any\nperson obtai"
},
{
"path": "MODULE.bazel",
"chars": 134,
"preview": "module(name = \"maplibre-tile-spec\")\n\nbazel_dep(name = \"platforms\", version = \"1.0.0\")\nbazel_dep(name = \"rules_cc\", versi"
},
{
"path": "README.md",
"chars": 4740,
"preview": "<p align=\"center\">\n <picture>\n <source media=\"(prefers-color-scheme: dark)\" srcset=\"https://maplibre.org/img/maplibr"
},
{
"path": "SECURITY_POLICY.txt",
"chars": 101,
"preview": "For an up-to-date policy refer to\nhttps://github.com/maplibre/maplibre/blob/main/SECURITY_POLICY.txt\n"
},
{
"path": "biome.json",
"chars": 260,
"preview": "{\n \"$schema\": \"https://biomejs.dev/schemas/2.0.5/schema.json\",\n \"css\": {\n \"formatter\": {\n \"indentWidth\": 2,\n "
},
{
"path": "cpp/.clang-tidy",
"chars": 4367,
"preview": "---\nChecks: [\n android-*,\n boost-*,\n bugprone-*,\n clang-analyzer-core*,\n clang-analyzer-cplusplus*,\n c"
},
{
"path": "cpp/.gitignore",
"chars": 59,
"preview": "/build\n/.cache\ncompile_commands.json\ncmake_test_discovery*\n"
},
{
"path": "cpp/.nvmrc",
"chars": 6,
"preview": "24.13\n"
},
{
"path": "cpp/BUILD.bazel",
"chars": 847,
"preview": "load(\"@rules_cc//cc:cc_library.bzl\", \"cc_library\")\n\ncc_library(\n name = \"mlt_internal_headers\",\n hdrs = glob([\"src"
},
{
"path": "cpp/CMakeLists.txt",
"chars": 6592,
"preview": "cmake_minimum_required(VERSION 3.25)\nproject(mlt-cpp LANGUAGES CXX)\n\nlist(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_"
},
{
"path": "cpp/CTestCustom.cmake",
"chars": 192,
"preview": "# Exclude vendor/third-party code from coverage reports\nset(CTEST_CUSTOM_COVERAGE_EXCLUDE\n ${CTEST_CUSTOM_COVERAGE_EX"
},
{
"path": "cpp/README.md",
"chars": 1122,
"preview": "# maplibre-tile-spec/cpp\n\nA C++ implementation of the MapLibre Tile (MLT) vector tile format.\n\n## Status\n\nDecoder only, "
},
{
"path": "cpp/bazel/check/BUILD.bazel",
"chars": 874,
"preview": "load(\"@rules_cc//cc:cc_binary.bzl\", \"cc_binary\")\n\ncc_binary(\n name = \"sse42\",\n srcs = [\"sse42.c\"],\n copts = sel"
},
{
"path": "cpp/bazel/check/avx.c",
"chars": 113,
"preview": "#include<immintrin.h>\nint main(){\n__m128 x=_mm_set1_ps(0.5);\nx=_mm_permute_ps(x,1);\nreturn _mm_movemask_ps(x);\n}\n"
},
{
"path": "cpp/bazel/check/avx2.c",
"chars": 125,
"preview": "#include<immintrin.h>\nint main(){\n__m256i x=_mm256_set1_epi32(5);\nx=_mm256_add_epi32(x,x);\nreturn _mm256_movemask_epi8(x"
},
{
"path": "cpp/bazel/check/sse42.c",
"chars": 115,
"preview": "#include<smmintrin.h>\nint main(){\n__m128 x=_mm_set1_ps(0.5);\nx=_mm_dp_ps(x,x,0x77);\nreturn _mm_movemask_ps(x);\n}\")\n"
},
{
"path": "cpp/cmake/AddCXXCompilerFlag.cmake",
"chars": 2881,
"preview": "# - Adds a compiler flag if it is supported by the compiler\n#\n# This function checks that the supplied compiler flag is "
},
{
"path": "cpp/include/mlt/common.hpp",
"chars": 591,
"preview": "#pragma once\n\n#include <mlt/polyfill.hpp>\n\n#include <string_view>\n#include <type_traits>\n\nnamespace mlt {\n\nusing DataVie"
},
{
"path": "cpp/include/mlt/coordinate.hpp",
"chars": 544,
"preview": "#pragma once\n\n#include <cstdint>\n#include <vector>\n\nnamespace mlt {\n\nstruct Coordinate {\n float x;\n float y;\n\n "
},
{
"path": "cpp/include/mlt/decoder.hpp",
"chars": 700,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n#include <mlt/tile.hpp>\n#include <mlt/util/noncopyable.hpp>\n#include <mlt/geomet"
},
{
"path": "cpp/include/mlt/feature.hpp",
"chars": 1235,
"preview": "#pragma once\n\n#include <mlt/properties.hpp>\n#include <mlt/util/noncopyable.hpp>\n\n#include <memory>\n#include <optional>\n\n"
},
{
"path": "cpp/include/mlt/geometry.hpp",
"chars": 4081,
"preview": "#pragma once\n\n#include <mlt/coordinate.hpp>\n#include <mlt/metadata/tileset.hpp>\n#include <mlt/util/noncopyable.hpp>\n\n#in"
},
{
"path": "cpp/include/mlt/geometry_vector.hpp",
"chars": 10757,
"preview": "#pragma once\n\n#include <mlt/geometry.hpp>\n#include <mlt/util/morton_curve.hpp>\n\n#include <algorithm>\n#include <cassert>\n"
},
{
"path": "cpp/include/mlt/json.hpp",
"chars": 12569,
"preview": "#pragma once\n\n#include <sstream>\n#if MLT_WITH_JSON\n#include <mlt/common.hpp>\n#include <mlt/coordinate.hpp>\n#include <mlt"
},
{
"path": "cpp/include/mlt/layer.hpp",
"chars": 1200,
"preview": "#pragma once\n\n#include <mlt/feature.hpp>\n#include <mlt/properties.hpp>\n#include <mlt/util/noncopyable.hpp>\n\n#include <ve"
},
{
"path": "cpp/include/mlt/metadata/stream.hpp",
"chars": 9465,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n#include <mlt/util/buffer_stream.hpp>\n#include <mlt/util/noncopyable.hpp>\n#inclu"
},
{
"path": "cpp/include/mlt/metadata/tileset.hpp",
"chars": 4428,
"preview": "#pragma once\n\n#include <cstdint>\n#include <optional>\n#include <string>\n#include <variant>\n#include <vector>\n\nnamespace m"
},
{
"path": "cpp/include/mlt/metadata/type_map.hpp",
"chars": 7496,
"preview": "#include <cassert>\n#include <cstddef>\n#include <optional>\n\n#include <mlt/metadata/tileset.hpp>\n\nnamespace mlt::metadata:"
},
{
"path": "cpp/include/mlt/polyfill.hpp",
"chars": 746,
"preview": "#pragma once\n\n#include <algorithm>\n#include <bit>\n#include <ranges> // IWYU pragma: keep - Needed by MSVC\n#include <util"
},
{
"path": "cpp/include/mlt/projection.hpp",
"chars": 1478,
"preview": "#pragma once\n\n#include <mlt/coordinate.hpp>\n#include <mlt/layer.hpp>\n\n#include <cmath>\n#include <cstdint>\n#include <numb"
},
{
"path": "cpp/include/mlt/properties.hpp",
"chars": 4473,
"preview": "#pragma once\n\n#include <mlt/metadata/tileset.hpp>\n#include <mlt/util/packed_bitset.hpp>\n#include <mlt/util/noncopyable.h"
},
{
"path": "cpp/include/mlt/tile.hpp",
"chars": 794,
"preview": "#pragma once\n\n#include <mlt/layer.hpp>\n#include <mlt/util/noncopyable.hpp>\n\n#include <vector>\n\nnamespace mlt {\n\nclass Ma"
},
{
"path": "cpp/include/mlt/util/buffer_stream.hpp",
"chars": 2399,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n#include <mlt/util/noncopyable.hpp>\n\n#include <cstdint>\n#include <cstring>\n#incl"
},
{
"path": "cpp/include/mlt/util/noncopyable.hpp",
"chars": 394,
"preview": "#pragma once\n\nnamespace mlt::util {\n\nclass noncopyable {\npublic:\n noncopyable(noncopyable&) = delete;\n noncopyable"
},
{
"path": "cpp/include/mlt/util/packed_bitset.hpp",
"chars": 2264,
"preview": "#pragma once\n\n#include <bit>\n#include <cassert>\n#include <cstdint>\n#include <numeric>\n#include <optional>\n#include <vect"
},
{
"path": "cpp/include/mlt/util/stl.hpp",
"chars": 974,
"preview": "#pragma once\n\n#include <algorithm>\n#include <cstddef>\n#include <iterator>\n#include <vector>\n\nnamespace mlt::util {\n\n/// "
},
{
"path": "cpp/include/mlt/util/varint.hpp",
"chars": 3265,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n#include <mlt/util/buffer_stream.hpp>\n\n#include <stdexcept>\n#include <type_trait"
},
{
"path": "cpp/mod.just",
"chars": 1809,
"preview": "just := quote(just_executable())\n\n_default: (just '--list' 'cpp')\n\n[private]\njust *args:\n {{just}} {{args}}\n\n# Initia"
},
{
"path": "cpp/package.json",
"chars": 147,
"preview": "{\n \"type\": \"module\",\n \"dependencies\": {\n \"synthetic-test-utils\": \"file:../test/synthetic/synthetic-test-utils\",\n "
},
{
"path": "cpp/src/mlt/decode/geometry.hpp",
"chars": 21243,
"preview": "#pragma once\n\n#include <mlt/decode/int.hpp>\n#include <mlt/feature.hpp>\n#include <mlt/geometry.hpp>\n#include <mlt/geometr"
},
{
"path": "cpp/src/mlt/decode/int.cpp",
"chars": 3170,
"preview": "#include <algorithm>\n#include <mlt/decode/int.hpp>\n#include <mlt/decode/int_template.hpp>\n\n// from fastpfor/...\n#if MLT_"
},
{
"path": "cpp/src/mlt/decode/int.hpp",
"chars": 8051,
"preview": "#pragma once\n\n#include <mlt/metadata/stream.hpp>\n#include <mlt/util/buffer_stream.hpp>\n#include <mlt/util/noncopyable.hp"
},
{
"path": "cpp/src/mlt/decode/int_template.hpp",
"chars": 14343,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n#include <mlt/decode/int.hpp>\n#include <mlt/util/morton_curve.hpp>\n\n#include <ca"
},
{
"path": "cpp/src/mlt/decode/property.hpp",
"chars": 9467,
"preview": "#pragma once\n\n#include <algorithm>\n#include <iterator>\n#include <mlt/decode/int.hpp>\n#include <mlt/decode/string.hpp>\n#i"
},
{
"path": "cpp/src/mlt/decode/string.hpp",
"chars": 14557,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n#include <mlt/decode/int.hpp>\n#include <mlt/metadata/stream.hpp>\n#include <mlt/m"
},
{
"path": "cpp/src/mlt/decoder.cpp",
"chars": 6579,
"preview": "#include <mlt/decoder.hpp>\n\n#include <mlt/decode/geometry.hpp>\n#include <mlt/decode/int.hpp>\n#include <mlt/decode/int_te"
},
{
"path": "cpp/src/mlt/feature.cpp",
"chars": 655,
"preview": "#include <mlt/feature.hpp>\n\n#include <mlt/geometry.hpp>\n#include <mlt/layer.hpp>\n\nnamespace mlt {\n\nFeature::Feature(std:"
},
{
"path": "cpp/src/mlt/geometry_vector.cpp",
"chars": 30306,
"preview": "#include <mlt/geometry_vector.hpp>\n\n#include <mlt/coordinate.hpp>\n#include <mlt/polyfill.hpp>\n#include <mlt/util/morton_"
},
{
"path": "cpp/src/mlt/layer.cpp",
"chars": 543,
"preview": "#include <mlt/layer.hpp>\n#include <mlt/geometry_vector.hpp>\n\nnamespace mlt {\n\nLayer::Layer(std::string name_,\n "
},
{
"path": "cpp/src/mlt/metadata/stream.cpp",
"chars": 4175,
"preview": "#include <mlt/metadata/stream.hpp>\n\n#include <string>\n#include <utility>\n\nnamespace mlt::metadata::stream {\n\nnamespace {"
},
{
"path": "cpp/src/mlt/metadata/tileset.cpp",
"chars": 1874,
"preview": "#include <mlt/metadata/tileset.hpp>\n#include <mlt/metadata/type_map.hpp>\n#include <mlt/util/buffer_stream.hpp>\n#include "
},
{
"path": "cpp/src/mlt/properties.cpp",
"chars": 3720,
"preview": "#include <mlt/properties.hpp>\n\n#include <mlt/util/packed_bitset.hpp>\n#include <mlt/util/stl.hpp>\n\n#include <cassert>\n#in"
},
{
"path": "cpp/src/mlt/util/json_diff.hpp",
"chars": 6783,
"preview": "#pragma once\n#include <cstddef>\n#if MLT_WITH_JSON\n\n#include <mlt/json.hpp>\n\n#include <nlohmann/detail/string_concat.hpp>"
},
{
"path": "cpp/src/mlt/util/morton_curve.hpp",
"chars": 1858,
"preview": "#pragma once\n\n#include <mlt/util/space_filling_curve.hpp>\n\nnamespace mlt::util {\n\nclass MortonCurve : public SpaceFillin"
},
{
"path": "cpp/src/mlt/util/raw.hpp",
"chars": 1087,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n#include <mlt/metadata/stream.hpp>\n\n#include <algorithm>\n#include <cassert>\n\nnam"
},
{
"path": "cpp/src/mlt/util/rle.cpp",
"chars": 886,
"preview": "#include <mlt/util/rle.hpp>\n\n#include <mlt/metadata/stream.hpp>\n\n#include <cassert>\n\nnamespace mlt::util::decoding::rle "
},
{
"path": "cpp/src/mlt/util/rle.hpp",
"chars": 5307,
"preview": "#pragma once\n\n#include <mlt/util/buffer_stream.hpp>\n#include <mlt/util/noncopyable.hpp>\n\n#include <algorithm>\n#include <"
},
{
"path": "cpp/src/mlt/util/space_filling_curve.hpp",
"chars": 1577,
"preview": "#pragma once\n\n#include <mlt/coordinate.hpp>\n\n#include <cmath>\n#include <stdexcept>\n\nnamespace mlt::util {\n\nclass SpaceFi"
},
{
"path": "cpp/src/mlt/util/vectorized.hpp",
"chars": 1175,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n\n#include <cassert>\n#include <type_traits>\n\nnamespace mlt::util::decoding::vecto"
},
{
"path": "cpp/src/mlt/util/zigzag.hpp",
"chars": 513,
"preview": "#pragma once\n\n#include <mlt/common.hpp>\n\n#include <type_traits>\n\nnamespace mlt::util::decoding {\n\ntemplate <typename T>\n"
},
{
"path": "cpp/test/CMakeLists.txt",
"chars": 1322,
"preview": "set(TEST_SOURCES\n test_decode.cpp\n test_fsst.cpp\n test_packed_bitset.cpp\n test_util.cpp\n test_varint.cpp\n"
},
{
"path": "cpp/test/test_decode.cpp",
"chars": 6547,
"preview": "#include <gtest/gtest.h>\n\n#include <mlt/decoder.hpp>\n#include <mlt/geometry.hpp>\n#include <mlt/metadata/tileset.hpp>\n#in"
},
{
"path": "cpp/test/test_fastpfor.cpp",
"chars": 6497,
"preview": "#if !MLT_WITH_FASTPFOR\n#error This file should be excluded when FastPFor support is not enabled\n#endif\n\n#include <gtest/"
},
{
"path": "cpp/test/test_fsst.cpp",
"chars": 1395,
"preview": "#include <gtest/gtest.h>\n\n#include <mlt/decode/string.hpp>\n\n#include <string>\n#include <vector>\n\nTEST(FSST, DecodeFromJa"
},
{
"path": "cpp/test/test_packed_bitset.cpp",
"chars": 1651,
"preview": "#include <gtest/gtest.h>\n\n#include <mlt/util/packed_bitset.hpp>\n\nusing namespace mlt;\n\nTEST(PackedBitset, TestBit) {\n "
},
{
"path": "cpp/test/test_util.cpp",
"chars": 4179,
"preview": "#include <gtest/gtest.h>\n\n#include <mlt/util/vectorized.hpp>\n\nTEST(Util, ComponentwiseDeltaVec2) {\n // input, expecte"
},
{
"path": "cpp/test/test_varint.cpp",
"chars": 1513,
"preview": "#include <gtest/gtest.h>\n\n#include <mlt/util/buffer_stream.hpp>\n#include <mlt/util/varint.hpp>\n#include <mlt/util/vector"
},
{
"path": "cpp/tool/CMakeLists.txt",
"chars": 237,
"preview": "add_executable(mlt-cpp-json mlt-json.cpp synthetic-geojson.cpp)\nset_property(TARGET mlt-cpp-json PROPERTY CXX_STANDARD 2"
},
{
"path": "cpp/tool/mlt-json.cpp",
"chars": 2037,
"preview": "#include <mlt/decoder.hpp>\n#include <mlt/metadata/tileset.hpp>\n\n#include <cstring>\n#include <iostream>\n#include <fstream"
},
{
"path": "cpp/tool/synthetic-geojson.cpp",
"chars": 3876,
"preview": "#include \"synthetic-geojson.hpp\"\n\n#include <mlt/coordinate.hpp>\n#include <mlt/feature.hpp>\n#include <mlt/geometry.hpp>\n#"
},
{
"path": "cpp/tool/synthetic-geojson.hpp",
"chars": 451,
"preview": "#pragma once\n\n#include <mlt/tile.hpp>\n#include <nlohmann/json.hpp>\n\n/// Test utility: convert an MLT tile to a flat GeoJ"
},
{
"path": "cpp/tool/synthetic.test.ts",
"chars": 1205,
"preview": "import { execFileSync } from \"node:child_process\";\nimport { dirname, resolve } from \"node:path\";\nimport { fileURLToPath "
},
{
"path": "cpp/vendor/fastpfor.cmake",
"chars": 938,
"preview": "if(NOT MLT_WITH_FASTPFOR)\n message(STATUS \"[MLT] No FastPFOR support\")\n return()\nendif(NOT MLT_WITH_FASTPFOR)\n\nmessage"
},
{
"path": "docs/assets/extra.css",
"chars": 790,
"preview": "[data-md-color-scheme=\"default\"] {\n --md-primary-fg-color: #295daa;\n --md-accent-fg-color: #568ad6;\n}\n\n[data-md-color-"
},
{
"path": "docs/assets/spec/mlt_tileset_metadata.json",
"chars": 1252,
"preview": "{\n \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n \"type\": \"object\",\n \"properties\": {\n \"version\": {\n \""
},
{
"path": "docs/assets/spec/place_feature.json",
"chars": 469,
"preview": "{\n \"title\": \"Place Feature\",\n \"type\": \"object\",\n \"properties\": {\n \"id\": { \"type\": \"integer\" },\n \"geometry\": { \""
},
{
"path": "docs/encodings.md",
"chars": 6149,
"preview": "<h1>Encoding Definitions</h1>\n\n[TOC]\n\n---\n\n# Plain\n\nNo compression is applied to the data.\nDepending on the data type, v"
},
{
"path": "docs/implementation-status.md",
"chars": 1523,
"preview": "# Implementation Status\n\n## Integrations\n\n| Integration | Status |\n|---|---|\n| [MapLibre Native](https://maplibre.org/ma"
},
{
"path": "docs/index.md",
"chars": 1260,
"preview": "# Introduction\n\n--8<-- \"live-spec-note\"\n\nMLT is natively supported by [MapLibre GL JS](https://maplibre.org/maplibre-gl-"
},
{
"path": "docs/snippets/live-spec-note",
"chars": 240,
"preview": "!!! NOTE\n This is a live specification that evolves continuously. Features marked as <span class=\"experimental\"></spa"
},
{
"path": "docs/specification.md",
"chars": 25165,
"preview": "<h1>MapLibre Tile Specification</h1>\n\n--8<-- \"live-spec-note\"\n\n[TOC]\n\n---\n\n# Basics\n\nAn MLT (MapLibre Tile) contains inf"
},
{
"path": "java/.gitignore",
"chars": 52,
"preview": ".gradle/\nbuild/\noutput/\n*.mlt.mbtiles\n*.mlt.pmtiles\n"
},
{
"path": "java/CONTRIBUTING.md",
"chars": 625,
"preview": "To build the project run the following command:\n````bash\n./gradlew build\n````\n\nTo format the code run the following comm"
},
{
"path": "java/README-Decode.md",
"chars": 268,
"preview": "## MLT Decoder Java CLI Application\n\nThis is a very simple application which serves as an example of how to use the MLT "
},
{
"path": "java/README-Encode.md",
"chars": 4952,
"preview": "## MLT Encoder Java CLI Application\n\nThis application currently only supports converting MVT tiles to MLT format.\n\nIt ca"
},
{
"path": "java/README.MD",
"chars": 7654,
"preview": "# MapLibre Tile Java\n\n[](https://centra"
},
{
"path": "java/encoding-server/.gitignore",
"chars": 21,
"preview": "cache/\nnode_modules/\n"
},
{
"path": "java/encoding-server/README.md",
"chars": 1357,
"preview": "# MVT to MLT Development Server\n\nThis Node.js-based application serves as a **development and testing server** for conve"
},
{
"path": "java/encoding-server/config.json",
"chars": 261,
"preview": "{\n \"host\": \"0.0.0.0\",\n \"port\": 80,\n \"verbose\": true,\n\n \"input\": \"mvt\",\n \"noids\": false,\n \"fsst\": false,\n \"fastpfo"
},
{
"path": "java/encoding-server/config.mjs",
"chars": 1668,
"preview": "import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { parseArgs } f"
},
{
"path": "java/encoding-server/convert.mjs",
"chars": 7973,
"preview": "import { exec, execSync, spawn } from \"node:child_process\";\nimport { randomUUID } from \"node:crypto\";\nimport { createWri"
},
{
"path": "java/encoding-server/eslint.config.mjs",
"chars": 400,
"preview": "import eslint from \"@eslint/js\";\nimport nPlugin from \"eslint-plugin-n\";\nimport globals from \"globals\";\n\nexport default ["
},
{
"path": "java/encoding-server/package.json",
"chars": 446,
"preview": "{\n \"name\": \"encoding-server\",\n \"version\": \"1.0.0\",\n \"main\": \"server.mjs\",\n \"scripts\": {\n \"start\": \"node server.mj"
},
{
"path": "java/encoding-server/server.mjs",
"chars": 496,
"preview": "import cors from \"cors\";\nimport express from \"express\";\n\nimport config from \"./config.mjs\";\nimport {\n convertSourceRequ"
},
{
"path": "java/gradle/libs.versions.toml",
"chars": 3456,
"preview": "[versions]\ntileverse = \"1.3.3\"\njmh = \"1.37\"\njunit-jupiter = \"6.0.3\"\nkotlin-jvm = \"2.3.10\"\nlombok = \"1.18.38\"\n\n[libraries"
},
{
"path": "java/gradle/wrapper/gradle-wrapper.properties",
"chars": 252,
"preview": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributi"
},
{
"path": "java/gradlew",
"chars": 8595,
"preview": "#!/bin/sh\n\n#\n# Copyright © 2015 the original authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
},
{
"path": "java/gradlew.bat",
"chars": 2896,
"preview": "@rem\r\n@rem Copyright 2015 the original author or authors.\r\n@rem\r\n@rem Licensed under the Apache License, Version 2.0 (th"
},
{
"path": "java/lombok.config",
"chars": 246,
"preview": "# Add generated annotations to generated code\nlombok.addLombokGeneratedAnnotation = true\n# Add nullability annotations t"
},
{
"path": "java/mlt-cli/build.gradle",
"chars": 5466,
"preview": "plugins {\n id 'java-library'\n id 'jacoco'\n alias(libs.plugins.kotlin.jvm)\n alias(libs.plugins.diffplug.spotl"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Conversion.kt",
"chars": 15265,
"preview": "package org.maplibre.mlt.cli\n\nimport com.onthegomap.planetiler.geo.TileCoord\nimport org.apache.commons.compress.compress"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Decode.kt",
"chars": 3796,
"preview": "package org.maplibre.mlt.cli\n\nimport org.apache.commons.cli.CommandLine\nimport org.apache.commons.cli.DefaultParser\nimpo"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Encode.kt",
"chars": 15809,
"preview": "package org.maplibre.mlt.cli\n\nimport org.apache.commons.cli.CommandLine\nimport org.apache.commons.io.FilenameUtils\nimpor"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/EncodeCommandLine.kt",
"chars": 34564,
"preview": "package org.maplibre.mlt.cli\n\nimport org.apache.commons.cli.CommandLine\nimport org.apache.commons.cli.Converter\nimport o"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/EncodeConfig.kt",
"chars": 1149,
"preview": "package org.maplibre.mlt.cli\n\nimport org.maplibre.mlt.compare.CompareHelper.CompareMode\nimport org.maplibre.mlt.converte"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Environment.kt",
"chars": 4849,
"preview": "package org.maplibre.mlt.cli\n\nimport kotlin.time.Duration\nimport kotlin.time.Duration.Companion.seconds\n\nconst val ENV_C"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Json.kt",
"chars": 326,
"preview": "package org.maplibre.mlt.cli\n\nimport org.maplibre.mlt.data.MapLibreTile\nimport org.maplibre.mlt.data.MapboxVectorTile\nim"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Logging.kt",
"chars": 1473,
"preview": "package org.maplibre.mlt.cli\n\nimport org.slf4j.LoggerFactory\nimport org.slf4j.MarkerFactory\nimport java.text.DecimalForm"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/MBTiles.kt",
"chars": 9912,
"preview": "package org.maplibre.mlt.cli\n\nimport org.apache.commons.lang3.mutable.MutableBoolean\nimport org.imintel.mbtiles4j.MBTile"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/OfflineDB.kt",
"chars": 9738,
"preview": "package org.maplibre.mlt.cli\n\nimport com.google.gson.Gson\nimport com.google.gson.JsonObject\nimport com.google.gson.JsonS"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/PMTiles.kt",
"chars": 19654,
"preview": "package org.maplibre.mlt.cli\n\nimport com.github.benmanes.caffeine.cache.RemovalCause\nimport com.github.benmanes.caffeine"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/ReadablePmtiles.kt",
"chars": 11420,
"preview": "package org.maplibre.mlt.cli\n\nimport com.onthegomap.planetiler.archive.TileArchiveMetadata\nimport com.onthegomap.planeti"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/SerialTaskRunner.kt",
"chars": 307,
"preview": "package org.maplibre.mlt.cli\n\nclass SerialTaskRunner : TaskRunner {\n override val threadCount: Int\n get() = 0\n"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Server.kt",
"chars": 1883,
"preview": "package org.maplibre.mlt.cli\n\nimport org.slf4j.Logger\nimport org.slf4j.LoggerFactory\nimport java.io.BufferedReader\nimpor"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/TaskRunner.kt",
"chars": 1762,
"preview": "package org.maplibre.mlt.cli\n\nimport java.util.concurrent.LinkedBlockingQueue\nimport java.util.concurrent.ThreadPoolExec"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/ThreadPoolTaskRunner.kt",
"chars": 595,
"preview": "package org.maplibre.mlt.cli\n\nimport java.util.concurrent.ThreadPoolExecutor\nimport java.util.concurrent.TimeUnit\n\nclass"
},
{
"path": "java/mlt-cli/src/main/kotlin/org/maplibre/mlt/cli/Timer.kt",
"chars": 537,
"preview": "package org.maplibre.mlt.cli\n\nimport org.slf4j.LoggerFactory\n\nclass Timer {\n private var startTime: Long\n\n init {\n"
},
{
"path": "java/mlt-cli/src/main/resources/log4j2.json",
"chars": 1288,
"preview": "{\n \"Configuration\": {\n \"status\": \"warn\",\n \"Appenders\": {\n \"Console\": {\n \"name\": \"Console\",\n \""
},
{
"path": "java/mlt-cli/src/test/kotlin/org/maplibre/mlt/cli/EncodeCommandLineTest.kt",
"chars": 6856,
"preview": "package org.maplibre.mlt.cli\n\nimport org.apache.commons.cli.DefaultParser\nimport org.apache.commons.cli.Option\nimport or"
},
{
"path": "java/mlt-cli/src/test/kotlin/org/maplibre/mlt/cli/EnvironmentResolverTest.kt",
"chars": 8049,
"preview": "package org.maplibre.mlt.cli\n\nimport org.apache.logging.log4j.Level\nimport org.apache.logging.log4j.core.config.Configur"
},
{
"path": "java/mlt-cli/src/test/kotlin/org/maplibre/mlt/cli/LoggingTest.kt",
"chars": 1203,
"preview": "package org.maplibre.mlt.cli\n\nimport org.junit.jupiter.api.Assertions.assertEquals\nimport org.junit.jupiter.api.Test\n\ncl"
},
{
"path": "java/mlt-cli/src/test/kotlin/org/maplibre/mlt/cli/ReadablePmtilesMapDirectoryTest.kt",
"chars": 4442,
"preview": "package org.maplibre.mlt.cli\n\nimport com.onthegomap.planetiler.pmtiles.Pmtiles\nimport org.junit.jupiter.api.Assertions.a"
},
{
"path": "java/mlt-cli/src/test/kotlin/org/maplibre/mlt/cli/TaskRunnerTest.kt",
"chars": 3385,
"preview": "package org.maplibre.mlt.cli\n\nimport org.junit.jupiter.api.Assertions.assertEquals\nimport org.junit.jupiter.api.Assertio"
},
{
"path": "java/mlt-cli/src/test/kotlin/org/maplibre/mlt/cli/TestUtil.kt",
"chars": 251,
"preview": "package org.maplibre.mlt.cli\n\nimport org.junit.jupiter.api.Assertions.assertTrue\n\nfun Exception.andContains(str: String)"
},
{
"path": "java/mlt-cli/src/test/kotlin/org/maplibre/mlt/cli/TileCoordRangeTest.kt",
"chars": 925,
"preview": "package org.maplibre.mlt.cli\n\nimport org.junit.jupiter.api.Assertions.assertEquals\nimport org.junit.jupiter.api.Assertio"
},
{
"path": "java/mlt-core/build.gradle",
"chars": 4987,
"preview": "plugins {\n alias(libs.plugins.diffplug.spotless)\n alias(libs.plugins.maven.publish)\n alias(libs.plugins.me.cham"
},
{
"path": "java/mlt-core/src/jmh/java/org/maplibre/mlt/BenchmarkUtils.java",
"chars": 2946,
"preview": "package org.maplibre.mlt;\n\nimport java.io.ByteArrayInputStream;\nimport java.io.IOException;\nimport java.nio.file.Files;\n"
},
{
"path": "java/mlt-core/src/jmh/java/org/maplibre/mlt/OmtDecoderBenchmark.java",
"chars": 8328,
"preview": "package org.maplibre.mlt;\n\nimport java.io.ByteArrayInputStream;\nimport java.io.IOException;\nimport java.util.HashMap;\nim"
},
{
"path": "java/mlt-core/src/jmh/java/org/maplibre/mlt/converter/encodings/fsst/FsstBenchmark.java",
"chars": 34478,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\nimport java.util.Base64;\nimport java.util.concurrent.TimeUnit;\nimpor"
},
{
"path": "java/mlt-core/src/jmh/java/org/maplibre/mlt/data/rle_PartOffsets.csv",
"chars": 66305,
"preview": "2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;"
},
{
"path": "java/mlt-core/src/jmh/java/org/maplibre/mlt/data/rle_class_ratio17.csv",
"chars": 41064,
"preview": "0;0;0;0;0;0;0;0;0;1;-1;0;1;-1;2;0;0;0;1;0;1;0;0;-4;0;0;0;0;0;1;0;2;-3;0;1;-1;1;-1;1;0;0;0;0;-1;1;0;0;-1;1;-1;2;0;0;0;0;0"
},
{
"path": "java/mlt-core/src/jmh/java/org/maplibre/mlt/data/rle_id_ratio22_45k.csv",
"chars": 90468,
"preview": "2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;2;"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/compare/CompareHelper.java",
"chars": 13474,
"preview": "package org.maplibre.mlt.compare;\n\nimport jakarta.annotation.Nullable;\nimport java.util.Comparator;\nimport java.util.Has"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/CollectionUtils.java",
"chars": 592,
"preview": "package org.maplibre.mlt.converter;\n\nimport java.util.Collection;\n\npublic class CollectionUtils {\n private CollectionUt"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/ColumnMapping.java",
"chars": 4069,
"preview": "package org.maplibre.mlt.converter;\n\nimport jakarta.annotation.Nullable;\nimport java.util.Collection;\nimport java.util.C"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/ColumnMappingConfig.java",
"chars": 1118,
"preview": "package org.maplibre.mlt.converter;\n\nimport java.util.LinkedHashMap;\nimport java.util.List;\nimport java.util.regex.Patte"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/ConversionConfig.java",
"chars": 2905,
"preview": "package org.maplibre.mlt.converter;\n\nimport jakarta.annotation.Nullable;\nimport java.util.List;\nimport java.util.Map;\nim"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/FeatureTableOptimizations.java",
"chars": 764,
"preview": "package org.maplibre.mlt.converter;\n\nimport java.util.List;\n\n/**\n * Configure optimizations for a Layer\n *\n * @param all"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/MltConverter.java",
"chars": 33173,
"preview": "package org.maplibre.mlt.converter;\n\nimport com.google.gson.Gson;\nimport jakarta.annotation.Nullable;\nimport java.io.Byt"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/MortonSettings.java",
"chars": 264,
"preview": "package org.maplibre.mlt.converter;\n\npublic final class MortonSettings {\n public int numBits;\n public int coordinateSh"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/BooleanEncoder.java",
"chars": 1400,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util."
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/ByteRleEncoder.java",
"chars": 2747,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport java.io.ByteArrayOutputStream;\nimport java.io.IOException;\n\n/**\n *"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/DoubleEncoder.java",
"chars": 1212,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util."
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/EncodingUtils.java",
"chars": 11169,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport java.io.ByteArrayInputStream;\nimport java.io.ByteArrayOutputStream"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/FloatEncoder.java",
"chars": 1226,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util."
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/GeometryEncoder.java",
"chars": 26773,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport static org.maplibre.mlt.converter.encodings.IntegerEncoder.encodeF"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/IntegerEncoder.java",
"chars": 22955,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport com.google.common.collect.Lists;\nimport com.google.common.primitiv"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/LinearRegression.java",
"chars": 2648,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport java.util.Arrays;\n\n// Source: https://github.com/yhliu918/Learn-to"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/MltTypeMap.java",
"chars": 6707,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport jakarta.annotation.Nullable;\nimport java.util.List;\nimport java.ut"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/PropertyEncoder.java",
"chars": 23685,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport jakarta.annotation.Nullable;\nimport java.io.IOException;\nimport ja"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/StringEncoder.java",
"chars": 14668,
"preview": "package org.maplibre.mlt.converter.encodings;\n\nimport java.io.ByteArrayOutputStream;\nimport java.io.IOException;\nimport "
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/Fsst.java",
"chars": 2699,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\nimport java.io.ByteArrayOutputStream;\n\npublic interface Fsst {\n\n Sy"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstDebug.java",
"chars": 2160,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\nimport java.util.concurrent.atomic.AtomicBoolean;\nimport java.util.c"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstEncoder.java",
"chars": 1147,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\npublic class FsstEncoder {\n public static Fsst INSTANCE;\n\n public "
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstJava.java",
"chars": 191,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\nclass FsstJava implements Fsst {\n\n @Override\n public SymbolTable e"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/FsstJni.java",
"chars": 1075,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\nimport java.nio.file.FileSystems;\n\npublic class FsstJni implements F"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/Symbol.java",
"chars": 2902,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\nimport java.nio.ByteBuffer;\nimport java.nio.charset.StandardCharsets"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/SymbolTable.java",
"chars": 1674,
"preview": "package org.maplibre.mlt.converter.encodings.fsst;\n\nimport java.util.Arrays;\n\n/**\n * Output of FSST-encoding: a symbol t"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/encodings/fsst/SymbolTableBuilder.java",
"chars": 12361,
"preview": "/*\nMIT License\n\nCopyright (c) 2018-2020, CWI, TU Munich, FSU Jena\n\nPermission is hereby granted, free of charge, to any "
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/GeometryType.java",
"chars": 157,
"preview": "package org.maplibre.mlt.converter.geometry;\n\npublic enum GeometryType {\n POINT,\n LINESTRING,\n POLYGON,\n MULTIPOINT,"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/GeometryUtils.java",
"chars": 3369,
"preview": "package org.maplibre.mlt.converter.geometry;\n\nimport com.google.common.collect.Lists;\nimport java.util.ArrayList;\nimport"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/Hilbert.java",
"chars": 3036,
"preview": "package org.maplibre.mlt.converter.geometry;\n\n/**\n * Fast hilbert curve calculations from <a\n * href=\"https://github.com"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/HilbertCurve.java",
"chars": 530,
"preview": "package org.maplibre.mlt.converter.geometry;\n\npublic class HilbertCurve extends SpaceFillingCurve {\n\n public HilbertCur"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/SpaceFillingCurve.java",
"chars": 2278,
"preview": "package org.maplibre.mlt.converter.geometry;\n\npublic abstract class SpaceFillingCurve {\n protected int tileExtent;\n pr"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/Vertex.java",
"chars": 84,
"preview": "package org.maplibre.mlt.converter.geometry;\n\npublic record Vertex(int x, int y) {}\n"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/geometry/ZOrderCurve.java",
"chars": 1414,
"preview": "package org.maplibre.mlt.converter.geometry;\n\npublic class ZOrderCurve extends SpaceFillingCurve {\n\n public ZOrderCurve"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/mvt/MvtUtils.java",
"chars": 3224,
"preview": "package org.maplibre.mlt.converter.mvt;\n\nimport java.io.IOException;\nimport java.nio.file.Files;\nimport java.nio.file.Pa"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/tessellation/TessellatedPolygon.java",
"chars": 172,
"preview": "package org.maplibre.mlt.converter.tessellation;\n\nimport java.util.List;\n\npublic record TessellatedPolygon(List<Integer>"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/converter/tessellation/TessellationUtils.java",
"chars": 5096,
"preview": "package org.maplibre.mlt.converter.tessellation;\n\nimport com.google.gson.Gson;\nimport com.google.gson.JsonObject;\nimport"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/data/Feature.java",
"chars": 2366,
"preview": "package org.maplibre.mlt.data;\n\nimport jakarta.annotation.Nullable;\nimport java.util.Optional;\nimport java.util.function"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/data/FeatureInterface.java",
"chars": 1052,
"preview": "package org.maplibre.mlt.data;\n\nimport jakarta.annotation.Nullable;\nimport java.util.Optional;\nimport java.util.function"
},
{
"path": "java/mlt-core/src/main/java/org/maplibre/mlt/data/IndexedProperty.java",
"chars": 864,
"preview": "package org.maplibre.mlt.data;\n\nimport java.util.ArrayList;\nimport java.util.SequencedCollection;\nimport org.maplibre.ml"
}
]
// ... and 1594 more files (download for full content)
About this extraction
This page contains the full source code of the maplibre/maplibre-tile-spec GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1794 files (71.3 MB), approximately 1.6M tokens, and a symbol index with 3643 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.