more logical lifetime param structuring

5 files changed, 33 insertions, 33 deletions

diff --git a/Cargo.toml b/Cargo.toml
index fee587e..7711237 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "notmuch"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Dirk Van Haerenborgh <vhdirk@gmail.com>"]
 homepage = "https://github.com/vhdirk/notmuch-rs"
 repository = "https://github.com/vhdirk/notmuch-rs"
diff --git a/src/message.rs b/src/message.rs
index d28257c..81d2417 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -12,18 +12,18 @@ use Messages;
 use Filenames;
 
 #[derive(Debug)]
-pub struct Message<'q, 'd:'q>(
+pub struct Message<'d:'q, 'q>(
     pub(crate) *mut ffi::notmuch_message_t,
     PhantomData<&'q Query<'d>>,
 );
 
-impl<'q, 'd> NewFromPtr<*mut ffi::notmuch_message_t> for Message<'q, 'd> {
-    fn new(ptr: *mut ffi::notmuch_message_t) -> Message<'q, 'd> {
+impl<'d, 'q> NewFromPtr<*mut ffi::notmuch_message_t> for Message<'d, 'q> {
+    fn new(ptr: *mut ffi::notmuch_message_t) -> Message<'d, 'q> {
         Message(ptr, PhantomData)
     }
 }
 
-impl<'q, 'd> Message<'q, 'd>{
+impl<'d, 'q> Message<'d, 'q>{
 
     pub fn id(self: &Self) -> String{
         let mid = unsafe {
@@ -39,7 +39,7 @@ impl<'q, 'd> Message<'q, 'd>{
         tid.to_str().unwrap().to_string()
     }
 
-    pub fn replies(self: &'q Self) -> Messages<'q, 'd>{
+    pub fn replies(self: &'q Self) -> Messages<'d, 'q>{
         Messages::new(unsafe {
             ffi::notmuch_message_get_replies(self.0)
         })
@@ -66,7 +66,7 @@ impl<'q, 'd> Message<'q, 'd>{
 }
 
 
-impl<'q, 'd> Drop for Message<'q, 'd> {
+impl<'d, 'q> Drop for Message<'d, 'q> {
     fn drop(self: &mut Self) {
         unsafe {
             ffi::notmuch_message_destroy(self.0)
@@ -74,5 +74,5 @@ impl<'q, 'd> Drop for Message<'q, 'd> {
     }
 }
 
-unsafe impl<'q, 'd> Send for Message<'q, 'd>{}
-unsafe impl<'q, 'd> Sync for Message<'q, 'd>{}
+unsafe impl<'d, 'q> Send for Message<'d, 'q>{}
+unsafe impl<'d, 'q> Sync for Message<'d, 'q>{}
diff --git a/src/messages.rs b/src/messages.rs
index 139b9a8..65e1248 100644
--- a/src/messages.rs
+++ b/src/messages.rs
@@ -11,20 +11,20 @@ use Message;
 use Tags;
 
 #[derive(Debug)]
-pub struct Messages<'q, 'd:'q>(
+pub struct Messages<'d:'q, 'q>(
     // TODO: is this lifetime specifier correct?
     // query may outlive messages.
     pub(crate) *mut ffi::notmuch_messages_t,
     PhantomData<&'q Query<'d>>,
 );
 
-impl<'q, 'd> NewFromPtr<*mut ffi::notmuch_messages_t> for Messages<'q, 'd> {
-    fn new(ptr: *mut ffi::notmuch_messages_t) -> Messages<'q, 'd> {
+impl<'d, 'q> NewFromPtr<*mut ffi::notmuch_messages_t> for Messages<'d, 'q> {
+    fn new(ptr: *mut ffi::notmuch_messages_t) -> Messages<'d, 'q> {
         Messages(ptr, PhantomData)
     }
 }
 
-impl<'q, 'd> Messages<'q, 'd>{
+impl<'d, 'q> Messages<'d, 'q>{
 
     pub fn collect_tags(self: &'d Self) -> Tags<'d>{
         Tags::new(unsafe {
@@ -34,7 +34,7 @@ impl<'q, 'd> Messages<'q, 'd>{
 
 }
 
-impl<'q, 'd> Drop for Messages<'q, 'd> {
+impl<'d, 'q> Drop for Messages<'d, 'q> {
     fn drop(self: &mut Self) {
         let valid = unsafe {
             ffi::notmuch_messages_valid(self.0)
@@ -50,8 +50,8 @@ impl<'q, 'd> Drop for Messages<'q, 'd> {
     }
 }
 
-impl<'q, 'd> Iterator for Messages<'q, 'd> {
-    type Item = Message<'q, 'd>;
+impl<'d, 'q> Iterator for Messages<'d, 'q> {
+    type Item = Message<'d, 'q>;
 
     fn next(&mut self) -> Option<Self::Item> {
 
@@ -73,5 +73,5 @@ impl<'q, 'd> Iterator for Messages<'q, 'd> {
     }
 }
 
-unsafe impl<'q, 'd> Send for Messages<'q, 'd>{}
-unsafe impl<'q, 'd> Sync for Messages<'q, 'd>{}
+unsafe impl<'d, 'q> Send for Messages<'d, 'q>{}
+unsafe impl<'d, 'q> Sync for Messages<'d, 'q>{}
diff --git a/src/thread.rs b/src/thread.rs
index dfe0a69..4f98c26 100644
--- a/src/thread.rs
+++ b/src/thread.rs
@@ -10,18 +10,18 @@ use Messages;
 use Tags;
 
 #[derive(Debug)]
-pub struct Thread<'q, 'd:'q>(
+pub struct Thread<'d:'q, 'q>(
     pub(crate) *mut ffi::notmuch_thread_t,
     PhantomData<&'q Query<'d>>,
 );
 
-impl<'q, 'd> NewFromPtr<*mut ffi::notmuch_thread_t> for Thread<'q, 'd> {
-    fn new(ptr: *mut ffi::notmuch_thread_t) -> Thread<'q, 'd> {
+impl<'d, 'q> NewFromPtr<*mut ffi::notmuch_thread_t> for Thread<'d, 'q> {
+    fn new(ptr: *mut ffi::notmuch_thread_t) -> Thread<'d, 'q> {
         Thread(ptr, PhantomData)
     }
 }
 
-impl<'q, 'd> Thread<'q, 'd>{
+impl<'d, 'q> Thread<'d, 'q>{
 
     pub fn id(self: &Self) -> String{
         let tid = unsafe {
@@ -98,7 +98,7 @@ impl<'q, 'd> Thread<'q, 'd>{
 }
 
 
-impl<'q, 'd> Drop for Thread<'q, 'd> {
+impl<'d, 'q> Drop for Thread<'d, 'q> {
     fn drop(&mut self) {
         unsafe {
             ffi::notmuch_thread_destroy(self.0)
@@ -106,5 +106,5 @@ impl<'q, 'd> Drop for Thread<'q, 'd> {
     }
 }
 
-unsafe impl<'q, 'd> Send for Thread<'q, 'd> {}
-unsafe impl<'q, 'd> Sync for Thread<'q, 'd> {}
+unsafe impl<'d, 'q> Send for Thread<'d, 'q> {}
+unsafe impl<'d, 'q> Sync for Thread<'d, 'q> {}
diff --git a/src/threads.rs b/src/threads.rs
index 9a0117f..20fc302 100644
--- a/src/threads.rs
+++ b/src/threads.rs
@@ -8,18 +8,18 @@ use Thread;
 use ffi;
 
 #[derive(Debug)]
-pub struct Threads<'q, 'd:'q>(
+pub struct Threads<'d:'q, 'q>(
     *mut ffi::notmuch_threads_t,
     PhantomData<&'q Query<'d>>,
 );
 
-impl<'q, 'd> NewFromPtr<*mut ffi::notmuch_threads_t> for Threads<'q, 'd> {
-    fn new(ptr: *mut ffi::notmuch_threads_t) -> Threads<'q, 'd> {
+impl<'d, 'q> NewFromPtr<*mut ffi::notmuch_threads_t> for Threads<'d, 'q> {
+    fn new(ptr: *mut ffi::notmuch_threads_t) -> Threads<'d, 'q> {
         Threads(ptr, PhantomData)
     }
 }
 
-impl<'q, 'd> Drop for Threads<'q, 'd> {
+impl<'d, 'q> Drop for Threads<'d, 'q> {
     fn drop(&mut self) {
         unsafe {
             ffi::notmuch_threads_destroy(self.0)
@@ -27,8 +27,8 @@ impl<'q, 'd> Drop for Threads<'q, 'd> {
     }
 }
 
-impl<'q, 'd> Iterator for Threads<'q, 'd> {
-    type Item = Thread<'q, 'd>;
+impl<'d, 'q> Iterator for Threads<'d, 'q> {
+    type Item = Thread<'d, 'q>;
 
     fn next(self: &mut Self) -> Option<Self::Item> {
 
@@ -50,5 +50,5 @@ impl<'q, 'd> Iterator for Threads<'q, 'd> {
     }
 }
 
-unsafe impl<'q, 'd> Send for Threads<'q, 'd> {}
-unsafe impl<'q, 'd> Sync for Threads<'q, 'd> {}
+unsafe impl<'d, 'q> Send for Threads<'d, 'q> {}
+unsafe impl<'d, 'q> Sync for Threads<'d, 'q> {}