Struct VectorFst 

pub struct VectorFst<A: Arc> { /* private fields */ }

A simple, mutable FST whose states and arcs are stored in standard Vecs.

Implementations

impl<A: Arc> VectorFst<A>

pub const STATIC_PROPERTIES: u64

pub fn new() -> Self

impl<A: Arc> VectorFst<A>

where A::Label: FstScalar, A::StateId: FstScalar, A::Weight: WeightIo,

pub fn read<R: Read>( reader: &mut R, opts: &FstReadOptions, ) -> Result<Self, OpenFstError>

Reads a VectorFst from a stream.

Unlike ConstFst, the states and arcs are written field by field rather than as a block of memory, so there is nothing here that could be mapped and nothing that depends on how a struct happens to be laid out.

pub fn write_fst<F: Fst<A>, W: Write>( fst: &F, writer: &mut W, opts: &FstWriteOptions, ) -> Result<(), OpenFstError>

Writes any FST out in this format.

SICADA-DIVERGE: upstream writes a header saying it does not know the state count when the stream cannot seek, then seeks back to correct it when it can. This always counts first; see ConstFst::write_fst, which makes the same trade for the same reason.

pub fn write<W: Write>( &self, writer: &mut W, opts: &FstWriteOptions, ) -> Result<(), OpenFstError>

Writes this FST out.

Trait Implementations

impl<A: Clone + Arc> Clone for VectorFst<A>

where A::StateId: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Arc> ContiguousArcsFst<A> for VectorFst<A>

fn arcs_slice(&self, state: A::StateId) -> &[A]

Returns a contiguous slice of arcs leaving the given state.

impl<A: Debug + Arc> Debug for VectorFst<A>

where A::StateId: Debug,

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

Formats the value using the given formatter.

impl<A: Arc> Default for VectorFst<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Arc> ExpandedFst<A> for VectorFst<A>

fn num_states(&self) -> usize

Returns the total number of states in the FST.

impl<A: Arc> Fst<A> for VectorFst<A>

type StateIter<'a> = VectorFstStateIter<'a, A> where A: 'a

An iterator over the states of the FST.

type ArcIter<'a> = Cloned<Iter<'a, A>> where A: 'a

An iterator over the outgoing arcs of a state. Clone is required to allow multi-pass algorithms (e.g., matchers in Compose) to save and restore iteration positions effortlessly without C++ Seek or Reset.

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

Returns the initial state ID, or None if the FST is empty.

fn final_weight(&self, state: A::StateId) -> A::Weight

Returns the final weight of the given state. If the state is not final, this must return Weight::zero().

fn num_arcs(&self, state: A::StateId) -> usize

Returns the number of arcs leaving the given state.

fn num_input_epsilons(&self, state: A::StateId) -> usize

Returns the number of input epsilon arcs leaving the given state.

fn num_output_epsilons(&self, state: A::StateId) -> usize

Returns the number of output epsilon arcs leaving the given state.

fn num_states_if_known(&self) -> Option<usize>

Returns the number of states if it is finite and can be computed in O(1) time. Otherwise returns None.

fn properties(&self, mask: u64, test: bool) -> u64

Property bits. If test is false, returns stored properties bits (some possibly unknown). If test is true, computes the properties if they are unknown.

fn fst_type(&self) -> &str

Returns the name of the FST type (e.g., “vector”, “const”).

fn input_symbols(&self) -> Option<AtomicRc<SymbolTable>>

Returns the input label symbol table, if any. Using Arc allows cheap sharing across FST operations.

fn output_symbols(&self) -> Option<AtomicRc<SymbolTable>>

Returns the output label symbol table, if any.

fn states<'a>(&'a self) -> Self::StateIter<'a>

Returns an iterator over all state IDs in the FST.

fn arcs<'a>(&'a self, state: A::StateId) -> Self::ArcIter<'a>

Returns an iterator over the outgoing arcs of the given state.

fn count_states(&self) -> usize

Computes the exact number of states in the FST. If the state count is known in O(1) (i.e. num_states_if_known returns Some), it uses that. Otherwise, it iterates through all states in O(V) time.

fn count_arcs(&self) -> usize

Computes the exact number of arcs in the FST in O(V) time.

impl<A: Arc> MutableFst<A> for VectorFst<A>

fn set_start(&mut self, state: A::StateId)

Sets the initial state.

fn set_final(&mut self, state: A::StateId, weight: A::Weight)

Sets the final weight of a given state. Setting it to Weight::zero() effectively marks the state as non-final.

fn set_properties(&mut self, props: u64, mask: u64)

Explicitly updates the properties mask.

fn add_state(&mut self) -> A::StateId

Adds a new state to the FST and returns its ID.

fn add_states(&mut self, n: usize)

Adds n new states to the FST.

fn add_arc(&mut self, state: A::StateId, arc: A)

Adds an outgoing arc to a given state.

fn arcs_mut(&mut self, state: A::StateId) -> &mut [A]

The arcs leaving state, to be rearranged in place.

fn delete_arcs_n(&mut self, state: A::StateId, n: usize)

Deletes n outgoing arcs from a given state.

fn delete_arcs(&mut self, state: A::StateId)

Deletes all outgoing arcs from a given state.

fn delete_all_states(&mut self)

Deletes all states and arcs, leaving the FST empty.

fn delete_states(&mut self, dstates: &[A::StateId])

Deletes specific states. Note: This renumbers the remaining states and invalidates existing Arc nextstates.

fn reserve_states(&mut self, n: usize)

Hints the underlying allocation to reserve space for n total states.

fn reserve_arcs(&mut self, state: A::StateId, n: usize)

Hints the underlying allocation to reserve space for n arcs on a specific state.

fn set_input_symbols(&mut self, syms: Option<AtomicRc<SymbolTable>>)

Attaches an input symbol table.

fn set_output_symbols(&mut self, syms: Option<AtomicRc<SymbolTable>>)

Attaches an output symbol table.

fn mutable_input_symbols(&mut self) -> Option<&mut SymbolTable>

The input symbol table, to be changed in place.

fn mutable_output_symbols(&mut self) -> Option<&mut SymbolTable>

The output symbol table, to be changed in place. See mutable_input_symbols.

fn mutate_arcs<F>(&mut self, state: A::StateId, mutator: F)

where F: FnMut(&mut A),

Rewrites every arc leaving state.