versatiles_container 3.7.0

A toolbox for converting, checking and serving map tiles in various formats.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! `VersaTiles` Container: read, convert, and write tile containers.
//!
//! This crate exposes a small set of building blocks to work with map tile containers:
//! - a registry that maps file extensions to readers/writers,
//! - reader traits and adapters to stream tiles,
//! - writer traits to serialize tiles,
//! - utilities like caching and streaming combinators.
//!
//! It is designed for **runtime composition**: readers are object‑safe and can be wrapped
//! by adapters (e.g. bbox filters, axis flips, compression overrides) and then written
//! out with the appropriate writer inferred from the output path.
//!
//! # Quick start
//! ```rust
//! use versatiles_container::*;
//! use versatiles_core::*;
//! use std::sync::Arc;
//!
//! #[tokio::main]
//! async fn main() -> anyhow::Result<()> {
//!     // Open a source container via the registry
//!     let runtime = TilesRuntime::default();
//!     let reader = runtime.get_reader_from_str("../testdata/berlin.mbtiles").await?;
//!
//!     // Optionally adapt the reader: limit to a bbox pyramid, keep compression as-is
//!     let params = TilesConverterParameters {
//!         bbox_pyramid: Some(TileBBoxPyramid::new_full_up_to(8)),
//!         ..Default::default()
//!     };
//!     let reader = Arc::new(Box::new(TilesConvertReader::new_from_reader(reader, params)?) as Box<dyn TileSource>);
//!
//!     // Write to a target path; format is inferred from the extension
//!     let output = std::env::temp_dir().join("example.versatiles");
//!     runtime.write_to_path(reader, &output).await?;
//!     Ok(())
//! }
//! ```
//!
//! # Features
//! - `cli`: enables human‑readable probing of containers and tiles.
//! - `test`: helpers for integration tests in downstream crates.
//!
//! ## See also
//! - [`ContainerRegistry`]: register custom reader/writer implementations at runtime
//! - [`TileSource`], [`TilesWriter`]: object‑safe traits for IO
//! - [`TilesConvertReader`], [`convert_tiles_container`]: convenience conversion helpers

pub mod cache;
/// Re‑exports in‑memory caches and helpers used by readers/writers.
pub use cache::*;

mod container;
/// Re‑exports the container registry and common open/write helpers.
pub use container::*;

pub mod progress;
pub use progress::*;

/// Re‑exports progress tracking and event bus types.
pub mod runtime;
pub use runtime::*;

mod traversal;
pub use traversal::*;

mod types;
/// Re‑exports reader/writer traits, converters, and auxiliary types.
pub use types::*;

#[cfg(test)]
pub(crate) mod testing;