Struct Layer01 

pub struct Layer01<'a, S: DecodeState = Lazy> {
    pub name: &'a str,
    pub extent: u32,
    pub id: Option<Id<'a, S>>,
    pub geometry: Geometry<'a, S>,
    /* private fields */
}

Representation of an MLT feature table layer with tag 0x01 during decoding.

The type parameter S controls how columns are stored:

• Layer01<'a> / Layer01<'a, Lazy> (default) — columns are LazyParsed enums that may be raw or decoded. Use decode_id, decode_geometry, decode_properties for selective in-place decoding, or Layer01::decode_all to transition to Layer01<Parsed>.

• Layer01<'a, Parsed> — all columns are fully decoded. The fields id, geometry, and properties hold the parsed types directly, allowing infallible readonly access. There is a ParsedLayer01<'a> type alias for this.

Fields

name: &'a str

extent: u32

id: Option<Id<'a, S>>

geometry: Geometry<'a, S>

Implementations

impl<'a> Layer01<'a, Lazy>

pub fn iterate_prop_names(&self) -> Layer01PropNamesIter<'_, 'a>

Iterate over the property column names of this layer, in order.

Regular columns yield one PropName; SharedDict columns yield one name per sub-item. Names are available even before any column data has been decoded.

Pair with FeatureRef::iter_all_properties to associate per-feature values with their column names.

impl<'a> Layer01<'a, Parsed>

pub fn iter_features(&self) -> Layer01FeatureIter<'_, 'a>

Iterate over all features in this fully-decoded layer.

Returns a Layer01FeatureIter that yields one FeatureRef per feature. Construction is infallible; individual next() calls return MltResult<FeatureRef> because geometry decoding can fail.

pub fn iterate_prop_names(&self) -> Layer01PropNamesIter<'_, 'a>

Iterate over the property column names of this layer, in order. See Layer01::iterate_prop_names for details.

impl<'a> Layer01<'a, Lazy>

pub fn from_bytes(input: &'a [u8], parser: &mut Parser) -> MltResult<Self>

Parse v01::Layer metadata, reserving decoded memory against the parser’s budget.

pub fn decode_id( &mut self, dec: &mut Decoder, ) -> MltResult<Option<&mut IdValues>>

Decode only the ID column, leaving other columns in their encoded form.

Use this instead of Self::decode_all when other columns will be accessed lazily.

pub fn decode_geometry( &mut self, dec: &mut Decoder, ) -> MltResult<&mut GeometryValues>

Decode only the geometry column, leaving other columns in their encoded form.

Use this instead of Self::decode_all when other columns will be accessed lazily.

pub fn decode_properties(&mut self, dec: &mut Decoder) -> MltResult<()>

Decode only the property columns, leaving other columns in their encoded form.

Use this instead of Self::decode_all when other columns will be accessed lazily.

pub fn decode_all(self, dec: &mut Decoder) -> MltResult<ParsedLayer01<'a>>

Decode all columns and transition to Layer01<Parsed>.

Consumes self (a Layer01<Lazy>) and returns a Layer01<Parsed> where every column field holds its parsed value directly, enabling infallible readonly access.

impl Layer01<'_, Parsed>

pub fn into_tile(self, dec: &mut Decoder) -> MltResult<TileLayer01>

Decode and convert into a row-oriented TileLayer01, charging every heap allocation against dec.

pub fn feature_count(&self) -> usize

impl Layer01<'_>

pub fn into_tile(self, dec: &mut Decoder) -> MltResult<TileLayer01>

Decode and convert into a row-oriented TileLayer01

Trait Implementations

impl<'a, S: DecodeState> Analyze for Layer01<'a, S>

where Option<Id<'a, S>>: Analyze, Geometry<'a, S>: Analyze, Vec<Property<'a, S>>: Analyze,

fn collect_statistic(&self, stat: StatType) -> usize

fn for_each_stream(&self, cb: &mut dyn FnMut(StreamMeta))

Call cb with the StreamMeta of every stream contained in self. Default implementation is a no-op (types that hold no streams).

impl<'a, S> Clone for Layer01<'a, S>

where S: DecodeState, Option<Id<'a, S>>: Clone, Geometry<'a, S>: Clone, Vec<Property<'a, S>>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, S> Debug for Layer01<'a, S>

where S: DecodeState, Option<Id<'a, S>>: Debug, Geometry<'a, S>: Debug, Vec<Property<'a, S>>: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, S> PartialEq for Layer01<'a, S>

where S: DecodeState, Option<Id<'a, S>>: PartialEq, Geometry<'a, S>: PartialEq, Vec<Property<'a, S>>: PartialEq,

TODO: not certain this is needed

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.