add rx dispatcher to examples

helix-dap/examples/dap-dlv.rs

@@ -1,7 +1,7 @@
-use helix_dap::{events, Client, Event, Result, SourceBreakpoint};
+use helix_dap::{events, Client, Payload, Result, SourceBreakpoint};
 use serde::{Deserialize, Serialize};
 use serde_json::{from_value, to_value};
-use tokio::sync::mpsc::Receiver;
+use tokio::sync::mpsc::UnboundedReceiver;
 
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -10,15 +10,26 @@ struct LaunchArguments {
     program: String,
 }
 
-async fn output(mut output_event: Receiver<Event>) {
+async fn dispatch(mut rx: UnboundedReceiver<Payload>) {
     loop {
-        let body: events::Output =
+        match rx.recv().await.unwrap() {
-            from_value(output_event.recv().await.unwrap().body.unwrap()).unwrap();
+            Payload::Event(ev) => match &ev.event[..] {
-        println!(
+                "output" => {
-            "> [{}] {}",
+                    let body: events::Output = from_value(ev.body.unwrap()).unwrap();
-            body.category.unwrap_or("unknown".to_owned()),
+                    println!(
-            body.output
+                        "> [{}] {}",
-        );
+                        body.category.unwrap_or("unknown".to_owned()),
+                        body.output
+                    );
+                }
+                "stopped" => {
+                    println!("stopped");
+                }
+                _ => {}
+            },
+            Payload::Response(_) => unreachable!(),
+            Payload::Request(_) => todo!(),
+        };
     }
 }
 
@@ -35,12 +46,11 @@ pub async fn main() -> Result<()> {
         .apply()
         .expect("Failed to set up logging");
 
-    let client = Client::tcp_process("dlv", vec!["dap"], "-l 127.0.0.1:{}", 0).await;
+    let (mut client, events) =
+        Client::tcp_process("dlv", vec!["dap"], "-l 127.0.0.1:{}", 0).await?;
     println!("create: {:?}", client);
-    let mut client = client?;
 
-    let output_event = client.listen_for_event("output".to_owned()).await;
+    tokio::spawn(dispatch(events));
-    tokio::spawn(output(output_event));
 
     println!("init: {:?}", client.initialize("go".to_owned()).await);
     println!("caps: {:?}", client.capabilities());
@@ -73,14 +83,8 @@ pub async fn main() -> Result<()> {
         .read_line(&mut _in)
         .expect("Failed to read line");
 
-    let mut stopped_event = client.listen_for_event("stopped".to_owned()).await;
-
     println!("configurationDone: {:?}", client.configuration_done().await);
 
-    let stop: events::Stopped =
-        from_value(stopped_event.recv().await.unwrap().body.unwrap()).unwrap();
-    println!("stopped: {:?}", stop);
-
     let threads = client.threads().await?;
     println!("threads: {:#?}", threads);
     let bt = client

helix-dap/examples/dap-lldb.rs

@@ -1,7 +1,7 @@
-use helix_dap::{events, Client, Event, Result, SourceBreakpoint};
+use helix_dap::{events, Client, Payload, Result, SourceBreakpoint};
 use serde::{Deserialize, Serialize};
 use serde_json::{from_value, to_value};
-use tokio::sync::mpsc::Receiver;
+use tokio::sync::mpsc::UnboundedReceiver;
 
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -10,15 +10,26 @@ struct LaunchArguments {
     console: String,
 }
 
-async fn output(mut output_event: Receiver<Event>) {
+async fn dispatch(mut rx: UnboundedReceiver<Payload>) {
     loop {
-        let body: events::Output =
+        match rx.recv().await.unwrap() {
-            from_value(output_event.recv().await.unwrap().body.unwrap()).unwrap();
+            Payload::Event(ev) => match &ev.event[..] {
-        println!(
+                "output" => {
-            "> [{}] {}",
+                    let body: events::Output = from_value(ev.body.unwrap()).unwrap();
-            body.category.unwrap_or("unknown".to_owned()),
+                    println!(
-            body.output
+                        "> [{}] {}",
-        );
+                        body.category.unwrap_or("unknown".to_owned()),
+                        body.output
+                    );
+                }
+                "stopped" => {
+                    println!("stopped");
+                }
+                _ => {}
+            },
+            Payload::Response(_) => unreachable!(),
+            Payload::Request(_) => todo!(),
+        };
     }
 }
 
@@ -35,12 +46,10 @@ pub async fn main() -> Result<()> {
         .apply()
         .expect("Failed to set up logging");
 
-    let client = Client::tcp_process("lldb-vscode", vec![], "-p {}", 0).await;
+    let (mut client, events) = Client::tcp_process("lldb-vscode", vec![], "-p {}", 0).await?;
     println!("create: {:?}", client);
-    let mut client = client?;
 
-    let output_event = client.listen_for_event("output".to_owned()).await;
+    tokio::spawn(dispatch(events));
-    tokio::spawn(output(output_event));
 
     println!("init: {:?}", client.initialize("lldb".to_owned()).await);
     println!("caps: {:?}", client.capabilities());
@@ -73,14 +82,8 @@ pub async fn main() -> Result<()> {
         .read_line(&mut _in)
         .expect("Failed to read line");
 
-    let mut stopped_event = client.listen_for_event("stopped".to_owned()).await;
-
     println!("configurationDone: {:?}", client.configuration_done().await);
 
-    let stop: events::Stopped =
-        from_value(stopped_event.recv().await.unwrap().body.unwrap()).unwrap();
-    println!("stopped: {:?}", stop);
-
     let threads = client.threads().await?;
     println!("threads: {:#?}", threads);
     let bt = client