Struct PetriNetInfo 

pub struct PetriNetInfo(/* private fields */);

A wrapper type representing petri net for simulation.

Methods from Deref<Target = Net>

pub fn save(&self, filename: &Path) -> Result<(), Error>

Save the petri net to a file. Result represents success.

Examples found in repository

examples/example.rs (line 47)

fn main() -> ExitCode {
    let mut save = false;
    let mut load = false;

    let mut args = std::env::args();
    args.next();
    for arg in args {
        match arg.as_ref() {
            "save" => save = true,
            "load" => load = true,
            _ => eprintln!("Ignore invalid argument '{arg}'"),
        }
    }

    let Ok(net) = Net::load("examples/example.pn".as_ref()) else {
        eprintln!("Failed to load example net");
        return ExitCode::FAILURE;
    };
    let mut net = MultiPetriNetSimulation::new(net);

    let mut names = HashMap::new();
    let Ok(file) = File::open("examples/example.pnk") else {
        eprintln!("Failed to load example keys");
        return ExitCode::FAILURE;
    };
    for (tid, line) in net.transition_ids().zip(BufReader::new(file).lines()) {
        let Ok(line) = line else {
            eprintln!("Failed to read key");
            return ExitCode::FAILURE;
        };
        names.insert(tid, line);
    }

    if save && net.save("examples/example_copy.pns".as_ref()).is_err() {
        eprintln!("Failed to save example net");
    }

    if load {
        fn read_values(filename: &Path) -> std::io::Result<Vec<u32>> {
            let size = (std::fs::metadata(filename)?.len() + 3) / 4;

            let mut file = File::open(filename)?;

            (0..size)
                .map(|_| {
                    let mut value = [0; 4];
                    file.read_exact(&mut value)?;
                    Ok(u32::from_le_bytes(value))
                })
                .collect()
        }

        let Ok(data) = read_values("examples/example.pns".as_ref()) else {
            eprintln!("Reading state data failed");
            return ExitCode::FAILURE;
        };

        if net.add_simulation_from_data(data).is_err() {
            eprintln!("State initialization failed");
            return ExitCode::FAILURE;
        }
    } else {
        net.add_simulation();
    }

    enum StepAction {
        Continue,
        Reverse,
        Save,
        Quit,
    }

    let mut forward = true;
    for mut simulation in &mut net {
        fn step<D: PlayDirection>(
            fire: CallState<PetriNetSimulationBorrowMut, D>,
            names: &HashMap<Tid, String>,
        ) -> StepAction {
            if fire.callables.is_empty() {
                return StepAction::Reverse;
            }

            for (i, tid) in fire.callables.iter().enumerate() {
                println!("{}: {}", i + 1, names[tid]);
            }
            let stdin = io::stdin();
            let mut string = String::new();
            let Ok(size) = stdin.read_line(&mut string) else {
                eprintln!("Input error");
                return StepAction::Continue;
            };
            if size == 0 {
                return StepAction::Continue;
            }
            match unsafe { string.chars().next().unwrap_unchecked() } {
                'r' => return StepAction::Reverse,
                'q' => return StepAction::Quit,
                's' => return StepAction::Save,
                _ => (),
            }
            match usize::from_str(&string[..(string.len() - 1)]) {
                Ok(num) if num != 0 && num <= fire.callables.len() => {
                    fire.call(num - 1);
                }
                _ => {
                    println!(
                        "You have to input a valid number from 1 to {}",
                        fire.callables.len()
                    );
                    println!("You can also quit by writing \"q\", save the current state by writing \"s\" or reverse by writing \"r\"");
                    return StepAction::Continue;
                }
            }

            StepAction::Continue
        }

        loop {
            let step_action = if forward {
                step(simulation.prepare_call(), &names)
            } else {
                step(simulation.prepare_revert(), &names)
            };

            use StepAction::*;
            match step_action {
                Continue => (),
                Reverse => {
                    println!("Reverse play direction!");
                    forward = !forward;
                }
                Save => {
                    fn save(data: &[usize], filename: &Path) -> std::io::Result<()> {
                        let mut file = File::create(filename)?;
                        for &count in data {
                            file.write_all(&(count as u32).to_le_bytes())?;
                        }

                        Ok(())
                    }

                    let data = simulation.data();

                    println!(
                        "{}",
                        if save(data, "examples/example.pns".as_ref()).is_ok() {
                            "Saving successful"
                        } else {
                            "Saving failed"
                        }
                    );
                }
                Quit => break,
            }
        }
    }

    ExitCode::SUCCESS
}

pub fn transition_count(&self) -> usize

The count of transitions of the petri net.

pub fn transition_ids(&self) -> Ids<Transition>

An iterator over the ids of existing transitions.

