Enum las::Error

#[non_exhaustive]
pub enum Error {
    ClosedWriter,
    HeaderTooLarge(usize),
    InvalidClassification(u8),
    InvalidFileSignature([u8; 4]),
    InvalidInverseTransform {
        n: f64,
        transform: Transform,
    },
    InvalidPointFormat(Format),
    InvalidPointFormatNumber(u8),
    InvalidScannerChannel(u8),
    Io(Error),
    LaszipNotEnabled,
    LasZipError(LasZipError),
    LasZipVlrNotFound,
    NotAscii(String),
    NotZeroFilled(Vec<u8>),
    OffsetToEvlrsTooSmall(u64),
    OffsetToPointDataTooLarge(usize),
    OffsetToPointDataTooSmall(u32),
    OverlapClassification,
    PointAttributesDoNotMatch(Format),
    PointDataRecordLengthTooLarge {
        format: Format,
        len: u16,
    },
    PointPaddingNotAllowed,
    ReturnNumber {
        return_number: u8,
        version: Option<Version>,
    },
    StringTooLong {
        string: String,
        len: usize,
    },
    TooManyEvlrs(usize),
    TooManyPoints {
        n: u64,
        version: Version,
    },
    TooManyVlrs(usize),
    TryFromIntError(TryFromIntError),
    UnsupportedFeature {
        version: Version,
        feature: &'static str,
    },
    UnsupportedFormat {
        version: Version,
        format: Format,
    },
    Utf8(Utf8Error),
    WktRequired(Format),
    VlrTooLong(usize),
}

Crate-specific error enum.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ClosedWriter

The writer is closed.

HeaderTooLarge(usize)

The header size, as computed, is too large.

InvalidClassification(u8)

An invalid classification number.

InvalidFileSignature([u8; 4])

The file signature is not LASF.

InvalidInverseTransform

The value can’t have the inverse transform applied.

Fields

n: f64

The float.

transform: Transform

The transform that can’t be applied

InvalidPointFormat(Format)

This is an invalid point format.

It has a combination of options that can’t exist.

InvalidPointFormatNumber(u8)

This is an invalid format number.

InvalidScannerChannel(u8)

This is not a valid scanner channel

Io(Error)

std::io::Error

LaszipNotEnabled

The las data is laszip compressed.

LasZipError(LasZipError)

Available on crate feature laz only.

laz::LasZipError

LasZipVlrNotFound

Available on crate feature laz only.

The laszip vlr was not found, the points cannot be decompressed.

NotAscii(String)

This string is not ASCII.

NotZeroFilled(Vec<u8>)

These bytes are not zero-filled.

OffsetToEvlrsTooSmall(u64)

The offset to the start of the evlrs is too small.

OffsetToPointDataTooLarge(usize)

The offset to point data is too large.

OffsetToPointDataTooSmall(u32)

The offset to the point data was too small.

OverlapClassification

Overlap points are handled by an attribute on Point, not by a classification.

PointAttributesDoNotMatch(Format)

The attributes of the point format and point do not match.

PointDataRecordLengthTooLarge

The point data record length is too small for the format.

Fields

format: Format

The point format.

len: u16

The length of the point data record.

PointPaddingNotAllowed

Point padding is only allowed when evlrs are present.

ReturnNumber

This is not a valid return number.

Fields

return_number: u8

The return number.

version: Option<Version>

The version that doesn’t support this return number.

StringTooLong

This string is too long for the target slice.

Fields

string: String

The string.

len: usize

The target length.

TooManyEvlrs(usize)

Too many extended variable length records.

TooManyPoints

Too many points for this version.

Fields

n: u64

The number of points.

version: Version

The LAS version

TooManyVlrs(usize)

Too many variable length records.

TryFromIntError(TryFromIntError)

std::num::TryFromIntError

UnsupportedFeature

Feature is not supported by version.

Fields

version: Version

The LAS version.

feature: &'static str

The feature that is not supported

UnsupportedFormat

The point format is not supported by version.

Fields

version: Version

The LAS version.

format: Format

The unsupported point format.

Utf8(Utf8Error)

std::str::Utf8Error

WktRequired(Format)

Wkt is required for this point format.

VlrTooLong(usize)

The vlr data is too long.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<LasZipError> for Error

fn from(source: LasZipError) -> Self

Converts to this type from the input type.

impl From<TryFromIntError> for Error

fn from(source: TryFromIntError) -> Self

Converts to this type from the input type.

impl From<Utf8Error> for Error

fn from(source: Utf8Error) -> Self

Converts to this type from the input type.