Add internal functions for manipulating a new notmuch_message_t

[notmuch] / message.cc

diff --git a/message.cc b/message.cc
index 74a173e1ec2060d2bfbe7b2cc498cac5ddcfae85..9e43af3f0d38df5abbeaf55d0ff0c854322e4910 100644 (file)
--- a/message.cc
+++ b/message.cc
@@ -27,6 +27,7 @@ struct _notmuch_message {
     notmuch_database_t *notmuch;
     Xapian::docid doc_id;
     char *message_id;
+    char *filename;
     Xapian::Document doc;
 };
 
@@ -121,6 +122,7 @@ _notmuch_message_create (const void *talloc_owner,
     message->notmuch = notmuch;
     message->doc_id = doc_id;
     message->message_id = NULL; /* lazily created */
+    message->filename = NULL; /* lazily created */
     new (&message->doc) Xapian::Document;
 
     talloc_set_destructor (message, _notmuch_message_destructor);
@@ -150,6 +152,39 @@ notmuch_message_get_message_id (notmuch_message_t *message)
     return message->message_id;
 }
 
+/* Set the filename for 'message' to 'filename'.
+ *
+ * XXX: We should still figure out what we want to do for multiple
+ * files with identical message IDs. We will probably want to store a
+ * list of filenames here, (so that this will be "add_filename"
+ * instead of "set_filename"). Which would make this very similar to
+ * add_thread_ids.
+ *
+ * This change will not be reflected in the database until the next
+ * call to _notmuch_message_set_sync. */
+void
+_notmuch_message_set_filename (notmuch_message_t *message,
+                              const char *filename)
+{
+    if (message->filename)
+       talloc_free (message->filename);
+    message->doc.set_data (filename);
+}
+
+const char *
+notmuch_message_get_filename (notmuch_message_t *message)
+{
+    std::string filename_str;
+
+    if (message->filename)
+       return message->filename;
+
+    filename_str = message->doc.get_data ();
+    message->filename = talloc_strdup (message, filename_str.c_str ());
+
+    return message->filename;
+}
+
 /* We end up having to call the destructors explicitly because we had
  * to use "placement new" in order to initialize C++ objects within a
  * block that we allocated with talloc. So C++ is making talloc
@@ -205,8 +240,86 @@ notmuch_message_get_thread_ids (notmuch_message_t *message)
     return thread_ids;
 }
 
-/* Synchronize changes made to message->doc into the database. */
+void
+_notmuch_message_set_date (notmuch_message_t *message,
+                          const char *date)
+{
+    time_t time_value;
+
+    time_value = notmuch_parse_date (date, NULL);
+
+    message->doc.add_value (NOTMUCH_VALUE_DATE,
+                           Xapian::sortable_serialise (time_value));
+}
+
+void
+_notmuch_message_add_thread_id (notmuch_message_t *message,
+                               const char *thread_id)
+{
+    std::string id_str;
+
+    _notmuch_message_add_term (message, "thread", thread_id);
+
+    id_str = message->doc.get_value (NOTMUCH_VALUE_THREAD);
+
+    if (id_str.empty ()) {
+       message->doc.add_value (NOTMUCH_VALUE_THREAD, thread_id);
+    } else {
+       size_t pos;
+
+       /* Think about using a hash here if there's any performance
+        * problem. */
+       pos = id_str.find (thread_id);
+       if (pos == std::string::npos) {
+           id_str.append (",");
+           id_str.append (thread_id);
+           message->doc.add_value (NOTMUCH_VALUE_THREAD, id_str);
+       }
+    }
+}
+
 static void
+thread_id_generate (thread_id_t *thread_id)
+{
+    static int seeded = 0;
+    FILE *dev_random;
+    uint32_t value;
+    char *s;
+    int i;
+
+    if (! seeded) {
+       dev_random = fopen ("/dev/random", "r");
+       if (dev_random == NULL) {
+           srand (time (NULL));
+       } else {
+           fread ((void *) &value, sizeof (value), 1, dev_random);
+           srand (value);
+           fclose (dev_random);
+       }
+       seeded = 1;
+    }
+
+    s = thread_id->str;
+    for (i = 0; i < NOTMUCH_THREAD_ID_DIGITS; i += 8) {
+       value = rand ();
+       sprintf (s, "%08x", value);
+       s += 8;
+    }
+}
+
+void
+_notmuch_message_ensure_thread_id (notmuch_message_t *message)
+{
+    /* If not part of any existing thread, generate a new thread_id. */
+    thread_id_t thread_id;
+
+    thread_id_generate (&thread_id);
+    _notmuch_message_add_term (message, "thread", thread_id.str);
+    message->doc.add_value (NOTMUCH_VALUE_THREAD, thread_id.str);
+}
+
+/* Synchronize changes made to message->doc out into the database. */
+void
 _notmuch_message_sync (notmuch_message_t *message)
 {
     Xapian::WritableDatabase *db = message->notmuch->xapian_db;