Examples found in repository

examples/example.rs (line 39)

fn main() -> ExitCode {
    let mut save = false;
    let mut load = false;

    let mut args = std::env::args();
    args.next();
    for arg in args {
        match arg.as_ref() {
            "save" => save = true,
            "load" => load = true,
            _ => eprintln!("Ignore invalid argument '{arg}'"),
        }
    }

    let Ok(net) = Net::load("examples/example.pn".as_ref()) else {
        eprintln!("Failed to load example net");
        return ExitCode::FAILURE;
    };
    let mut net = MultiPetriNetSimulation::new(net);

    let mut names = HashMap::new();
    let Ok(file) = File::open("examples/example.pnk") else {
        eprintln!("Failed to load example keys");
        return ExitCode::FAILURE;
    };
    for (tid, line) in net.transition_ids().zip(BufReader::new(file).lines()) {
        let Ok(line) = line else {
            eprintln!("Failed to read key");
            return ExitCode::FAILURE;
        };
        names.insert(tid, line);
    }

    if save && net.save("examples/example_copy.pns".as_ref()).is_err() {
        eprintln!("Failed to save example net");
    }

    if load {
        fn read_values(filename: &Path) -> std::io::Result<Vec<u32>> {
            let size = (std::fs::metadata(filename)?.len() + 3) / 4;

            let mut file = File::open(filename)?;

            (0..size)
                .map(|_| {
                    let mut value = [0; 4];
                    file.read_exact(&mut value)?;
                    Ok(u32::from_le_bytes(value))
                })
                .collect()
        }

        let Ok(data) = read_values("examples/example.pns".as_ref()) else {
            eprintln!("Reading state data failed");
            return ExitCode::FAILURE;
        };

        if net.add_simulation_from_data(data).is_err() {
            eprintln!("State initialization failed");
            return ExitCode::FAILURE;
        }
    } else {
        net.add_simulation();
    }

    enum StepAction {
        Continue,
        Reverse,
        Save,
        Quit,
    }

    let mut forward = true;
    for mut simulation in &mut net {
        fn step<D: PlayDirection>(
            fire: CallState<PetriNetSimulationBorrowMut, D>,
            names: &HashMap<Tid, String>,
        ) -> StepAction {
            if fire.callables.is_empty() {
                return StepAction::Reverse;
            }

            for (i, tid) in fire.callables.iter().enumerate() {
                println!("{}: {}", i + 1, names[tid]);
            }
            let stdin = io::stdin();
            let mut string = String::new();
            let Ok(size) = stdin.read_line(&mut string) else {
                eprintln!("Input error");
                return StepAction::Continue;
            };
            if size == 0 {
                return StepAction::Continue;
            }
            match unsafe { string.chars().next().unwrap_unchecked() } {
                'r' => return StepAction::Reverse,
                'q' => return StepAction::Quit,
                's' => return StepAction::Save,
                _ => (),
            }
            match usize::from_str(&string[..(string.len() - 1)]) {
                Ok(num) if num != 0 && num <= fire.callables.len() => {
                    fire.call(num - 1);
                }
                _ => {
                    println!(
                        "You have to input a valid number from 1 to {}",
                        fire.callables.len()
                    );
                    println!("You can also quit by writing \"q\", save the current state by writing \"s\" or reverse by writing \"r\"");
                    return StepAction::Continue;
                }
            }

            StepAction::Continue
        }

        loop {
            let step_action = if forward {
                step(simulation.prepare_call(), &names)
            } else {
                step(simulation.prepare_revert(), &names)
            };

            use StepAction::*;
            match step_action {
                Continue => (),
                Reverse => {
                    println!("Reverse play direction!");
                    forward = !forward;
                }
                Save => {
                    fn save(data: &[usize], filename: &Path) -> std::io::Result<()> {
                        let mut file = File::create(filename)?;
                        for &count in data {
                            file.write_all(&(count as u32).to_le_bytes())?;
                        }

                        Ok(())
                    }

                    let data = simulation.data();

                    println!(
                        "{}",
                        if save(data, "examples/example.pns".as_ref()).is_ok() {
                            "Saving successful"
                        } else {
                            "Saving failed"
                        }
                    );
                }
                Quit => break,
            }
        }
    }

    ExitCode::SUCCESS
}

pub fn transition(&self, tid: Id<Transition>) -> &Node<Id<Place>>

A node representing a transition of the petri net.

pub fn reusable_transition(&self) -> Option<Id<Transition>>

Returns the index of the next reusable transition.

pub fn place_count(&self) -> usize

The count of places of the petri net.

pub fn place_ids(&self) -> Ids<Place>

An iterator over the ids of existing places.

pub fn place(&self, pid: Id<Place>) -> &Node<Id<Transition>>

