Enum pns::DynamicNet
source · pub enum DynamicNet {
Default(Net),
Simulated(SimulatedNet),
}
Expand description
A dynamic type, able to store both net kinds.
Variants§
Default(Net)
Variant for the default Net
type.
Simulated(SimulatedNet)
Variant for the SimulatedNet
type.
Implementations§
source§impl DynamicNet
impl DynamicNet
sourcepub fn default_mut(&mut self) -> Option<&mut Net>
pub fn default_mut(&mut self) -> Option<&mut Net>
Convert the dynamic net into a mutable Net
sourcepub fn simulated(&self) -> Option<&SimulatedNet>
pub fn simulated(&self) -> Option<&SimulatedNet>
Convert the dynamic net into a SimulatedNet
sourcepub fn simulated_mut(&mut self) -> Option<&mut SimulatedNet>
pub fn simulated_mut(&mut self) -> Option<&mut SimulatedNet>
Convert the dynamic net into a mutable SimulatedNet
sourcepub fn add_place(&mut self) -> Pid
pub fn add_place(&mut self) -> Pid
Add a new place to the petri net and get the index and refresh states if necessary.
sourcepub fn add_transition(&mut self) -> Tid
pub fn add_transition(&mut self) -> Tid
Add a new transition to the petri net and get the index and refresh states if necessary.
sourcepub fn add_connected_transition(
&mut self,
in_pids: &[Pid],
out_pids: &[Pid],
) -> Tid
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 if necessary.
sourcepub fn remove_place(&mut self, pid: Pid)
pub fn remove_place(&mut self, pid: Pid)
Remove a place at index pid
from petri net and refresh states if necessary.
sourcepub fn connect_in(&mut self, tid: Tid, pid: Pid) -> bool
pub fn connect_in(&mut self, tid: Tid, pid: Pid) -> bool
Make a connection in to the transition with index tid
from place with index pid
and refresh states if necessary.
Result represents success.
sourcepub fn connect_out(&mut self, tid: Tid, pid: Pid) -> bool
pub fn connect_out(&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 if necessary.
Result represents success.
sourcepub fn duplicate_transition(&mut self, tid: Tid) -> Tid
pub fn duplicate_transition(&mut self, tid: Tid) -> Tid
Duplicate the transition and get the index of the clone and refresh states if necessary.
sourcepub fn duplicate_place(&mut self, pid: Pid) -> Pid
pub fn duplicate_place(&mut self, pid: Pid) -> Pid
Duplicate the place and get the index of the clone and refresh states if necessary.
Methods from Deref<Target = Net>§
sourcepub fn save(&self, filename: &Path) -> Result<(), Error>
pub fn save(&self, filename: &Path) -> Result<(), Error>
Save the petri net to a file. Result represents success.
Examples found in repository?
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
fn main() -> Result<(), Error> {
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 mut net = SimulatedNet::load("pns/examples/example.pn".as_ref())?;
let mut names = HashMap::new();
let file = File::open("pns/examples/example.pnk")?;
for (tid, line) in net.transition_ids().zip(BufReader::new(file).lines()) {
names.insert(tid, line?);
}
if save {
net.save("examples/example_copy.pn".as_ref())?;
}
if load {
net.load_state("examples/example.pns".as_ref())
.expect("State initialization failed");
} else {
net.add_state();
}
let mut forward = true;
for mut state in &mut net {
loop {
let fire = if forward {
state.fire()
} else {
state.unfire()
};
if fire.transitions.is_empty() {
println!("Reverse play direction!");
forward = !forward;
continue;
}
for (i, tid) in fire.transitions.iter().enumerate() {
println!("{}: {}", i + 1, names[tid]);
}
let stdin = io::stdin();
let mut string = String::new();
let size = stdin.read_line(&mut string)?;
if size == 0 {
continue;
}
match string.chars().next().unwrap() {
'r' => {
println!("Reverse play direction!");
forward = !forward;
continue;
}
'q' => break,
's' => {
println!(
"{}",
if state.save("examples/example.pns".as_ref()).is_ok() {
"Saving successful"
} else {
"Saving failed"
}
);
continue;
}
_ => (),
}
match usize::from_str(&string[..(string.len() - 1)]) {
Ok(num) if num != 0 && num <= fire.transitions.len() => {
fire.finish(num - 1);
}
_ => {
println!(
"You have to input a valid number from 1 to {}",
fire.transitions.len()
);
println!("You can also quit by writing \"q\", save the current state by writing \"s\" or reverse by writing \"r\"");
continue;
}
}
}
}
Ok(())
}
sourcepub fn transition_count(&self) -> usize
pub fn transition_count(&self) -> usize
The count of transitions of the petri net.
sourcepub fn transition_ids(&self) -> Ids<Transition>
pub fn transition_ids(&self) -> Ids<Transition>
An iterator over the ids of existing transitions.
Examples found in repository?
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
fn main() -> Result<(), Error> {
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 mut net = SimulatedNet::load("pns/examples/example.pn".as_ref())?;
let mut names = HashMap::new();
let file = File::open("pns/examples/example.pnk")?;
for (tid, line) in net.transition_ids().zip(BufReader::new(file).lines()) {
names.insert(tid, line?);
}
if save {
net.save("examples/example_copy.pn".as_ref())?;
}
if load {
net.load_state("examples/example.pns".as_ref())
.expect("State initialization failed");
} else {
net.add_state();
}
let mut forward = true;
for mut state in &mut net {
loop {
let fire = if forward {
state.fire()
} else {
state.unfire()
};
if fire.transitions.is_empty() {
println!("Reverse play direction!");
forward = !forward;
continue;
}
for (i, tid) in fire.transitions.iter().enumerate() {
println!("{}: {}", i + 1, names[tid]);
}
let stdin = io::stdin();
let mut string = String::new();
let size = stdin.read_line(&mut string)?;
if size == 0 {
continue;
}
match string.chars().next().unwrap() {
'r' => {
println!("Reverse play direction!");
forward = !forward;
continue;
}
'q' => break,
's' => {
println!(
"{}",
if state.save("examples/example.pns".as_ref()).is_ok() {
"Saving successful"
} else {
"Saving failed"
}
);
continue;
}
_ => (),
}
match usize::from_str(&string[..(string.len() - 1)]) {
Ok(num) if num != 0 && num <= fire.transitions.len() => {
fire.finish(num - 1);
}
_ => {
println!(
"You have to input a valid number from 1 to {}",
fire.transitions.len()
);
println!("You can also quit by writing \"q\", save the current state by writing \"s\" or reverse by writing \"r\"");
continue;
}
}
}
}
Ok(())
}
sourcepub fn transition(&self, tid: Tid) -> &Node<Pid>
pub fn transition(&self, tid: Tid) -> &Node<Pid>
A node representing a transition of the petri net.
sourcepub fn reusable_transition(&self) -> Option<Tid>
pub fn reusable_transition(&self) -> Option<Tid>
Returns the index of the next reusable transition.
sourcepub fn place_count(&self) -> usize
pub fn place_count(&self) -> usize
The count of places of the petri net.
sourcepub fn reusable_place(&self) -> Option<Pid>
pub fn reusable_place(&self) -> Option<Pid>
Returns the index of the next reusable place.
sourcepub fn initial_token_count(&self, pid: Pid) -> usize
pub fn initial_token_count(&self, pid: Pid) -> usize
The initial token count for a place of the petri net.