reorganize module

_archive/rhai_engine/rhaiexamples/pause_and_resume.rs

@@ -0,0 +1,112 @@
+//! An advanced example showing how to pause/resume/stop an `Engine` via an MPSC channel.
+
+#[cfg(feature = "unchecked")]
+fn main() {
+    panic!("This example does not run under 'unchecked'.");
+}
+
+use rhai::{Dynamic, Engine};
+
+#[cfg(feature = "sync")]
+use std::sync::Mutex;
+
+#[cfg(not(feature = "unchecked"))]
+fn main() {
+    let (tx, rx) = std::sync::mpsc::channel::<String>();
+
+    #[cfg(feature = "sync")]
+    let rx = Mutex::new(rx);
+
+    // Spawn thread with Engine, capturing the channel
+    std::thread::spawn(move || {
+        // Create Engine
+        let mut engine = Engine::new();
+
+        engine.on_progress(move |_ops| {
+            #[cfg(feature = "sync")]
+            if _ops % 5 != 0 {
+                return None;
+            }
+
+            #[cfg(feature = "sync")]
+            let rx = &*rx.lock().unwrap();
+
+            let mut paused = false;
+
+            loop {
+                match rx.try_recv() {
+                    Ok(cmd) => match cmd.as_str() {
+                        "pause" => {
+                            println!("[Thread] Script paused. Type 'resume' to continue or 'stop' to terminate.");
+                            paused = true;
+                        }
+                        "resume" => {
+                            println!("[Thread] Resuming script...");
+                            return None;
+                        }
+                        "stop" => {
+                            println!("[Thread] Stopping script...");
+                            return Some(Dynamic::UNIT);
+                        }
+                        cmd if paused => {
+                            println!("[Thread] I don't understand '{cmd}'!");
+                            println!("Type 'resume' to continue script, or 'stop' to terminate!");
+                        }
+                        _ => {
+                            println!("[Thread] I don't understand '{cmd}'!");
+                            return None;
+                        }
+                    },
+                    Err(_) if paused => (),
+                    Err(_) => return None,
+                }
+
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            }
+        });
+
+        // Run script
+        let _ = engine
+            .run(
+                r#"
+                    let counter = 0;
+
+                    loop {
+                        print("[Script] One Potato...");
+                        sleep(1);
+
+                        counter += 1;
+
+                        print("[Script] Two Potatoes...");
+                        sleep(1);
+
+                        print(`[Script] Boring Counter: ${counter}...`);
+                        sleep(1);
+
+                        print("[Script] Three Potatoes...");
+                        sleep(1);
+                    }
+                "#,
+            )
+            .expect_err("Error expected");
+
+        println!("[Thread] Script stopped!");
+    });
+
+    println!("[Main] Type 'pause' or 'stop' to control the script.");
+
+    let mut input = String::new();
+
+    loop {
+        input.clear();
+
+        match std::io::stdin().read_line(&mut input) {
+            Ok(0) => (),
+            Ok(_) => match tx.send(input.trim().to_string()) {
+                Ok(_) => (),
+                Err(_) => break,
+            },
+            Err(_) => break,
+        }
+    }
+}