add new context.rs to separate the code a little

waku-bindings/src/node/context.rs

@@ -0,0 +1,48 @@
+use std::ffi::c_void;
+use std::sync::{Arc, Mutex};
+
+use crate::utils::{get_trampoline, LibwakuResponse};
+
+pub struct WakuNodeContext {
+    obj_ptr: *mut c_void,
+    msg_observer: Arc<Mutex<Box<dyn FnMut(LibwakuResponse) + Send + Sync>>>,
+}
+
+impl WakuNodeContext {
+    pub fn new(obj_ptr: *mut c_void) -> Self {
+        Self {
+            obj_ptr: obj_ptr,
+            msg_observer: Arc::new(Mutex::new(Box::new(|_response| {
+                println!("msg observer not set")
+            }))),
+        }
+    }
+
+    pub fn get_ptr(&self) -> *mut c_void {
+        self.obj_ptr
+    }
+
+    /// Register callback to act as event handler and receive application events,
+    /// which are used to react to asynchronous events in Waku
+    pub fn waku_set_event_callback<F: FnMut(LibwakuResponse) + 'static + Sync + Send>(
+        &self,
+        closure: F,
+    ) -> Result<(), String> {
+        if let Ok(mut boxed_closure) = self.msg_observer.lock() {
+            *boxed_closure = Box::new(closure);
+            unsafe {
+                let cb = get_trampoline(&(*boxed_closure));
+                waku_sys::waku_set_event_callback(
+                    self.obj_ptr,
+                    cb,
+                    &mut (*boxed_closure) as *mut _ as *mut c_void,
+                )
+            };
+            Ok(())
+        } else {
+            Err(format!(
+                "Failed to acquire lock in waku_set_event_callback!"
+            ))
+        }
+    }
+}

waku-bindings/src/node/events.rs

@@ -4,24 +4,14 @@
 //! An example of an asynchronous event that might be emitted is receiving a message.
 //! When an event is emitted, this callback will be triggered receiving an [`Event`]
 
-// std
-use std::ffi::c_void;
 // crates
 use serde::{Deserialize, Serialize};
 // internal
 use crate::general::WakuMessage;
 use std::str;
 
-use crate::utils::{get_trampoline, LibwakuResponse};
 use crate::MessageHash;
 
-use std::sync::{Arc, Mutex};
-
-pub struct WakuNodeContext {
-    obj_ptr: *mut c_void,
-    msg_observer: Arc<Mutex<Box<dyn FnMut(LibwakuResponse) + Send + Sync>>>,
-}
-
 /// Waku event
 /// For now just WakuMessage is supported
 #[non_exhaustive]
@@ -45,45 +35,6 @@ pub struct WakuMessageEvent {
     pub waku_message: WakuMessage,
 }
 
-impl WakuNodeContext {
-    pub fn new(obj_ptr: *mut c_void) -> Self {
-        Self {
-            obj_ptr: obj_ptr,
-            msg_observer: Arc::new(Mutex::new(Box::new(|_response| {
-                println!("msg observer not set")
-            }))),
-        }
-    }
-
-    pub fn get_ptr(&self) -> *mut c_void {
-        self.obj_ptr
-    }
-
-    /// Register callback to act as event handler and receive application events,
-    /// which are used to react to asynchronous events in Waku
-    pub fn waku_set_event_callback<F: FnMut(LibwakuResponse) + 'static + Sync + Send>(
-        &self,
-        closure: F,
-    ) -> Result<(), String> {
-        if let Ok(mut boxed_closure) = self.msg_observer.lock() {
-            *boxed_closure = Box::new(closure);
-            unsafe {
-                let cb = get_trampoline(&(*boxed_closure));
-                waku_sys::waku_set_event_callback(
-                    self.obj_ptr,
-                    cb,
-                    &mut (*boxed_closure) as *mut _ as *mut c_void,
-                )
-            };
-            Ok(())
-        } else {
-            Err(format!(
-                "Failed to acquire lock in waku_set_event_callback!"
-            ))
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::Event;

waku-bindings/src/node/filter.rs

@@ -6,7 +6,7 @@ use std::ffi::CString;
 use libc::*;
 // internal
 use crate::general::Result;
-use crate::node::events::WakuNodeContext;
+use crate::node::context::WakuNodeContext;
 use crate::utils::{get_trampoline, handle_no_response, LibwakuResponse};
 
 pub fn waku_filter_subscribe(

waku-bindings/src/node/lightpush.rs

@@ -6,7 +6,7 @@ use std::ffi::CString;
 use libc::*;
 // internal
 use crate::general::{MessageHash, Result, WakuMessage};
-use crate::node::events::WakuNodeContext;
+use crate::node::context::WakuNodeContext;
 use crate::utils::{get_trampoline, handle_response, LibwakuResponse};
 
 pub fn waku_lightpush_publish_message(

waku-bindings/src/node/management.rs

@@ -8,7 +8,7 @@ use multiaddr::Multiaddr;
 // internal
 use super::config::WakuNodeConfig;
 use crate::general::Result;
-use crate::node::events::WakuNodeContext;
+use crate::node::context::WakuNodeContext;
 use crate::utils::LibwakuResponse;
 use crate::utils::WakuDecode;
 use crate::utils::{get_trampoline, handle_json_response, handle_no_response, handle_response};

waku-bindings/src/node/mod.rs

@@ -1,6 +1,7 @@
 //! Waku node implementation
 
 mod config;
+mod context;
 mod events;
 mod filter;
 mod lightpush;
@@ -18,7 +19,8 @@ use crate::general::{MessageHash, Result, WakuMessage};
 
 pub use config::RLNConfig;
 pub use config::WakuNodeConfig;
-pub use events::{Event, WakuMessageEvent, WakuNodeContext};
+pub use context::WakuNodeContext;
+pub use events::{Event, WakuMessageEvent};
 pub use relay::waku_create_content_topic;
 
 use crate::Encoding;

waku-bindings/src/node/peers.rs

@@ -8,7 +8,7 @@ use libc::*;
 use multiaddr::Multiaddr;
 // internal
 use crate::general::Result;
-use crate::node::events::WakuNodeContext;
+use crate::node::context::WakuNodeContext;
 use crate::utils::LibwakuResponse;
 use crate::utils::{get_trampoline, handle_no_response};
 

waku-bindings/src/node/relay.rs

@@ -7,7 +7,7 @@ use std::time::Duration;
 use libc::*;
 // internal
 use crate::general::{Encoding, MessageHash, Result, WakuContentTopic, WakuMessage};
-use crate::node::events::WakuNodeContext;
+use crate::node::context::WakuNodeContext;
 use crate::utils::{get_trampoline, handle_no_response, handle_response, LibwakuResponse};
 
 /// Create a content topic according to [RFC 23](https://rfc.vac.dev/spec/23/)