Struct EditNet

Source

pub struct EditNet<'a> { /* private fields */ }

Expand description

A wrapper type for net which only supports safe edits.

Implementations§

Source §

impl EditNet<'_>

Source

pub fn add_place(&mut self) -> Pid

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

Source

pub fn add_transition(&mut self) -> Tid

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

Source

pub fn add_connected_transition( &mut self, in_pids: &[Pid], out_pids: &[Pid], ) -> Tid

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

Source

pub fn remove_place(&mut self, pid: Pid)

Remove a place at index pid from petri net and refresh states.

Source

pub fn connect_place_to_transition(&mut self, pid: Pid, tid: Tid) -> bool

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

Source

pub fn connect_transition_to_place(&mut self, tid: Tid, pid: Pid) -> bool

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

Source

pub fn duplicate_transition(&mut self, tid: Tid) -> Tid

Duplicate the transition and get the index of the clone and refresh states.

Source

pub fn duplicate_place(&mut self, pid: Pid) -> Pid

Duplicate the place and get the index of the clone and refresh states.

Source

pub fn add_initial_tokens(&mut self, pid: Pid, count: usize) -> usize

Increase the initial token count in place indexed by pid and refresh states.

Methods from Deref<Target = Net>§

Source

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)

14fn main() -> ExitCode {
15    let mut save = false;
16    let mut load = false;
17
18    let mut args = std::env::args();
19    args.next();
20    for arg in args {
21        match arg.as_ref() {
22            "save" => save = true,
23            "load" => load = true,
24            _ => eprintln!("Ignore invalid argument '{arg}'"),
25        }
26    }
27
28    let Ok(net) = Net::load("examples/example.pn".as_ref()) else {
29        eprintln!("Failed to load example net");
30        return ExitCode::FAILURE;
31    };
32    let mut net = MultiPetriNetSimulation::new(net);
33
34    let mut names = HashMap::new();
35    let Ok(file) = File::open("examples/example.pnk") else {
36        eprintln!("Failed to load example keys");
37        return ExitCode::FAILURE;
38    };
39    for (tid, line) in net.transition_ids().zip(BufReader::new(file).lines()) {
40        let Ok(line) = line else {
41            eprintln!("Failed to read key");
42            return ExitCode::FAILURE;
43        };
44        names.insert(tid, line);
45    }
46
47    if save && net.save("examples/example_copy.pns".as_ref()).is_err() {
48        eprintln!("Failed to save example net");
49    }
50
51    if load {
52        fn read_values(filename: &Path) -> std::io::Result<Vec<u32>> {
53            let size = (std::fs::metadata(filename)?.len() + 3) / 4;
54
55            let mut file = File::open(filename)?;
56
57            (0..size)
58                .map(|_| {
59                    let mut value = [0; 4];
60                    file.read_exact(&mut value)?;
61                    Ok(u32::from_le_bytes(value))
62                })
63                .collect()
64        }
65
66        let Ok(data) = read_values("examples/example.pns".as_ref()) else {
67            eprintln!("Reading state data failed");
68            return ExitCode::FAILURE;
69        };
70
71        if net.add_simulation_from_data(data).is_err() {
72            eprintln!("State initialization failed");
73            return ExitCode::FAILURE;
74        }
75    } else {
76        net.add_simulation();
77    }
78
79    enum StepAction {
80        Continue,
81        Reverse,
82        Save,
83        Quit,
84    }
85
86    let mut forward = true;
87    for mut simulation in &mut net {
88        fn step<D: PlayDirection>(
89            fire: CallState<PetriNetSimulationBorrowMut, D>,
90            names: &HashMap<Tid, String>,
91        ) -> StepAction {
92            if fire.callables.is_empty() {
93                return StepAction::Reverse;
94            }
95
96            for (i, tid) in fire.callables.iter().enumerate() {
97                println!("{}: {}", i + 1, names[tid]);
98            }
99            let stdin = io::stdin();
100            let mut string = String::new();
101            let Ok(size) = stdin.read_line(&mut string) else {
102                eprintln!("Input error");
103                return StepAction::Continue;
104            };
105            if size == 0 {
106                return StepAction::Continue;
107            }
108            match unsafe { string.chars().next().unwrap_unchecked() } {
109                'r' => return StepAction::Reverse,
110                'q' => return StepAction::Quit,
111                's' => return StepAction::Save,
112                _ => (),
113            }
114            match usize::from_str(&string[..(string.len() - 1)]) {
115                Ok(num) if num != 0 && num <= fire.callables.len() => {
116                    fire.call(num - 1);
117                }
118                _ => {
119                    println!(
120                        "You have to input a valid number from 1 to {}",
121                        fire.callables.len()
122                    );
123                    println!("You can also quit by writing \"q\", save the current state by writing \"s\" or reverse by writing \"r\"");
124                    return StepAction::Continue;
125                }
126            }
127
128            StepAction::Continue
129        }
130
131        loop {
132            let step_action = if forward {
133                step(simulation.prepare_call(), &names)
134            } else {
135                step(simulation.prepare_revert(), &names)
136            };
137
138            use StepAction::*;
139            match step_action {
140                Continue => (),
141                Reverse => {
142                    println!("Reverse play direction!");
143                    forward = !forward;
144                }
145                Save => {
146                    fn save(data: &[usize], filename: &Path) -> std::io::Result<()> {
147                        let mut file = File::create(filename)?;
148                        for &count in data {
149                            file.write_all(&(count as u32).to_le_bytes())?;
150                        }
151
152                        Ok(())
153                    }
154
155                    let data = simulation.data();
156
157                    println!(
158                        "{}",
159                        if save(data, "examples/example.pns".as_ref()).is_ok() {
160                            "Saving successful"
161                        } else {
162                            "Saving failed"
163                        }
164                    );
165                }
166                Quit => break,
167            }
168        }
169    }
170
171    ExitCode::SUCCESS
172}

