implement StreamingIteratorExt for iterator types

5 files changed, 65 insertions, 49 deletions

diff --git a/src/lib.rs b/src/lib.rs
index d8f72d3..80916e2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,16 +21,16 @@ mod tags;
 mod thread;
 mod threads;
 
-pub use database::Database;
-pub use directory::Directory;
+pub use database::{Database, DatabaseExt};
+pub use directory::{Directory, DirectoryExt};
 pub use error::Error;
 pub use filenames::{Filenames, FilenamesOwner};
-pub use message::{Message, MessageOwner};
-pub use messages::{Messages, MessagesOwner};
+pub use message::{Message, MessageExt, MessageOwner};
+pub use messages::{Messages, MessagesExt, MessagesOwner};
 pub use query::{Query, QueryExt};
-pub use tags::{Tags, TagsOwner};
-pub use thread::{Thread, ThreadOwner};
-pub use threads::{Threads, ThreadsOwner};
+pub use tags::{Tags, TagsExt, TagsOwner};
+pub use thread::{Thread, ThreadExt, ThreadOwner};
+pub use threads::{Threads, ThreadsExt, ThreadsOwner};
 
 pub use ffi::{DatabaseMode, Sort};
-pub use utils::StreamingIterator;
+pub use utils::{StreamingIterator, StreamingIteratorExt};
diff --git a/src/messages.rs b/src/messages.rs
index 7aa1c45..7a0a48c 100644
--- a/src/messages.rs
+++ b/src/messages.rs
@@ -3,7 +3,7 @@ use std::ops::Drop;
 use supercow::{Phantomcow, Supercow};
 
 use ffi;
-use utils::StreamingIterator;
+use utils::{StreamingIterator, StreamingIteratorExt};
 use Message;
 use MessageOwner;
 use Tags;
@@ -56,15 +56,6 @@ impl<'o, Owner: MessagesOwner + 'o> Messages<'o, Owner> {
     }
 }
 
-
-pub trait MessagesExt<'o, Owner: MessagesOwner + 'o>{
-
-}
-
-impl<'o, Owner: MessagesOwner + 'o> MessagesExt<'o, Owner> for Messages<'o, Owner>{
-    
-}
-
 impl<'o, Owner: MessagesOwner + 'o> MessageOwner for Messages<'o, Owner> {}
 impl<'o, Owner: MessagesOwner + 'o> TagsOwner for Messages<'o, Owner> {}
 
@@ -94,19 +85,35 @@ impl<'s, 'o: 's, Owner: MessagesOwner + 'o> StreamingIterator<'s, Message<'s, Se
     for Messages<'o, Owner>
 {
     fn next(&'s mut self) -> Option<Message<'s, Self>> {
-        let valid = unsafe { ffi::notmuch_messages_valid(self.handle.ptr) };
+        <Self as StreamingIteratorExt<'s, Message<'s, Self>>>::next(Supercow::borrowed(self))
+    }
+}
+
+pub trait MessagesExt<'o, Owner: MessagesOwner + 'o> {
+
+}
+
+impl<'o, Owner: MessagesOwner + 'o> MessagesExt<'o, Owner> for Messages<'o, Owner>{
+    
+}
+
+impl<'s, 'o: 's, Owner: MessagesOwner + 'o> StreamingIteratorExt<'s, Message<'s, Self>> for Messages<'o, Owner>
+{
+    fn next<S: Into<Supercow<'s, Messages<'o, Owner>>>>(messages: S) -> Option<Message<'s, Self>>{
+        let messagesref = messages.into();
+        let valid = unsafe { ffi::notmuch_messages_valid(messagesref.handle.ptr) };
 
         if valid == 0 {
             return None;
         }
 
         let cmsg = unsafe {
-            let msg = ffi::notmuch_messages_get(self.handle.ptr);
-            ffi::notmuch_messages_move_to_next(self.handle.ptr);
+            let msg = ffi::notmuch_messages_get(messagesref.handle.ptr);
+            ffi::notmuch_messages_move_to_next(messagesref.handle.ptr);
             msg
         };
 
-        Some(Message::from_ptr(cmsg, Supercow::borrowed(self)))
+        Some(Message::from_ptr(cmsg, Supercow::phantom(messagesref)))
     }
 }
 
diff --git a/src/threads.rs b/src/threads.rs
index 54b49a9..5083f87 100644
--- a/src/threads.rs
+++ b/src/threads.rs
@@ -1,7 +1,7 @@
 use std::ops::Drop;
 
 use supercow::{Phantomcow, Supercow};
