Struct LkPathArray

#[repr(C)]
pub struct LkPathArray<const N: usize = linkspace_point::::path::LkPathArray::{constant#0}> {
    pub roots: Roots,
    /* private fields */
}

Fields

roots: Roots

Implementations

impl LkPathArray

pub const EMPTY: LkPathArray = Self::EMPTY_CONST_SIZED

pub const INVALID: LkPathArray<0>

This triggers MissingRoots error on deserialize::LkPath::from_bytes

pub const fn from_path(value: &LkPath) -> LkPathArray

pub fn extend_from_iter<A, T>(&mut self, iter: T) -> Result<(), LkPathError>

where A: AsRef<[u8]>, T: IntoIterator<Item = A>,

pub fn try_from_iter<A, T>(iter: T) -> Result<LkPathArray, LkPathError>

where A: AsRef<[u8]>, T: IntoIterator<Item = A>,

impl<const N: usize> LkPathArray<N>

pub const EMPTY_CONST_SIZED: LkPathArray<N>

pub const fn push(&mut self, part: &[u8]) -> Result<(), LkPathError>

pub const fn try_from_path( path: &LkPath, ) -> Result<LkPathArray<N>, CapacityError>

impl LkPathArray

pub fn try_from_ablist(ablist: &ABList) -> Result<LkPathArray, LkPathExprError>

impl LkPathArray

pub fn parse_eval_basic( st: &str, ) -> Result<LkPathArray, ABEError<LkPathExprError>>

impl<const N: usize> LkPathArray<N>

pub const fn as_path(&self) -> &LkPath

pub const fn as_path_mut(&mut self) -> &mut LkPath

Methods from Deref<Target = LkPath>

pub fn to_array(&self) -> LkPathArray

pub fn pop_last(&self) -> (&LkPathSegm, Option<LkPathPart<'_>>)

pub fn ablist(&self) -> ABList

pub const EMPTY: &'static LkPath

pub fn segments(&self) -> &LkPathSegm

pub fn double_check_parts(&self) -> Result<(), LkPathError>

pub fn as_bytes(&self) -> &[u8]

pub fn as_bytes_inclusive(&self) -> &[u8]

pub fn parts(&self) -> [Option<LkPathPart<'_>>; 8]

pub fn parts_bytes(&self) -> [&[u8]; 8]

pub fn parts_bytes_mut(&mut self) -> [&mut [u8]; 8]

pub fn nparts(&self) -> &u8

pub fn part0(&self) -> &[u8]

pub fn part0_mut(&mut self) -> &mut [u8]

pub fn part1(&self) -> &[u8]

pub fn part1_mut(&mut self) -> &mut [u8]

pub fn part2(&self) -> &[u8]

pub fn part2_mut(&mut self) -> &mut [u8]

pub fn part3(&self) -> &[u8]

pub fn part3_mut(&mut self) -> &mut [u8]

pub fn part4(&self) -> &[u8]

pub fn part4_mut(&mut self) -> &mut [u8]

pub fn part5(&self) -> &[u8]

pub fn part5_mut(&mut self) -> &mut [u8]

pub fn part6(&self) -> &[u8]

pub fn part6_mut(&mut self) -> &mut [u8]

pub fn part7(&self) -> &[u8]

pub fn part7_mut(&mut self) -> &mut [u8]

pub fn boxed(&self) -> Box<LkPath>

pub fn rc(&self) -> Rc<LkPath>

Methods from Deref<Target = LkPathSegm>

pub fn try_into_array(&self) -> Result<LkPathArray, LkPathError>

pub fn alt_delimiter(&self, delim: Ctr) -> String

pub const EMPTY: &'static LkPathSegm

pub fn iter(&self) -> impl Iterator<Item = LkPathPart<'_>>

pub fn iter_checked( &self, ) -> impl Iterator<Item = Result<LkPathPart<'_>, LkPathError>>

pub fn is_empty(&self) -> bool

pub fn raw_segment_bytes(&self) -> &[u8]

pub fn starts_with(&self, other: &LkPathSegm) -> bool

pub fn shift(&self) -> (Option<LkPathPart<'_>>, &LkPathSegm)

Trait Implementations

impl ABEValidator for LkPathArray

fn check(b: &[ABE]) -> Result<(), MatchError>

impl Borrow<LkPath> for LkPathArray

fn borrow(&self) -> &LkPath

Immutably borrows from an owned value.

impl<const N: usize> Clone for LkPathArray<N>

fn clone(&self) -> LkPathArray<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for LkPathArray<N>

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

Formats the value using the given formatter.

impl Default for LkPathArray

fn default() -> LkPathArray

Returns the “default value” for a type.

impl<const N: usize> Deref for LkPathArray<N>

type Target = LkPath

The resulting type after dereferencing.

fn deref(&self) -> &<LkPathArray<N> as Deref>::Target

Dereferences the value.

impl<const N: usize> DerefMut for LkPathArray<N>

fn deref_mut(&mut self) -> &mut <LkPathArray<N> as Deref>::Target

Mutably dereferences the value.

impl<const N: usize> Display for LkPathArray<N>

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

Formats the value using the given formatter.

impl From<&LkPath> for LkPathArray

fn from(value: &LkPath) -> LkPathArray

Converts to this type from the input type.

impl FromStr for LkPathArray

type Err = ABEError<LkPathExprError>

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<LkPathArray, <LkPathArray as FromStr>::Err>

Parses a string s to return a value of this type.

impl Ord for LkPathArray

fn cmp(&self, other: &LkPathArray) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: usize> PartialEq for LkPathArray<N>

fn eq(&self, other: &LkPathArray<N>) -> 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 PartialOrd for LkPathArray

fn partial_cmp(&self, other: &LkPathArray) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToABE for LkPathArray

fn write_abe(&self, out: &mut dyn FnMut(ABE))

fn write_abe_str(&self, out: &mut dyn Write) -> Result<(), Error>

fn to_abe_str(&self) -> String

fn to_abe(&self) -> Vec<ABE>

impl TryAsSpace for LkPathArray

fn try_as_space(&self, scope: &dyn LkEnv) -> Result<Space>

impl TryFrom<ABList> for LkPathArray

type Error = LkPathExprError

The type returned in the event of a conversion error.

fn try_from( ablist: ABList, ) -> Result<LkPathArray, <LkPathArray as TryFrom<ABList>>::Error>

Performs the conversion.

impl<const N: usize> Copy for LkPathArray<N>

impl<const N: usize> Eq for LkPathArray<N>

impl<const N: usize> StructuralPartialEq for LkPathArray<N>