A node representing a place of the petri net.

pub fn reusable_place(&self) -> Option<Id<Place>>

Returns the index of the next reusable place.

pub fn initial_token_count(&self, pid: Id<Place>) -> usize

The initial token count for a place of the petri net.

pub fn add_place(&mut self) -> Id<Place>

Add a new place to the petri net and get the index.

pub fn add_transition(&mut self) -> Id<Transition>

Add a new transition to the petri net and get the index.

pub fn remove_place(&mut self, pid: Id<Place>)

Remove a place at index pid from petri net.

pub fn remove_transition(&mut self, tid: Id<Transition>)

Remove a transition at index tid from petri net.

pub fn connect_place_to_transition( &mut self, pid: Id<Place>, tid: Id<Transition>, ) -> bool

Make a connection in to the transition with index tid from place with index pid. Result represents success.

pub fn connect_transition_to_place( &mut self, tid: Id<Transition>, pid: Id<Place>, ) -> bool

Make a connection out from the transition with index tid to place with index pid. Result represents success.

pub fn disconnect_place_to_transition( &mut self, pid: Id<Place>, tid: Id<Transition>, )

Remove the connection in to transition with index tid from place with index pid.

pub fn disconnect_transition_to_place( &mut self, tid: Id<Transition>, pid: Id<Place>, )

Remove the connection out from transition with index tid to place with index pid.

pub fn add_initial_tokens(&mut self, pid: Id<Place>, count: usize) -> usize

Increase the initial token count in place indexed by pid.

pub fn add_connected_place( &mut self, in_tids: &[Id<Transition>], out_tids: &[Id<Transition>], ) -> Id<Place>

Add a new place to the petri net, connct it to the specified transitions and get the index.

pub fn add_connected_transition( &mut self, in_pids: &[Id<Place>], out_pids: &[Id<Place>], ) -> Id<Transition>

Add a new transition to the petri net, connct it to the specified places and get the index.

pub fn duplicate_place(&mut self, pid: Id<Place>) -> Id<Place>

Duplicate the place and get the index of the clone.

pub fn duplicate_transition(&mut self, tid: Id<Transition>) -> Id<Transition>

Duplicate the transition and get the index of the clone.

Trait Implementations

impl Deref for PetriNetInfo

type Target = Net

The resulting type after dereferencing.

fn deref(&self) -> &Net

Dereferences the value.

impl DerefMut for PetriNetInfo

fn deref_mut(&mut self) -> &mut Net

Mutably dereferences the value.

impl EditableSimulationInfo for PetriNetInfo

type Edit<'a> = EditNet<'a>

The type used for safe edits.

unsafe fn edit(&mut self) -> EditNet<'_>

Creates a type which allows safe edits to the info without invalidating the states.

unsafe fn refresh_state(&self, state: &mut Self::State)

Refreshes the provided mutable state, assuming it is compatible with this SimulationInfo instance.

impl From<Net> for PetriNetInfo

fn from(net: Net) -> Self

Converts to this type from the input type.

impl From<PetriNetInfo> for Net

fn from(val: PetriNetInfo) -> Self

Converts to this type from the input type.

impl SimulationInfo for PetriNetInfo

type StateLoadingError = StateInitializationError

The error type returned when loading the simulation state fails.

type State = State

The type of the simulation state.

type AccessData = [usize]

The type used to access the current state.

type LoadData = Vec<u32>

The type of data used to load the simulation state.

type Event = Id<Transition>

The type of events that can be called or reverted in the simulation.

type EventContainer<'a> = TransitionView<'a>

The type of container used to access the available events.

fn default_state(&self) -> State

Creates a new default state compatible with this SimulationInfo instance.

fn load_state(&self, data: Vec<u32>) -> Result<State, StateInitializationError>

Loads a state from the provided data, returning a Result with the loaded state or an error.

unsafe fn clone_state(&self, state: &State) -> State

Clones the provided state, assuming it is compatible with this SimulationInfo instance.

unsafe fn data<'a>(&self, state: &'a State) -> &'a [usize]

Returns a reference to the data which repsesents the state.

fn callables(state: &State) -> TransitionView<'_>

Returns the events that can be called for the provided state.

fn callable(state: &State, tid: Tid) -> bool

Checks if the provided event can be called for the given state.

unsafe fn call(&self, state: &mut State, tid: Tid)

Calls the provided event on the given mutable state.

fn revertables(state: &State) -> TransitionView<'_>

Returns the events that can be reverted for the provided state.

fn revertable(state: &State, tid: Tid) -> bool

Checks if the provided event can be reverted for the given state.

unsafe fn revert(&self, state: &mut State, tid: Tid)

Reverts the provided event on the given mutable state.