Enum tor_netdoc::Pos

#[non_exhaustive]
pub enum Pos {
    None,
    Unknown,
    Invalid(usize),
    Byte {
        off: usize,
    },
    PosInLine {
        line: usize,
        byte: usize,
    },
    Raw {
        ptr: *const u8,
    },
}

A position within a directory object. Used to tell where an error occurred.

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.

None

The error did not occur at any particular position.

This can happen when the error is something like a missing entry: the entry is supposed to go somewhere, but we can’t say where.

Unknown

The error occurred at an unknown position.

We should avoid using this case.

Invalid(usize)

The error occurred at an invalid offset within the string, or outside the string entirely.

This can only occur because of an internal error of some kind.

Byte

The error occurred at a particular byte within the string.

We try to convert these to a Pos before displaying them to the user.

Fields

off: usize

Byte offset within a string.

PosInLine

The error occurred at a particular line (and possibly at a particular byte within the line.)

Fields

line: usize

Line offset within a string.

byte: usize

Byte offset within the line.

Raw

The error occurred at a position in memory. This shouldn’t be exposed to the user, but rather should be mapped to a position in the string.

Fields

ptr: *const u8

A raw pointer to the position where the error occurred.

Implementations

impl Pos

pub fn from_offset(s: &str, off: usize) -> Self

Construct a Pos from an offset within a &str slice.

pub fn at(s: &str) -> Self

Construct a Pos from a slice of some other string. This Pos won’t be terribly helpful, but it may be converted into a useful Pos with within.

pub fn at_end_of(s: &str) -> Self

Construct Pos from the end of some other string.

pub fn from_byte(off: usize) -> Self

Construct a position from a byte offset.

pub fn from_line(line: usize, byte: usize) -> Self

Construct a position from a line and a byte offset within that line.

pub fn within(self, s: &str) -> Self

Given a position, if it was at a byte offset, convert it to a line-and-byte position within s.

Requires that this position was actually generated from s. If it was not, the results here may be nonsensical.

TODO: I wish I knew an efficient safe way to do this that guaranteed that we we always talking about the right string.

Trait Implementations

impl Clone for Pos

fn clone(&self) -> Pos

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Pos

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

Formats the value using the given formatter.

impl Display for Pos

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

Formats the value using the given formatter.

impl PartialEq for Pos

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Pos

impl Eq for Pos

impl Send for Pos

impl StructuralPartialEq for Pos

impl Sync for Pos