Struct Layer01 

pub struct Layer01<'a> {
    pub name: &'a str,
    pub extent: u32,
    pub id: Option<Id<'a>>,
    pub geometry: Geometry<'a>,
    pub properties: Vec<Property<'a>>,
}

Representation of a feature table layer encoded as MLT tag 0x01

Fields

name: &'a str

extent: u32

id: Option<Id<'a>>

geometry: Geometry<'a>

properties: Vec<Property<'a>>

Implementations

impl Layer01<'_>

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

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

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

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(&mut self, dec: &mut Decoder) -> MltResult<()>

impl Layer01<'_>

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

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

Callers do not need to pre-call decode_all on the source layer.

Trait Implementations

impl Analyze for Layer01<'_>

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> Debug for Layer01<'a>

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

Formats the value using the given formatter.

impl PartialEq<Layer01<'_>> for StagedLayer01

fn eq(&self, other: &Layer01<'_>) -> 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.

impl PartialEq<StagedLayer01> for Layer01<'_>

fn eq(&self, other: &StagedLayer01) -> 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.

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

fn eq(&self, other: &Layer01<'a>) -> 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.

impl<'a> StructuralPartialEq for Layer01<'a>