Source

pub fn transition_count(&self) -> usize

The count of transitions of the petri net.

Source

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

An iterator over the ids of existing transitions.

Examples found in repository ?

examples/example.rs (line 39)

14fn main() -> ExitCode {
15    let mut save = false;
16    let mut load = false;
17
18    let mut args = std::env::args();
19    args.next();
20    for arg in args {
21        match arg.as_ref() {
22            "save" => save = true,
23            "load" => load = true,
24            _ => eprintln!("Ignore invalid argument '{arg}'"),
25        }
26    }
27
28    let Ok(net) = Net::load("examples/example.pn".as_ref()) else {
29        eprintln!("Failed to load example net");
30        return ExitCode::FAILURE;
31    };
32    let mut net = MultiPetriNetSimulation::new(net);
33
34    let mut names = HashMap::new();
35    let Ok(file) = File::open("examples/example.pnk") else {
36        eprintln!("Failed to load example keys");
37        return ExitCode::FAILURE;
38    };
39    for (tid, line) in net.transition_ids().zip(BufReader::new(file).lines()) {
40        let Ok(line) = line else {
41            eprintln!("Failed to read key");
42            return ExitCode::FAILURE;
43        };
44        names.insert(tid, line);
45    }
46
47    if save && net.save("examples/example_copy.pns".as_ref()).is_err() {
48        eprintln!("Failed to save example net");
49    }
50
51    if load {
52        fn read_values(filename: &Path) -> std::io::Result<Vec<u32>> {
53            let size = (std::fs::metadata(filename)?.len() + 3) / 4;
54
55            let mut file = File::open(filename)?;
56
57            (0..size)
58                .map(|_| {
59                    let mut value = [0; 4];
60                    file.read_exact(&mut value)?;
61                    Ok(u32::from_le_bytes(value))
62                })
63                .collect()
64        }
65
66        let Ok(data) = read_values("examples/example.pns".as_ref()) else {
67            eprintln!("Reading state data failed");
68            return ExitCode::FAILURE;
69        };
70
71        if net.add_simulation_from_data(data).is_err() {
72            eprintln!("State initialization failed");
73            return ExitCode::FAILURE;
74        }
75    } else {
76        net.add_simulation();
77    }
78
79    enum StepAction {
80        Continue,
81        Reverse,
82        Save,
83        Quit,
84    }
85
86    let mut forward = true;
87    for mut simulation in &mut net {
88        fn step<D: PlayDirection>(
89            fire: CallState<PetriNetSimulationBorrowMut, D>,
90            names: &HashMap<Tid, String>,
91        ) -> StepAction {
92            if fire.callables.is_empty() {
93                return StepAction::Reverse;
94            }
95
96            for (i, tid) in fire.callables.iter().enumerate() {
97                println!("{}: {}", i + 1, names[tid]);
98            }
99            let stdin = io::stdin();
100            let mut string = String::new();
101            let Ok(size) = stdin.read_line(&mut string) else {
102                eprintln!("Input error");
103                return StepAction::Continue;
104            };
105            if size == 0 {
106                return StepAction::Continue;
107            }
108            match unsafe { string.chars().next().unwrap_unchecked() } {
109                'r' => return StepAction::Reverse,
110                'q' => return StepAction::Quit,
111                's' => return StepAction::Save,
112                _ => (),
113            }
114            match usize::from_str(&string[..(string.len() - 1)]) {
115                Ok(num) if num != 0 && num <= fire.callables.len() => {
116                    fire.call(num - 1);
117                }
118                _ => {
119                    println!(
120                        "You have to input a valid number from 1 to {}",
121                        fire.callables.len()
122                    );
123                    println!("You can also quit by writing \"q\", save the current state by writing \"s\" or reverse by writing \"r\"");
124                    return StepAction::Continue;
125                }
126            }
127
128            StepAction::Continue
129        }
130
131        loop {
132            let step_action = if forward {
133                step(simulation.prepare_call(), &names)
134            } else {
135                step(simulation.prepare_revert(), &names)
136            };
137
138            use StepAction::*;
139            match step_action {
140                Continue => (),
141                Reverse => {
142                    println!("Reverse play direction!");
143                    forward = !forward;
144                }
145                Save => {
146                    fn save(data: &[usize], filename: &Path) -> std::io::Result<()> {
147                        let mut file = File::create(filename)?;
148                        for &count in data {
149                            file.write_all(&(count as u32).to_le_bytes())?;
150                        }
151
152                        Ok(())
153                    }
154
155                    let data = simulation.data();
156
157                    println!(
158                        "{}",
159                        if save(data, "examples/example.pns".as_ref()).is_ok() {
160                            "Saving successful"
161                        } else {
162                            "Saving failed"
163                        }
164                    );
165                }
166                Quit => break,
167            }
168        }
169    }
170
171    ExitCode::SUCCESS
172}