Struct aho_corasick::automaton::StateID

#[repr(transparent)]
pub struct StateID(SmallIndex);

The identifier of a finite automaton state.

It is represented by a u32 even on 64-bit systems in order to conserve space. Namely, on all targets, this type guarantees that its value will fit in a u32, i32, usize and an isize. This means that on 16-bit targets, for example, this type’s maximum value will never overflow an isize, which means it will never overflow a i16 even though its internal representation is still a u32.

Safety

While a StateID is meant to guarantee that its value fits into usize without using as much space as a usize on all targets, callers must not rely on this property for safety. Callers may choose to rely on this property for correctness however. For example, creating a StateID with an invalid value can be done in entirely safe code. This may in turn result in panics or silent logical errors.

Tuple Fields

0: SmallIndex

Implementations

impl StateID

pub const MAX: StateID = _

The maximum value.

pub const LIMIT: usize = 2_147_483_647usize

The total number of values that can be represented.

pub const ZERO: StateID = _

The zero value.

pub const SIZE: usize = 4usize

The number of bytes that a single value uses in memory.

pub fn new(value: usize) -> Result<StateID, StateIDError>

Create a new value that is represented by a “small index.”

If the given index exceeds the maximum allowed value, then this returns an error.

pub const fn new_unchecked(value: usize) -> StateID

Create a new value without checking whether the given argument exceeds the maximum.

Using this routine with an invalid value will result in unspecified behavior, but not undefined behavior. In particular, an invalid ID value is likely to cause panics or possibly even silent logical errors.

Callers must never rely on this type to be within a certain range for memory safety.

pub const fn from_u32_unchecked(index: u32) -> StateID

Create a new value from a u32 without checking whether the given value exceeds the maximum.

Using this routine with an invalid value will result in unspecified behavior, but not undefined behavior. In particular, an invalid ID value is likely to cause panics or possibly even silent logical errors.

Callers must never rely on this type to be within a certain range for memory safety.

pub fn must(value: usize) -> StateID

Like new, but panics if the given value is not valid.

pub const fn as_usize(&self) -> usize

Return the internal value as a usize. This is guaranteed to never overflow usize.

pub const fn as_u64(&self) -> u64

Return the internal value as a u64. This is guaranteed to never overflow.

pub const fn as_u32(&self) -> u32

Return the internal value as a u32. This is guaranteed to never overflow u32.

pub const fn as_i32(&self) -> i32

Return the internal value as a i32. This is guaranteed to never overflow an i32.

pub fn one_more(&self) -> usize

Returns one more than this value as a usize.

Since values represented by a “small index” have constraints on their maximum value, adding 1 to it will always fit in a usize, u32 and a i32.

pub fn from_ne_bytes(bytes: [u8; 4]) -> Result<StateID, StateIDError>

Decode this value from the bytes given using the native endian byte order for the current target.

If the decoded integer is not representable as a small index for the current target, then this returns an error.

pub fn from_ne_bytes_unchecked(bytes: [u8; 4]) -> StateID

Decode this value from the bytes given using the native endian byte order for the current target.

This is analogous to new_unchecked in that is does not check whether the decoded integer is representable as a small index.

pub fn to_ne_bytes(&self) -> [u8; 4]

Return the underlying integer as raw bytes in native endian format.

pub(crate) fn iter(len: usize) -> StateIDIter

Returns an iterator over all values from 0 up to and not including the given length.

If the given length exceeds this type’s limit, then this panics.

Trait Implementations

impl Clone for StateID

fn clone(&self) -> StateID

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StateID

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

Formats the value using the given formatter.

impl Default for StateID

fn default() -> StateID

Returns the “default value” for a type.

impl From<SmallIndex> for StateID

fn from(index: SmallIndex) -> StateID

Converts to this type from the input type.

impl From<StateID> for SmallIndex

fn from(sid: StateID) -> SmallIndex

Converts to this type from the input type.

impl From<u8> for StateID

fn from(value: u8) -> StateID

Converts to this type from the input type.

impl Hash for StateID

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<StateID> for [T]

type Output = T

The returned type after indexing.

fn index(&self, index: StateID) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<StateID> for Vec<T>

type Output = T

The returned type after indexing.

fn index(&self, index: StateID) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<StateID> for [T]

fn index_mut(&mut self, index: StateID) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<StateID> for Vec<T>

fn index_mut(&mut self, index: StateID) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl Ord for StateID

fn cmp(&self, other: &StateID) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for StateID

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

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl TryFrom<u16> for StateID

type Error = StateIDError

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<StateID, StateIDError>

Performs the conversion.

impl TryFrom<u32> for StateID

type Error = StateIDError

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<StateID, StateIDError>

Performs the conversion.

impl TryFrom<u64> for StateID

type Error = StateIDError

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<StateID, StateIDError>

Performs the conversion.

impl TryFrom<usize> for StateID

type Error = StateIDError

The type returned in the event of a conversion error.

fn try_from(value: usize) -> Result<StateID, StateIDError>

Performs the conversion.

impl Copy for StateID

impl Eq for StateID

impl StructuralPartialEq for StateID