add scopeable version of message.freeze/thaw

5 files changed, 179 insertions, 3 deletions

diff --git a/src/database.rs b/src/database.rs
index f3733ef..c828bb2 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -395,7 +395,7 @@ pub trait DatabaseExt {
                 unsafe { ffi::notmuch_database_index_file(dbref.ptr, msg_path.as_ptr(), opts, &mut msg) }
                     .as_result()?;
                 
-                Ok(Message::from_ptr(msg, Supercow::phantom(dbref)))
+                Ok(Message::from_ptr(msg, ScopedSupercow::phantom(dbref)))
             }
             None => Err(Error::NotmuchError(Status::FileError)),
         }
diff --git a/src/index.rs b/src/index.rs
index 41505b6..a672dfb 100644
--- a/src/index.rs
+++ b/src/index.rs
@@ -1,5 +1,5 @@
 use std::ops::Drop;
-use supercow::Supercow;
+use supercow::{Supercow, Phantomcow};
 
 use error::{Error, Result};
 use ffi;
diff --git a/src/lib.rs b/src/lib.rs
index 0336e8a..f32ce95 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -26,7 +26,7 @@ pub use database::{Database, DatabaseExt};
 pub use directory::{Directory, DirectoryExt};
 pub use error::Error;
 pub use filenames::{Filenames, FilenamesOwner};
-pub use message::{Message, MessageExt, MessageOwner};
+pub use message::{Message, MessageExt, MessageOwner, FrozenMessage};
 pub use messages::{Messages, MessagesExt};
 pub use query::{Query, QueryExt};
 pub use tags::{Tags, TagsExt, TagsOwner};
diff --git a/src/message.rs b/src/message.rs
index f5d0542..77aecc3 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -175,3 +175,39 @@ impl<'o, O> MessageExt<'o, O> for Message<'o, O> where O: MessageOwner + 'o {}
 
 unsafe impl<'o, O> Send for Message<'o, O> where O: MessageOwner + 'o {}
 unsafe impl<'o, O> Sync for Message<'o, O> where O: MessageOwner + 'o {}
+
+
+pub struct FrozenMessage<'m ,'o, O>
+where
+    O: MessageOwner + 'o
+{
+    message: ScopedSupercow<'m, Message<'o, O>>
+}
+
+
+impl<'m, 'o, O> FrozenMessage<'m, 'o, O>
+where
+    O: MessageOwner + 'o
+{
+    pub fn new<M>(message: M) -> Result<Self>
+    where
+        M: Into<ScopedSupercow<'m, Message<'o, O>>>
+    {
+        let msg = message.into();
+        msg.freeze()?;
+        Ok(FrozenMessage{
+            message: msg
+        })
+    }
+}
+
+impl<'m, 'o, O> Drop for FrozenMessage<'m, 'o, O>
+where
+    O: MessageOwner + 'o
+{
+    fn drop(&mut self) {
+        let _ = self.message.thaw();
+    }
+}
+
+
diff --git a/tests/commands.rs b/tests/commands.rs
new file mode 100644
index 0000000..c9f9d60
--- /dev/null
+++ b/tests/commands.rs
@@ -0,0 +1,140 @@
+extern crate dirs;
+extern crate notmuch;
+extern crate supercow;
+
+use std::path::Path;
+use std::sync::Arc;
+use std::result::Result;
+use supercow::Supercow;
+use notmuch::ScopedSupercow;
+
+use notmuch::{
+    Database,
+    DatabaseExt,
+    Query,
+    QueryExt,
+    Message,
+    FrozenMessage,
+    Error
+};
+
+#[derive(Debug)]
+pub struct AtomicOperation<'d> {
+    database: ScopedSupercow<'d, Database>,
+}
+
+impl<'d> AtomicOperation<'d> {
+    pub fn new<D>(db: D) -> Result<Self, Error>
+    where
+        D: Into<ScopedSupercow<'d, Database>>,
+    {
+        let database = db.into();
+        database.begin_atomic()?;
+        Ok(AtomicOperation{
+            database
+        })
+    }
+}
+
+impl<'d> Drop for AtomicOperation<'d> {
+    fn drop(&mut self) {
+        let _ = self.database.end_atomic();
+    }
+}
+
+/// Add a single file to the database
+pub fn add_file<'d, D, P>(db: D, filename: &P) -> Result<Message<'d, Database>, Error>
+where
+    D: Into<ScopedSupercow<'d, Database>>,
+    P: AsRef<Path>
+{
+    let mut database = db.into();
+
+    let _atomic = AtomicOperation::new(Supercow::share(&mut database)).unwrap();
+
+    match <Database as DatabaseExt>::index_file(Supercow::share(&mut database), filename, None) {
+        Ok(msg) => {
+
+            // scoped version of freezing a message
+            {
+                let _fmsg = FrozenMessage::new(&msg);
+                
+
+            }
+            Ok(msg)
+        },
+        Err(err) => {
+            Err(err)
+        }
+    }
+
+
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add_file() {
+
+
+
+    }
+}
+
+
+
+//       status = notmuch_database_index_file (notmuch, filename, indexing_cli_choices.opts, &message);
+//       switch (status) {
+//       /* Success. */
+//       case NOTMUCH_STATUS_SUCCESS:
+//           state->added_messages++;
+//           notmuch_message_freeze (message);
+//           if (state->synchronize_flags)
+//               notmuch_message_maildir_flags_to_tags (message);
+  
+//           for (tag = state->new_tags; *tag != NULL; tag++) {
+//               if (strcmp ("unread", *tag) != 0 ||
+//                   ! notmuch_message_has_maildir_flag (message, 'S')) {
+//                   notmuch_message_add_tag (message, *tag);
+//               }
+//           }
+  
+//           notmuch_message_thaw (message);
+//           break;
+//       /* Non-fatal issues (go on to next file). */
+//       case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
+//           if (state->synchronize_flags)
+//               notmuch_message_maildir_flags_to_tags (message);
+//           break;
+//       case NOTMUCH_STATUS_FILE_NOT_EMAIL:
+//           fprintf (stderr, "Note: Ignoring non-mail file: %s\n", filename);
+//           break;
+//       case NOTMUCH_STATUS_FILE_ERROR:
+//           /* Someone renamed/removed the file between scandir and now. */
+//           state->vanished_files++;
+//           fprintf (stderr, "Unexpected error with file %s\n", filename);
+//           (void) print_status_database ("add_file", notmuch, status);
+//           break;
+//       /* Fatal issues. Don't process anymore. */
+//       case NOTMUCH_STATUS_READ_ONLY_DATABASE:
+//       case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
+//       case NOTMUCH_STATUS_OUT_OF_MEMORY:
+//           (void) print_status_database ("add_file", notmuch, status);
+//           goto DONE;
+//       default:
+//           INTERNAL_ERROR ("add_message returned unexpected value: %d", status);
+//           goto DONE;
+//       }
+  
+//       status = notmuch_database_end_atomic (notmuch);
+  
+//     DONE:
+//       if (message)
+//           notmuch_message_destroy (message);
+  
+//       return status;
+//   }
+  
\ No newline at end of file