Struct ArchiveWriter 

pub struct ArchiveWriter { /* private fields */ }

Writer for creating an STT archive.

Two modes:

• create — eager: each tile is compressed and written as it arrives, so peak memory is bounded (good for streaming huge builds).
• create_optimized — buffered: tiles are held until finalize, where a shared zstd dictionary is trained, byte-identical blobs are deduplicated, and blobs are written in Hilbert order. Smaller archives at the cost of holding payloads in memory.

Implementations

impl ArchiveWriter

pub fn create<P: AsRef<Path>>(path: P, compression: Compression) -> Result<Self>

Create an archive in eager (streaming) mode. Tile blobs use compression.

pub fn create_optimized<P: AsRef<Path>>(path: P) -> Result<Self>

Create an archive in buffered “optimized” mode: a shared zstd dictionary is trained over the tile corpus, byte-identical blobs are deduplicated, and blobs are laid down in 2D-spatial-Hilbert order for range-read locality. Requires zstd. See create_optimized_with_ordering to pick a different (e.g. space-time) blob order.

pub fn create_optimized_with_ordering<P: AsRef<Path>>( path: P, ordering: BlobOrdering, ) -> Result<Self>

Buffered “optimized” mode with an explicit blob byte-ordering. The directory index stays (zoom, hilbert, time_start) regardless; only the physical blob layout changes, so readers are unaffected. The default (BlobOrdering::Hilbert3) minimises range requests across the widest range of datasets (see examples/simulate_layout.rs).

pub fn create_reordered<P: AsRef<Path>>( path: P, ordering: BlobOrdering, ) -> Result<Self>

Buffered mode that reorders blobs but ships NO shared dictionary, so the result stays decodable by readers without a dictionary-capable zstd (today’s TS reader). Per-blob zstd + byte-identical dedup still apply. This is the reader-safe way to get the range-request win from blob ordering without the dict that the TS reader can’t yet decode.

pub fn add_tile( &mut self, id: &TileId, time_start: i64, time_end: i64, feature_count: u32, payload: &[u8], ) -> Result<()>

Add a tile. payload is the uncompressed tile payload (the layer frame produced by crate::arrow_tile::encode_tile).

pub fn add_tile_with_bucket( &mut self, id: &TileId, time_start: i64, time_end: i64, feature_count: u32, temporal_bucket_ms: Option<u64>, payload: &[u8], ) -> Result<()>

Add a tile, tagging the directory entry with the temporal bucket size it represents (used when emitting temporal-LOD aggregate tiles).

pub fn add_tile_full( &mut self, id: &TileId, time_start: i64, time_end: i64, cover_t_min: Option<i64>, feature_count: u32, temporal_bucket_ms: Option<u64>, payload: &[u8], ) -> Result<()>

Add a tile carrying the full directory metadata, including the tight lower covering bound cover_t_min (the earliest feature start time actually present — see TileEntry::cover_t_min). None leaves the entry without a covering bound (clients fall back to time_start).

pub fn tile_count(&self) -> usize

Number of tiles staged so far (buffered or written).

pub fn finalize(self, metadata: &Metadata) -> Result<()>

Finalise: write the dictionary (if any), directory, metadata, and header.