Struct AntWriter 

pub struct AntWriter<W: Write> { /* private fields */ }

Streaming .ant writer: records in, zstd-framed NDJSON out. Call AntWriter::finish to emit the trailer and flush.

Example

Write a small file — manifest first (via AntWriter::new), then records, then AntWriter::finish to append the trailer with the per-kind counts and the integrity hash:

use ant_types::{Evidence, ProjectId, TenantId, TypeName, Vertex, VertexId};
use antares_format::{AntRecord, AntWriter, Manifest, FORMAT_VERSION};
use std::collections::BTreeMap;

let manifest = Manifest {
    format: "antares".into(),
    version: FORMAT_VERSION.into(),
    tenant_id: 1,
    project_id: 1,
    selection: None,
    created_at: None,
    producer: Some("doctest/0.1".into()),
};

// Any `std::io::Write` works; a Vec keeps the example in memory.
let mut writer = AntWriter::new(Vec::new(), manifest, 0)?;
writer.write(AntRecord::Vertex {
    data: Vertex {
        id: VertexId("deal_1".into()),
        name: "Example Deal".into(),
        label: TypeName("Demo.Deal".into()),
        properties: BTreeMap::new(),
    },
})?;
writer.write(AntRecord::Evidence {
    data: Evidence::quick(
        "ev1", TenantId(1), ProjectId(1),
        "note", "n1", "example content",
    ),
})?;

let bytes = writer.finish()?; // appends the trailer, flushes zstd
assert!(!bytes.is_empty());

Implementations

impl<W: Write> AntWriter<W>

pub fn new(out: W, manifest: Manifest, level: i32) -> Result<Self, AntError>

Compression level 0 = zstd default (currently 3). Levels up to 19 trade speed for size; text-heavy evidence compresses 5-10x at the default already.

pub fn write(&mut self, rec: AntRecord) -> Result<(), AntError>

Append one record. The manifest is written by AntWriter::new and the trailer by AntWriter::finish; passing either here is an error.

pub fn counts(&self) -> &Counts

Records written so far (excluding manifest/trailer).

pub fn finish(self) -> Result<W, AntError>

Emit the trailer (counts + sha256 of everything before it) and finish the zstd frame. Returns the inner writer.