Struct LanguageOfAlignments 

pub struct LanguageOfAlignments {
    pub activity_key: ActivityKey,
    pub alignments: Vec<Vec<Move>>,
}

Fields

activity_key: ActivityKey

alignments: Vec<Vec<Move>>

Implementations

impl LanguageOfAlignments

pub fn new(activity_key: ActivityKey) -> Self

pub fn push(&mut self, alignment: Vec<Move>)

pub fn append(&mut self, alignments: &mut Vec<Vec<Move>>)

pub fn get(&self, index: usize) -> Option<&Vec<Move>>

pub fn get_activity_key(&self) -> &ActivityKey

pub fn get_activity_key_mut(&mut self) -> &mut ActivityKey

pub fn sort(&mut self)

Trait Implementations

impl Clone for LanguageOfAlignments

fn clone(&self) -> LanguageOfAlignments

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Display for LanguageOfAlignments

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

Formats the value using the given formatter.

impl Exportable for LanguageOfAlignments

fn export_from_object(object: EbiObject, f: &mut dyn Write) -> Result<()>

Input: any EbiObject. Output: the object will have been converted if necessary, and written to f. May fail for all kinds of reasons.

fn export(&self, f: &mut dyn Write) -> Result<()>

impl From<StochasticLanguageOfAlignments> for LanguageOfAlignments

fn from(value: StochasticLanguageOfAlignments) -> Self

Converts to this type from the input type.

impl FromStr for LanguageOfAlignments

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl HasActivityKey for LanguageOfAlignments

fn activity_key(&self) -> &ActivityKey

fn activity_key_mut(&mut self) -> &mut ActivityKey

impl Importable for LanguageOfAlignments

const FILE_FORMAT_SPECIFICATION_LATEX: &str = "A language of alignments is a line-based structure. Lines starting with a \\# are ignored. This first line is exactly `language of alignments'. The second line is the number of alignments in the language. For each alignment, the first line contains the number of moves in the alignment. Then, each move is given as either \\begin{itemize} \\item `synchronous move', followed by a line with the word `label' followed by a space and the activity label, which is followed with a line with the index of the involved transition. \\item `silent move', followed by a line with the index of the silent transition. \\item `log move', followed by a line with the word `label', then a space, and then the activity label. \\item `model move', followed by a line with the word `label' followed by a space and the activity label, which is followed with a line with the index of the involved ransition. \\end{itemize} Note that the Semantics trait of Ebi, which is what most alignment computations use, requires that every final marking is a deadlock. Consequently, an implicit silent transition may be added by the Semantics trait that is not in the model. For instance: \\lstinputlisting[language=ebilines, style=boxed]{../testfiles/aa-ab-ba.ali}"

A latex piece that describes the file format.

const IMPORTER_PARAMETERS: &[ImporterParameter]

Defines the parameters that the importer expects.

fn import_as_object( reader: &mut dyn BufRead, parameter_values: &ImporterParameterValues, ) -> Result<EbiObject>

fn import(reader: &mut dyn BufRead, _: &ImporterParameterValues) -> Result<Self>

where Self: Sized,

Attempts to import from the reader. The parameter_values must match the order given in IMPORTER_PARAMETERS.

fn default_importer_parameter_values() -> ImporterParameterValues

impl Infoable for LanguageOfAlignments

fn info(&self, f: &mut impl Write) -> Result<()>

impl TranslateActivityKey for LanguageOfAlignments

fn translate_using_activity_key(&mut self, to_activity_key: &mut ActivityKey)

Change the activity key of this object, by translating all mentions of activities to the new activity key (which will be updated with activity labels it did not have yet.). This is a potentially expensive operation. If only a part of the activities will be used, then consider using an ActivityKeyTranslator directly. The activity key of this object will be updated too, so the activity keys will be equivalent afterwards.