Struct rustfst::fst_impls::VectorFst

pub struct VectorFst<W: Semiring> { /* private fields */ }

Trait Implementations

impl<W: 'static + Semiring> Add<VectorFst<W>> for VectorFst<W>

type Output = Result<VectorFst<W>, Error>

The resulting type after applying the + operator.

fn add(self, rhs: VectorFst<W>) -> Self::Output

Performs the + operation.

impl<'a, W: 'static + Semiring> ArcIterator<'a> for VectorFst<W>

type Iter = Iter<'a, Arc<W>>

Iterator used to iterate over the arcs leaving a state of an FST.

fn arcs_iter(&'a self, state_id: &StateId) -> Result<Self::Iter, Error>

impl<W: 'static + Semiring> BitOr<VectorFst<W>> for VectorFst<W>

type Output = Result<VectorFst<W>, Error>

The resulting type after applying the | operator.

fn bitor(self, rhs: VectorFst<W>) -> Self::Output

Performs the | operation.

impl<W: Clone + Semiring> Clone for VectorFst<W>

fn clone(&self) -> VectorFst<W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<W: 'static + Semiring> CoreFst for VectorFst<W>

type W = W

Weight use in the wFST. This type must implement the Semiring trait

fn start(&self) -> Option<StateId>

Returns the ID of the start state of the wFST if it exists else none.

fn final_weight(&self, state_id: &StateId) -> Option<W>

Retrieves the final weight of a state (if the state is a final one).

fn num_arcs(&self) -> usize

Total number of arcs in the wFST. This is the sum of the outgoing arcs of each state.

fn is_final(&self, state_id: &StateId) -> bool

Returns whether or not the state with identifier passed as parameters is a final state.

impl<W: Debug + Semiring> Debug for VectorFst<W>

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

Formats the value using the given formatter.

impl<W: 'static + Semiring> Display for VectorFst<W>where
    W::Type: Display,

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

Formats the value using the given formatter.

impl<W: 'static + Semiring> ExpandedFst for VectorFst<W>

fn num_states(&self) -> usize

Returns the number of states that contains the FST. They are all counted even if some states are not on a successful path (doesn’t perform triming).

impl<'a, W: 'static + Semiring> MutableArcIterator<'a> for VectorFst<W>

type IterMut = IterMut<'a, Arc<W>>

fn arcs_iter_mut(
    &'a mut self,
    state_id: &StateId
) -> Result<Self::IterMut, Error>

impl<W: 'static + Semiring> MutableFst for VectorFst<W>

fn new() -> Self

Creates an empty wFST

fn set_start(&mut self, state_id: &StateId) -> Result<(), Error>

The state with identifier state_id is now the start state. Note that only one start state is allowed in this implementation. Calling this function twice will mean losing the first start state. If the state_id doesn’t exist an error is raised.

fn set_final(&mut self, state_id: &StateId, final_weight: W) -> Result<(), Error>

The state with identifier state_id is now a final state with a weight final_weight. If the state_id doesn’t exist an error is raised.

fn add_state(&mut self) -> StateId

Adds a new state to the current FST. The identifier of the new state is returned

fn add_arc(
    &mut self,
    source: &StateId,
    arc: Arc<<Self as CoreFst>::W>
) -> Result<(), Error>

Adds an arc to the FST. The arc will start in the state source. An error is raised if the state source doesn’t exist.

fn del_state(&mut self, state_to_remove: &StateId) -> Result<(), Error>

Removes a state from an FST. It also removes all the arcs starting from another state and reaching this state. An error is raised if the state state_id doesn’t exist.

fn del_states<T: IntoIterator<Item = StateId>>(
    &mut self,
    states: T
) -> Result<(), Error>

Removes multiple states from an FST. If one of the states doesn’t exist, an error is raised.

fn add_fst<F: ExpandedFst<W = Self::W>>(
    &mut self,
    fst_to_add: &F
) -> Result<HashMap<StateId, StateId>, Error>

impl<W: PartialEq + Semiring> PartialEq<VectorFst<W>> for VectorFst<W>

fn eq(&self, other: &VectorFst<W>) -> 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<'a, W: 'a + Semiring> StateIterator<'a> for VectorFst<W>

type Iter = VectorStateIterator<'a, W>

Iterator used to iterate over the state_id of the states of an FST.

fn states_iter(&'a self) -> Self::Iter

Creates an iterator over the state_id of the states of an FST.

impl<W: 'static + Semiring> Fst for VectorFst<W>

impl<W: Semiring> StructuralPartialEq for VectorFst<W>