-use utils::StreamingIterator;
+use utils::{StreamingIterator, StreamingIteratorExt};
 
 use ffi;
 use thread::ThreadOwner;
@@ -38,34 +38,13 @@ impl<'o, Owner: ThreadsOwner + 'o> Threads<'o, Owner> {
             marker: owner.into(),
         }
     }
-    pub(crate) fn from_handle<O: Into<Phantomcow<'o, Owner>>>(
-        handle: ThreadsPtr,
-        owner: O,
-    ) -> Threads<'o, Owner> {
-        Threads {
-            handle,
-            marker: owner.into(),
-        }
-    }
 }
 
 impl<'s, 'o: 's, Owner: ThreadsOwner + 'o> StreamingIterator<'s, Thread<'s, Self>>
     for Threads<'o, Owner>
 {
     fn next(&'s mut self) -> Option<Thread<'s, Self>> {
-        let valid = unsafe { ffi::notmuch_threads_valid(self.handle.ptr) };
-
-        if valid == 0 {
-            return None;
-        }
-
-        let cthread = unsafe {
-            let t = ffi::notmuch_threads_get(self.handle.ptr);
-            ffi::notmuch_threads_move_to_next(self.handle.ptr);
-            t
-        };
-
-        Some(Thread::from_ptr(cthread, Supercow::borrowed(self)))
+        <Self as StreamingIteratorExt<'s, Thread<'s, Self>>>::next(Supercow::borrowed(self))
     }
 }
 
@@ -77,5 +56,25 @@ impl<'o, Owner: ThreadsOwner + 'o> ThreadsExt<'o, Owner> for Threads<'o, Owner>{
     
 }
 
+impl<'s, 'o: 's, Owner: ThreadsOwner + 'o> StreamingIteratorExt<'s, Thread<'s, Self>> for Threads<'o, Owner>
+{
+    fn next<S: Into<Supercow<'s, Threads<'o, Owner>>>>(threads: S) -> Option<Thread<'s, Self>>{
+        let threadsref = threads.into();
+        let valid = unsafe { ffi::notmuch_threads_valid(threadsref.handle.ptr) };
+
+        if valid == 0 {
+            return None;
+        }
+
+        let cmsg = unsafe {
+            let msg = ffi::notmuch_threads_get(threadsref.handle.ptr);
+            ffi::notmuch_threads_move_to_next(threadsref.handle.ptr);
+            msg
+        };
+
+        Some(Thread::from_ptr(cmsg, Supercow::phantom(threadsref)))
+    }
+}
+
 unsafe impl<'o, Owner: ThreadsOwner + 'o> Send for Threads<'o, Owner> {}
 unsafe impl<'o, Owner: ThreadsOwner + 'o> Sync for Threads<'o, Owner> {}
diff --git a/src/utils.rs b/src/utils.rs
index 5cce04d..def8d93 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,6 +1,8 @@
 use libc;
 use std::{ffi, str};
 
+use supercow::Supercow;
+
 pub trait ToStr {
     fn to_str<'a>(&self) -> Result<&'a str, str::Utf8Error>;
 }
@@ -27,3 +29,11 @@ pub trait StreamingIterator<'a, T> {
     /// have been consumed.
     fn next(&'a mut self) -> Option<T>;
 }
+
+pub trait StreamingIteratorExt<'a, T> {
+    /// Return either the next item in the sequence, or `None` if all items
+    /// have been consumed.
+    fn next<S: Into<Supercow<'a, Self>>>(s: S) -> Option<T>
+      where Self: Sized + 'a;
+}
+
diff --git a/tests/main.rs b/tests/main.rs
index 11723b2..512aa84 100644
--- a/tests/main.rs
+++ b/tests/main.rs
@@ -3,8 +3,8 @@ extern crate dirs;
 
 use std::sync::Arc;
 
-use notmuch::StreamingIterator;
-use notmuch::{Query, QueryExt};
+use notmuch::{StreamingIterator, StreamingIteratorExt};
+use notmuch::{Threads, Thread, Query, QueryExt};
 
 fn main() {
 
@@ -32,10 +32,10 @@ fn main() {
             
             // let mut threads = db.create_query(&"".to_string()).unwrap().search_threads().unwrap();
 
-            let mut threads = <Query as QueryExt>::search_threads(query).unwrap();
+            let threads = Arc::new(<Query as QueryExt>::search_threads(query).unwrap());
 
 
-            while let Some(thread) = threads.next() {
+            while let Some(thread) = <Threads<Query> as StreamingIteratorExt<Thread<Threads<Query>>>>::next(threads.clone()) {
                 println!("thread {:?} {:?}", thread.subject(), thread.authors());
             }