Struct stabby_abi::istable::Array

pub struct Array<Offset: Unsigned, T, Rest>(/* private fields */);

A type-fu linked list.

Trait Implementations

impl<Offset: Unsigned, T, Rest> Default for Array<Offset, T, Rest>

fn default() -> Self

Returns the “default value” for a type.

impl<Offset: Unsigned, T: NonZero, Rest: IBitMask> IBitMask for Array<Offset, T, Rest>

const TUPLE: Self::Tuple = _

Expose the bitmask at runtime.

type Tuple = ((usize, usize), <Rest as IBitMask>::Tuple)

The type of the runtime-exposed mask.

type ByteAt<O: Unsigned> = <<Offset as IUnsigned>::Equal<O> as IBit>::UTernary<T, <Rest as IBitMask>::ByteAt<O>>

Self[O]

type BitAnd<Mask: IBitMask> = <<<T as IUnsigned>::BitAnd<<Mask as IBitMask>::ByteAt<Offset>> as IUnsigned>::Equal<UTerm> as IBit>::BmTernary<<Rest as IBitMask>::BitAnd<Mask>, Array<Offset, <<T as IUnsigned>::BitAnd<<Mask as IBitMask>::ByteAt<Offset>> as IUnsigned>::NonZero, <Rest as IBitMask>::BitAnd<Mask>>>

Self & T

type BitOr<Arr: IBitMask> = Array<Offset, T, <Rest as IBitMask>::BitOr<Arr>>

Self | T

type Shift<O: Unsigned> = Array<<Offset as IUnsigned>::Add<O>, T, <Rest as IBitMask>::Shift<O>>

Shift the bitmask by O bytes.

type HasFreeByteAt<O: Unsigned> = <<<O as IUnsigned>::Equal<Offset> as IBit>::And<<T as IUnsigned>::Equal<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>>> as IBit>::Or<<Rest as IBitMask>::HasFreeByteAt<O>>

Checks whether the mask is FF at index O

type ExtractBit = <<<T as IUnsigned>::AbsSub<<T as NonZero>::TruncateAtRightmostOne> as IUnsigned>::Greater<UTerm> as IBit>::BmTernary<Array<Offset, <<T as IUnsigned>::AbsSub<<T as NonZero>::TruncateAtRightmostOne> as IUnsigned>::NonZero, Rest>, Rest>

Remove the next bit that will be used as a determinant in enums.

type ExtractedBitByteOffset = Offset

Obtain the determinant’s offset in bytes.

type ExtractedBitMask = <T as NonZero>::TruncateAtRightmostOne

Obtain the determinant’s mask.

impl<Offset: Unsigned, T, Rest: IForbiddenValues> IForbiddenValues for Array<Offset, T, Rest>

type Shift<O: Unsigned> = Array<<Offset as IUnsigned>::Add<O>, T, <Rest as IForbiddenValues>::Shift<O>>

Shift all values in the set by O bytes

type Or<O: IForbiddenValues> = Or<O, Array<Offset, T, Rest>>

union(Self, T)

type SelectFrom<Mask: IBitMask> = <<<Mask as IBitMask>::HasFreeByteAt<Offset> as IBitBase>::AsForbiddenValue as ISingleForbiddenValue>::And<<<Rest as IForbiddenValues>::SelectFrom<Mask> as ISingleForbiddenValue>::Push<Offset, T>>

Extract a single forbidden value that fits within Mask

type SelectOne = Array<Offset, T, <Rest as IForbiddenValues>::SelectOne>

Extract the first available forbidden value.

impl<Offset: Unsigned, T, Rest: ISingleForbiddenValue> ISingleForbiddenValue for Array<Offset, T, Rest>

type Push<O: Unsigned, V> = Array<O, V, Array<Offset, T, Rest>>

Add a byte to the forbidden value.

type Or<V: ISingleForbiddenValue> = Array<Offset, T, Rest>

Self == End ? T : Self

type And<V: ISingleForbiddenValue> = V

T == End ? Self : T

type Resolve = Array<Offset, T, Rest>

Turns Saturators into End.

impl<O: Unsigned, T, R: IBitMask> Includes<Array<O, T, R>> for End

type Output = End

The result

impl<O1: Unsigned, T1, R1, O2: Unsigned, T2, R2: IBitMask> Includes<Array<O1, T1, R1>> for Array<O2, T2, R2>

where Array<O2, T2, R2>: IncludesComputer<(O1, T1)> + Includes<R1>, R1: IsEnd + IBitMask, <Self as Includes<R1>>::Output: IsEnd, (<Self as IncludesComputer<(O1, T1)>>::Output, <Self as Includes<R1>>::Output, <<Self as Includes<R1>>::Output as IsEnd>::Output, <R1 as IsEnd>::Output): Arrayify,

type Output = <(<Array<O2, T2, R2> as IncludesComputer<(O1, T1)>>::Output, <Array<O2, T2, R2> as Includes<R1>>::Output, <<Array<O2, T2, R2> as Includes<R1>>::Output as IsEnd>::Output, <R1 as IsEnd>::Output) as Arrayify>::Output

The result

impl<O1: Unsigned, T1, O2: Unsigned, T2, R2: IBitMask> IncludesComputer<(O1, T1)> for Array<O2, T2, R2>

where Self: IncludesComputer<(O1, T1, <O1 as Unsigned>::Equal<O2>)>,

type Output = <Array<O2, T2, R2> as IncludesComputer<(O1, T1, <O1 as IUnsigned>::Equal<O2>)>>::Output

Support for stabby computations

impl<O1: Unsigned, T1, O2: Unsigned, T2, R2> IncludesComputer<(O1, T1, B0)> for Array<O2, T2, R2>

where R2: IncludesComputer<(O1, T1)> + IBitMask,

type Output = <R2 as IncludesComputer<(O1, T1)>>::Output

Support for stabby computations

impl<O1: Unsigned, T1, O2: Unsigned, T2: Unsigned, R2: IBitMask> IncludesComputer<(O1, T1, B1)> for Array<O2, T2, R2>

where Self: IncludesComputer<(O1, T1, B1, <T2 as Unsigned>::Equal<U255>)>,

type Output = <Array<O2, T2, R2> as IncludesComputer<(O1, T1, B1, <T2 as IUnsigned>::Equal<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>>)>>::Output

Support for stabby computations

impl<O1: Unsigned, T1, O2: Unsigned, T2, R2: IBitMask> IncludesComputer<(O1, T1, B1, B0)> for Array<O2, T2, R2>

type Output = End

Support for stabby computations

impl<O1: Unsigned, T1, O2: Unsigned, T2, R2: IBitMask> IncludesComputer<(O1, T1, B1, B1)> for Array<O2, T2, R2>

type Output = (O1, T1)

Support for stabby computations

impl<Offset: Unsigned, Value: Unsigned, Tail: IForbiddenValues + IntoValueIsErr> IntoValueIsErr for Array<Offset, Value, Tail>

type ValueIsErr = ValueIsErr<Offset, Value, <Tail as IntoValueIsErr>::ValueIsErr>

The coerced type.

impl<O: Unsigned, T, R: IBitMask> IsEnd for Array<O, T, R>

type Output = B0

The result