more correct lifetimes

10 files changed, 112 insertions, 50 deletions

diff --git a/src/database.rs b/src/database.rs
index 6d98413..7a1bb63 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -14,6 +14,7 @@ use utils::{
 use Directory;
 use Query;
 use Tags;
+use tags::TagsOwner;
 
 use ffi;
 
@@ -47,6 +48,8 @@ pub struct Database{
     pub(crate) handle: DatabasePtr
 }
 
+impl TagsOwner for Database{}
+
 impl Database {
     pub fn create<P: AsRef<Path>>(path: &P) -> Result<Self> {
         let path_str = CString::new(path.as_ref().to_str().unwrap()).unwrap();
diff --git a/src/directory.rs b/src/directory.rs
index 4bf0a7a..ce219f5 100644
--- a/src/directory.rs
+++ b/src/directory.rs
@@ -5,6 +5,7 @@ use utils::FromPtr;
 
 use Database;
 use Filenames;
+use filenames::{FilenamesPtr, FilenamesOwner};
 
 use ffi;
 
@@ -21,17 +22,32 @@ impl Drop for DirectoryPtr {
     }
 }
 
+impl DirectoryPtr {
+    pub fn child_directories(self: &Self) -> FilenamesPtr{
+        FilenamesPtr{
+            ptr: unsafe {
+                ffi::notmuch_directory_get_child_directories(self.ptr)
+            }
+        }
+    }
+}
+
+
+
 #[derive(Debug)]
 pub struct Directory<'d>{
     handle: DirectoryPtr,
     phantom: PhantomData<&'d Database>,
 }
 
+impl<'d> FilenamesOwner for Directory<'d>{}
+
 impl<'d> Directory<'d>{
-    pub fn child_directories(self: &'d Self) -> Filenames<'d>{
-        Filenames::from_ptr(unsafe {
-            ffi::notmuch_directory_get_child_directories(self.handle.ptr)
-        })
+    pub fn child_directories(self: &'d Self) -> Filenames<Self>{
+        Filenames{
+            handle: self.handle.child_directories(),
+            phantom: PhantomData
+        }
     }
 }
 
diff --git a/src/filenames.rs b/src/filenames.rs
index 5f369e8..3c167df 100644
--- a/src/filenames.rs
+++ b/src/filenames.rs
@@ -8,6 +8,8 @@ use utils::FromPtr;
 use Database;
 use ffi;
 
+pub trait FilenamesOwner{}
+
 #[derive(Debug)]
 pub(crate) struct FilenamesPtr {
     pub ptr: *mut ffi::notmuch_filenames_t
@@ -28,13 +30,13 @@ impl Drop for FilenamesPtr {
 }
  
 #[derive(Debug)]
-pub struct Filenames<'d>{
+pub struct Filenames<'o, Owner: FilenamesOwner>{
     pub(crate) handle: FilenamesPtr,
-    phantom: PhantomData<&'d Database>
+    pub(crate) phantom: PhantomData<&'o Owner>
 }
 
-impl<'d> FromPtr<*mut ffi::notmuch_filenames_t> for Filenames<'d> {
-    fn from_ptr(ptr: *mut ffi::notmuch_filenames_t) -> Filenames<'d> {
+impl<'o, Owner: FilenamesOwner> FromPtr<*mut ffi::notmuch_filenames_t> for Filenames<'o, Owner> {
+    fn from_ptr(ptr: *mut ffi::notmuch_filenames_t) -> Filenames<'o, Owner> {
         Filenames{
             handle: FilenamesPtr{ptr},
             phantom: PhantomData
@@ -42,7 +44,7 @@ impl<'d> FromPtr<*mut ffi::notmuch_filenames_t> for Filenames<'d> {
     }
 }
 
-impl<'d> Iterator for Filenames<'d> {
+impl<'o, Owner: FilenamesOwner> Iterator for Filenames<'o, Owner> {
     type Item = PathBuf;
 
     fn next(self: &mut Self) -> Option<Self::Item> {
@@ -65,5 +67,5 @@ impl<'d> Iterator for Filenames<'d> {
     }
 }
 
-unsafe impl<'d> Send for Filenames<'d>{}
-unsafe impl<'d> Sync for Filenames<'d>{}
+unsafe impl<'o, Owner: FilenamesOwner> Send for Filenames<'o, Owner>{}
+unsafe impl<'o, Owner: FilenamesOwner> Sync for Filenames<'o, Owner>{}
diff --git a/src/message.rs b/src/message.rs
index ddcb356..c5a6404 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -14,7 +14,10 @@ use Query;
 use Messages;
 use Filenames;
 use Tags;
+use messages::MessagesOwner;
+use filenames::FilenamesOwner;
 
+pub trait MessageOwner{}
 
 #[derive(Debug)]
 pub(crate) struct MessagePtr {
@@ -30,13 +33,17 @@ impl Drop for MessagePtr {
 }
  
 #[derive(Debug)]
-pub struct Message<'d:'q, 'q>{
+pub struct Message<'o, Owner: MessageOwner>{
     pub(crate) handle: MessagePtr,
-    phantom: PhantomData<&'q Query<'d>>,
+    phantom: PhantomData<&'o Owner>,
 }
 
-impl<'d, 'q> FromPtr<*mut ffi::notmuch_message_t> for Message<'d, 'q> {
-    fn from_ptr(ptr: *mut ffi::notmuch_message_t) -> Message<'d, 'q> {
+impl<'o, Owner: MessageOwner> MessagesOwner for Message<'o, Owner>{}
+impl<'o, Owner: MessageOwner> FilenamesOwner for Message<'o, Owner>{}
+
+
+impl<'o, Owner: MessageOwner> FromPtr<*mut ffi::notmuch_message_t> for Message<'o, Owner> {
+    fn from_ptr(ptr: *mut ffi::notmuch_message_t) -> Message<'o, Owner> {
         Message{
             handle: MessagePtr{ptr},
             phantom: PhantomData
@@ -44,7 +51,7 @@ impl<'d, 'q> FromPtr<*mut ffi::notmuch_message_t> for Message<'d, 'q> {
     }
 }
 
-impl<'d, 'q> Message<'d, 'q>{
+impl<'o, Owner: MessageOwner> Message<'o, Owner>{
 
     pub fn id(self: &Self) -> String{
         let mid = unsafe {
@@ -60,7 +67,7 @@ impl<'d, 'q> Message<'d, 'q>{
         tid.to_str().unwrap().to_string()
     }
 
-    pub fn replies(self: &'q Self) -> Messages<'d, 'q>{
+    pub fn replies(self: &Self) -> Messages<'o, Self>{
         Messages::from_ptr(unsafe {
             ffi::notmuch_message_get_replies(self.handle.ptr)
         })
@@ -73,7 +80,7 @@ impl<'d, 'q> Message<'d, 'q>{
         }
     }
 
-    pub fn filenames(self: &'d Self) -> Filenames<'d>{
+    pub fn filenames(self: &Self) -> Filenames<Self>{
         Filenames::from_ptr(unsafe {
             ffi::notmuch_message_get_filenames(self.handle.ptr)
         })
@@ -97,12 +104,12 @@ impl<'d, 'q> Message<'d, 'q>{
         }
     }
 
-    pub fn tags(self: &'d Self) -> Tags<'d>{
+    pub fn tags(self: &Self) -> Tags{
         Tags::from_ptr(unsafe {
             ffi::notmuch_message_get_tags(self.handle.ptr)
         })
     }
 }
 
-unsafe impl<'d, 'q> Send for Message<'d, 'q>{}
-unsafe impl<'d, 'q> Sync for Message<'d, 'q>{}
+unsafe impl<'o, Owner: MessageOwner> Send for Message<'o, Owner>{}
+unsafe impl<'o, Owner: MessageOwner> Sync for Message<'o, Owner>{}
diff --git a/src/messages.rs b/src/messages.rs
index 4bc90e9..40929eb 100644
--- a/src/messages.rs
+++ b/src/messages.rs
@@ -9,7 +9,10 @@ use utils::{
 use Query;
 use Message;
 use Tags;
+use message::MessageOwner;
 
+pub trait MessagesOwner{
+}
 
 #[derive(Debug)]
 pub(crate) struct MessagesPtr {
@@ -34,13 +37,13 @@ impl Drop for MessagesPtr {
 
 
 #[derive(Debug)]
-pub struct Messages<'d:'q, 'q>{
+pub struct Messages<'o, Owner: MessagesOwner>{
     pub(crate) handle: MessagesPtr,
-    phantom: PhantomData<&'q Query<'d>>,
+    phantom: PhantomData<&'o Owner>,
 }
 
-impl<'d, 'q> FromPtr<*mut ffi::notmuch_messages_t> for Messages<'d, 'q> {
-    fn from_ptr(ptr: *mut ffi::notmuch_messages_t) -> Messages<'d, 'q> {
+impl<'o, Owner: MessagesOwner> FromPtr<*mut ffi::notmuch_messages_t> for Messages<'o, Owner> {
+    fn from_ptr(ptr: *mut ffi::notmuch_messages_t) -> Messages<'o, Owner> {
         Messages{
             handle: MessagesPtr{ptr},
             phantom: PhantomData
@@ -48,7 +51,10 @@ impl<'d, 'q> FromPtr<*mut ffi::notmuch_messages_t> for Messages<'d, 'q> {
     }
 }
 
-impl<'d, 'q> Messages<'d, 'q>{
+impl<'o, Owner: MessagesOwner> MessageOwner for Messages<'o, Owner>{}
+
+
+impl<'o, Owner: MessagesOwner> Messages<'o, Owner>{
 
     /**
      * Return a list of tags from all messages.
@@ -63,7 +69,7 @@ impl<'d, 'q> Messages<'d, 'q>{
      *
      * The function returns NULL on error.
      */
-    pub fn collect_tags(self: &'d Self) -> Tags{
+    pub fn collect_tags(self: &'o Self) -> Tags{
         Tags::from_ptr(unsafe {
             ffi::notmuch_messages_collect_tags(self.handle.ptr)
         })
@@ -72,8 +78,8 @@ impl<'d, 'q> Messages<'d, 'q>{
 
 
 
-impl<'d, 'q> Iterator for Messages<'d, 'q> {
-    type Item = Message<'d, 'q>;
+impl<'o, Owner: MessagesOwner> Iterator for Messages<'o, Owner> {
+    type Item = Message<'o, Self>;
 
     fn next(&mut self) -> Option<Self::Item> {
 
@@ -95,5 +101,5 @@ impl<'d, 'q> Iterator for Messages<'d, 'q> {
     }
 }
 
-unsafe impl<'d, 'q> Send for Messages<'d, 'q>{}
-unsafe impl<'d, 'q> Sync for Messages<'d, 'q>{}
+unsafe impl<'o, Owner: MessagesOwner> Send for Messages<'o, Owner>{}
+unsafe impl<'o, Owner: MessagesOwner> Sync for Messages<'o, Owner>{}
diff --git a/src/query.rs b/src/query.rs
index b4cd9a2..a95c9c2 100644
--- a/src/query.rs
+++ b/src/query.rs
@@ -11,6 +11,8 @@ use Database;
 use Messages;
 use Threads;
 use ffi::Sort;
+use threads::ThreadsOwner;
+use messages::MessagesOwner;
 
 #[derive(Debug)]
 pub(crate) struct QueryPtr {
@@ -31,6 +33,10 @@ pub struct Query<'d>{
     phantom: PhantomData<&'d Database>,
 }
 
+impl<'d> ThreadsOwner for Query<'d>{}
+impl<'d> MessagesOwner for Query<'d>{}
+
+
 impl<'d> FromPtr<*mut ffi::notmuch_query_t> for Query<'d> {
     fn from_ptr(ptr: *mut ffi::notmuch_query_t) -> Query<'d> {
         Query{
@@ -68,7 +74,7 @@ impl<'d> Query<'d> {
 
 
     /// Filter messages according to the query and return
-    pub fn search_messages<'q>(self: &'d Self) -> Result<Messages<'q, 'd>>
+    pub fn search_messages<'q>(self: &'d Self) -> Result<Messages<'q, Self>>
     {
         let mut msgs = ptr::null_mut();
         try!(unsafe {
@@ -92,7 +98,7 @@ impl<'d> Query<'d> {
         Ok(cnt)
     }
 
-    pub fn search_threads<'q>(self: &'d Self) -> Result<Threads<'q, 'd>>
+    pub fn search_threads<'q>(self: &'d Self) -> Result<Threads<'q, Self>>
     {
         let mut thrds = ptr::null_mut();
         try!(unsafe {
diff --git a/src/tags.rs b/src/tags.rs
index 61f99b7..5cac5ba 100644
--- a/src/tags.rs
+++ b/src/tags.rs
@@ -10,6 +10,9 @@ use utils::{
 use Database;
 use ffi;
 
+pub trait TagsOwner{}
+
+
 #[derive(Debug)]
 pub struct Tags<'d>(
     *mut ffi::notmuch_tags_t,
diff --git a/src/thread.rs b/src/thread.rs
index 60782f5..1cf163e 100644
--- a/src/thread.rs
+++ b/src/thread.rs
@@ -8,6 +8,11 @@ use utils::{
 use Query;
 use Messages;
 use Tags;
+use messages::MessagesOwner;
+use tags::TagsOwner;
+
+pub trait ThreadOwner{}
+
 
 #[derive(Debug)]
 pub(crate) struct ThreadPtr {
@@ -24,13 +29,17 @@ impl Drop for ThreadPtr {
 
 
 #[derive(Debug)]
-pub struct Thread<'d:'q, 'q>{
+pub struct Thread<'o, Owner: ThreadOwner>{
     pub(crate) handle: ThreadPtr,
-    phantom: PhantomData<&'q Query<'d>>,
+    phantom: PhantomData<&'o Owner>,
 }
 
-impl<'d, 'q> FromPtr<*mut ffi::notmuch_thread_t> for Thread<'d, 'q> {
-    fn from_ptr(ptr: *mut ffi::notmuch_thread_t) -> Thread<'d, 'q> {
+impl<'o, Owner: ThreadOwner> MessagesOwner for Thread<'o, Owner>{}
+impl<'o, Owner: ThreadOwner> TagsOwner for Thread<'o, Owner>{}
+
+
+impl<'o, Owner: ThreadOwner> FromPtr<*mut ffi::notmuch_thread_t> for Thread<'o, Owner> {
+    fn from_ptr(ptr: *mut ffi::notmuch_thread_t) -> Thread<'o, Owner> {
         Thread{
             handle: ThreadPtr{ptr},
             phantom: PhantomData
@@ -38,7 +47,7 @@ impl<'d, 'q> FromPtr<*mut ffi::notmuch_thread_t> for Thread<'d, 'q> {
     }
 }
 
-impl<'d, 'q> Thread<'d, 'q>{
+impl<'o, Owner: ThreadOwner> Thread<'o, Owner>{
 
     pub fn id(self: &Self) -> String{
         let tid = unsafe {
@@ -62,7 +71,7 @@ impl<'d, 'q> Thread<'d, 'q>{
     }
 
 
-    pub fn toplevel_messages(self: &Self) -> Messages{
+    pub fn toplevel_messages(self: &Self) -> Messages<Self>{
         Messages::from_ptr(unsafe {
             ffi::notmuch_thread_get_toplevel_messages(self.handle.ptr)
         })
@@ -70,7 +79,7 @@ impl<'d, 'q> Thread<'d, 'q>{
 
     /// Get a `Messages` iterator for all messages in 'thread' in
     /// oldest-first order.
-    pub fn messages(self: &Self) -> Messages{
+    pub fn messages(self: &Self) -> Messages<Self>{
         Messages::from_ptr(unsafe {
             ffi::notmuch_thread_get_messages(self.handle.ptr)
         })
@@ -115,5 +124,5 @@ impl<'d, 'q> Thread<'d, 'q>{
 }
 
 
-unsafe impl<'d, 'q> Send for Thread<'d, 'q> {}
-unsafe impl<'d, 'q> Sync for Thread<'d, 'q> {}
+unsafe impl<'o, Owner: ThreadOwner> Send for Thread<'o, Owner> {}
+unsafe impl<'o, Owner: ThreadOwner> Sync for Thread<'o, Owner> {}
diff --git a/src/threads.rs b/src/threads.rs
index a98caba..09f51bf 100644
--- a/src/threads.rs
+++ b/src/threads.rs
@@ -6,6 +6,10 @@ use utils::FromPtr;
 use Query;
 use Thread;
 use ffi;
+use thread::ThreadOwner;
+
+pub trait ThreadsOwner{}
+
 
 #[derive(Debug)]
 pub(crate) struct ThreadsPtr {
@@ -21,13 +25,16 @@ impl Drop for ThreadsPtr {
 }
 
 #[derive(Debug)]
-pub struct Threads<'d:'q, 'q>{
+pub struct Threads<'o, Owner: ThreadsOwner>{
     handle: ThreadsPtr,
-    phantom: PhantomData<&'q Query<'d>>,
+    phantom: PhantomData<&'o Owner>,
 }
 
-impl<'d, 'q> FromPtr<*mut ffi::notmuch_threads_t> for Threads<'d, 'q> {
-    fn from_ptr(ptr: *mut ffi::notmuch_threads_t) -> Threads<'d, 'q> {
+impl<'o, Owner: ThreadsOwner> ThreadOwner for Threads<'o, Owner>{}
+
+
+impl<'o, Owner: ThreadsOwner> FromPtr<*mut ffi::notmuch_threads_t> for Threads<'o, Owner> {
+    fn from_ptr(ptr: *mut ffi::notmuch_threads_t) -> Threads<'o, Owner> {
         Threads{
             handle: ThreadsPtr{ptr},
             phantom: PhantomData
@@ -35,8 +42,8 @@ impl<'d, 'q> FromPtr<*mut ffi::notmuch_threads_t> for Threads<'d, 'q> {
     }
 }
 
-impl<'d, 'q> Iterator for Threads<'d, 'q> {
-    type Item = Thread<'d, 'q>;
+impl<'o, Owner: ThreadsOwner> Iterator for Threads<'o, Owner> {
+    type Item = Thread<'o, Self>;
 
     fn next(self: &mut Self) -> Option<Self::Item> {
 
@@ -58,5 +65,5 @@ impl<'d, 'q> Iterator for Threads<'d, 'q> {
     }
 }
 
-unsafe impl<'d, 'q> Send for Threads<'d, 'q> {}
-unsafe impl<'d, 'q> Sync for Threads<'d, 'q> {}
+unsafe impl<'o, Owner: ThreadsOwner> Send for Threads<'o, Owner> {}
+unsafe impl<'o, Owner: ThreadsOwner> Sync for Threads<'o, Owner> {}
diff --git a/src/utils.rs b/src/utils.rs
index 9de7e08..5db8957 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -37,3 +37,6 @@ impl ToString for *const libc::c_char {
 }
 
 
+pub struct Owner;
+
+