default listen is changed to strong and listen_weak added for the wea…

…k version of listen

src/sodium/cell.rs

@@ -91,6 +91,13 @@ impl<A: Clone + Trace + Finalize + 'static> Cell<A> {
     ) -> Listener {
         self.impl_.listen(callback)
     }
+
+    pub fn listen_weak<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK
+    ) -> Listener {
+        self.impl_.listen_weak(callback)
+    }
 }
 
 impl<A: Clone + Trace + Finalize + 'static> Clone for Cell<A> {

src/sodium/impl_/cell.rs

@@ -408,6 +408,21 @@ impl<A: Clone + Trace + Finalize + 'static> Cell<A> {
     pub fn listen<CALLBACK:FnMut(&A)+'static>(
         &self,
         callback: CALLBACK
+    ) -> Listener {
+        self._listen(callback, false)
+    }
+
+    pub fn listen_weak<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK
+    ) -> Listener {
+        self._listen(callback, true)
+    }
+
+    pub fn _listen<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK,
+        weak: bool
     ) -> Listener {
         let sodium_ctx = self._node().sodium_ctx();
         let sodium_ctx = &sodium_ctx;
@@ -435,7 +450,7 @@ impl<A: Clone + Trace + Finalize + 'static> Cell<A> {
             vec![self._node().clone()],
             || {},
             String::from("Cell::listen_node")
-        ))
+        ), weak)
     }
 }
 

src/sodium/impl_/listener.rs

@@ -6,25 +6,35 @@ use sodium::gc::Trace;
 use std::cell::UnsafeCell;
 
 pub struct Listener {
-    node_op: Gc<UnsafeCell<Option<Node>>>
+    node_op: Gc<UnsafeCell<Option<Node>>>,
+    weak: bool
 }
 
 impl Listener {
     pub fn debug(&self) {
         self.node_op.debug();
     }
 
-    pub fn new(node: Node) -> Listener {
+    pub fn new(node: Node, weak: bool) -> Listener {
         let sodium_ctx = node.sodium_ctx();
         let mut gc_ctx = sodium_ctx.gc_ctx();
+        if !weak {
+            sodium_ctx.add_keep_alive(node.clone());
+        }
         Listener {
-            node_op: gc_ctx.new_gc_with_desc(UnsafeCell::new(Some(node)), String::from("Listener::new"))
+            node_op: gc_ctx.new_gc_with_desc(UnsafeCell::new(Some(node)), String::from("Listener::new")),
+            weak
         }
     }
 
     pub fn unlisten(&self) {
+        let weak = self.weak;
         let node_op = unsafe { &mut *(*self.node_op).get() };
         if let &mut Some(ref mut node) = node_op {
+            let sodium_ctx = node.sodium_ctx();
+            if !weak {
+                sodium_ctx.remove_keep_alive(node);
+            }
             node.remove_all_dependencies();
         }
         *node_op = None;

src/sodium/impl_/sodium_ctx.rs

@@ -2,6 +2,7 @@ use sodium::gc::Finalize;
 use sodium::gc::GcCtx;
 use sodium::gc::Trace;
 use sodium::impl_::IsLambda0;
+use sodium::impl_::Listener;
 use sodium::impl_::MemoLazy;
 use sodium::impl_::Node;
 use std::cell::UnsafeCell;
@@ -28,7 +29,8 @@ pub struct SodiumCtxData {
     pub resort_required: bool,
     pub pre_trans: Vec<Box<FnMut()>>,
     pub post_trans: Vec<Box<FnMut()>>,
-    pub node_count: u32
+    pub node_count: u32,
+    pub keep_alive: HashSet<Node>
 }
 
 impl SodiumCtx {
@@ -43,7 +45,8 @@ impl SodiumCtx {
                 resort_required: false,
                 pre_trans: Vec::new(),
                 post_trans: Vec::new(),
-                node_count: 0
+                node_count: 0,
+                keep_alive: HashSet::new()
             }))
         }
     }
@@ -72,6 +75,16 @@ impl SodiumCtx {
         id
     }
 
+    pub fn add_keep_alive(&self, node: Node) {
+        let self_ = unsafe { &mut *(*self.data).get() };
+        self_.keep_alive.insert(node);
+    }
+
+    pub fn remove_keep_alive(&self, node: &Node) {
+        let self_ = unsafe { &mut *(*self.data).get() };
+        self_.keep_alive.remove(node);
+    }
+
     pub fn inc_node_count(&self) {
         let self_ = unsafe { &mut *(*self.data).get() };
         self_.node_count = self_.node_count + 1;

src/sodium/impl_/stream.rs

@@ -451,6 +451,21 @@ impl<A: Clone + Trace + Finalize + 'static> Stream<A> {
     pub fn listen<CALLBACK:FnMut(&A)+'static>(
         &self,
         callback: CALLBACK
+    ) -> Listener {
+        self._listen(callback, false)
+    }
+
+    pub fn listen_weak<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK
+    ) -> Listener {
+        self._listen(callback, true)
+    }
+
+    pub fn _listen<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK,
+        weak: bool
     ) -> Listener {
         let sodium_ctx = self._node().sodium_ctx();
         let sodium_ctx = &sodium_ctx;
@@ -482,7 +497,7 @@ impl<A: Clone + Trace + Finalize + 'static> Stream<A> {
             vec![self._node().clone()],
             || {},
             String::from("Stream::listen_node")
-        ))
+        ), weak)
     }
 }
 

src/sodium/is_cell.rs

@@ -55,6 +55,13 @@ pub trait IsCell<A: Finalize + Trace + Clone + 'static>: Sized {
     ) -> Listener {
         self.to_cell().listen(callback)
     }
+
+    fn listen_weak<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK
+    ) -> Listener {
+        self.to_cell().listen(callback)
+    }
 }
 
 impl<A: Finalize + Trace + Clone + 'static> IsCell<A> for Cell<A> {

src/sodium/is_stream.rs

@@ -117,6 +117,13 @@ pub trait IsStream<A: Finalize + Trace + Clone + 'static> {
     ) -> Listener {
         self.to_stream().listen(callback)
     }
+
+    fn listen_weak<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK
+    ) -> Listener {
+        self.to_stream().listen_weak(callback)
+    }
 }
 
 impl<A: Finalize + Trace + Clone + 'static> IsStream<A> for Stream<A> {

src/sodium/stream.rs

@@ -133,6 +133,13 @@ impl<A: Clone + Trace + Finalize + 'static> Stream<A> {
     ) -> Listener {
         self.impl_.listen(callback)
     }
+
+    pub fn listen_weak<CALLBACK:FnMut(&A)+'static>(
+        &self,
+        callback: CALLBACK
+    ) -> Listener {
+        self.impl_.listen_weak(callback)
+    }
 }
 
 impl<A: Clone + Trace + Finalize + 'static> Clone for Stream<A> {