Re: Address completion
authorSebastian Spaeth <Sebastian@SSpaeth.de>
Wed, 21 Apr 2010 14:11:09 +0000 (16:11 +0200)
committerW. Trevor King <wking@tremily.us>
Fri, 7 Nov 2014 17:36:44 +0000 (09:36 -0800)
8f/c6c710ae65f5ac58dbcc24c74365ae221d9114 [new file with mode: 0644]

diff --git a/8f/c6c710ae65f5ac58dbcc24c74365ae221d9114 b/8f/c6c710ae65f5ac58dbcc24c74365ae221d9114
new file mode 100644 (file)
index 0000000..277d521
--- /dev/null
@@ -0,0 +1,1092 @@
+Return-Path: <Sebastian@SSpaeth.de>\r
+X-Original-To: notmuch@notmuchmail.org\r
+Delivered-To: notmuch@notmuchmail.org\r
+Received: from localhost (localhost [127.0.0.1])\r
+       by olra.theworths.org (Postfix) with ESMTP id D209D4196F3\r
+       for <notmuch@notmuchmail.org>; Wed, 21 Apr 2010 07:11:22 -0700 (PDT)\r
+X-Virus-Scanned: Debian amavisd-new at olra.theworths.org\r
+X-Spam-Flag: NO\r
+X-Spam-Score: -1.9\r
+X-Spam-Level: \r
+X-Spam-Status: No, score=-1.9 tagged_above=-999 required=5\r
+       tests=[BAYES_00=-1.9] autolearn=ham\r
+Received: from olra.theworths.org ([127.0.0.1])\r
+       by localhost (olra.theworths.org [127.0.0.1]) (amavisd-new, port 10024)\r
+       with ESMTP id svf-4VNHV8ST for <notmuch@notmuchmail.org>;\r
+       Wed, 21 Apr 2010 07:11:17 -0700 (PDT)\r
+Received: from homiemail-a13.g.dreamhost.com (caiajhbdcagg.dreamhost.com\r
+       [208.97.132.66])\r
+       by olra.theworths.org (Postfix) with ESMTP id 7F2CB431FC1\r
+       for <notmuch@notmuchmail.org>; Wed, 21 Apr 2010 07:11:17 -0700 (PDT)\r
+Received: from sspaeth.de (unknown [195.190.188.219])\r
+       by homiemail-a13.g.dreamhost.com (Postfix) with ESMTPA id B3EA06A806B; \r
+       Wed, 21 Apr 2010 07:11:13 -0700 (PDT)\r
+Received: by sspaeth.de (sSMTP sendmail emulation);\r
+       Wed, 21 Apr 2010 16:11:09 +0200\r
+From: "Sebastian Spaeth" <Sebastian@SSpaeth.de>\r
+To: Dirk Hohndel <hohndel@infradead.org>,\r
+       Notmuch development list <notmuch@notmuchmail.org>\r
+Subject: Re: Address completion\r
+In-Reply-To: <871ve9jkhy.fsf@SSpaeth.de>\r
+References: <87bpddg67c.fsf@SSpaeth.de> <m3zl0xtqhf.fsf@x200.gr8dns.org>\r
+       <871ve9jkhy.fsf@SSpaeth.de>\r
+Date: Wed, 21 Apr 2010 16:11:09 +0200\r
+Message-ID: <878w8gj3pe.fsf@SSpaeth.de>\r
+MIME-Version: 1.0\r
+Content-Type: multipart/mixed; boundary="=-=-="\r
+X-BeenThere: notmuch@notmuchmail.org\r
+X-Mailman-Version: 2.1.13\r
+Precedence: list\r
+List-Id: "Use and development of the notmuch mail system."\r
+       <notmuch.notmuchmail.org>\r
+List-Unsubscribe: <http://notmuchmail.org/mailman/options/notmuch>,\r
+       <mailto:notmuch-request@notmuchmail.org?subject=unsubscribe>\r
+List-Archive: <http://notmuchmail.org/pipermail/notmuch>\r
+List-Post: <mailto:notmuch@notmuchmail.org>\r
+List-Help: <mailto:notmuch-request@notmuchmail.org?subject=help>\r
+List-Subscribe: <http://notmuchmail.org/mailman/listinfo/notmuch>,\r
+       <mailto:notmuch-request@notmuchmail.org?subject=subscribe>\r
+X-List-Received-Date: Wed, 21 Apr 2010 14:11:23 -0000\r
+\r
+--=-=-=\r
+\r
+David improved the notmuch-address.el glue today, and I improved my\r
+addrlookup tool also. It is much more intelligent now:\r
+\r
+We parse the notmuch db in up to 3 passes now where each find from\r
+the previous pass is sorted with heigher weight, ie we will first output\r
+addresses in our "address book" then addresses we have mailed to\r
+previously and only than at mails we have received.\r
+    \r
+1st pass: Find all 'from' addresses that are in messages tagged as\r
+      'addressbook' (this tag is configurable in .notmuch-config under\r
+      [user] addrbook_tag=foo but uses addressbook by default)\r
+    \r
+2nd pass: Find all 'to','cc','bcc' addresses that match our criteria and\r
+      that we ever sent a mail from our primary mail address\r
+    \r
+3rd pass: If pass1 + 2 lead to less than 10 message hits, perform a pass\r
+      3.  Look at all email 'from' headers that match our criteria and\r
+      use those.  We limit this, because notmuch opens all mail files\r
+      that might match, to read the header out of them, potentially\r
+      hurting performance a lot. So don't do pass 3 if pass 1 & 2 lead\r
+      to likely results already.\r
+    \r
+Using the address book feature, you can implement simple 'blacklisting'\r
+of emails.  If you have friends at Sun for example, you might want to\r
+'notmuch tag +addressbook from:"oracle.com"' to give those addresses\r
+priority over the sun.com addresses you have previously used.\r
+\r
+Performance is still good enough. Doing a "addrlookup" which returns everyone\r
+in my "addressbook" and all mail addresses I ever sent mail to (just\r
+165), takes real 0m0.095s with a warm file cache. If the file cache is\r
+cold, a search for e.g. "he" can take real     0m2.385s. The reason is\r
+that notmuch opens all possibly matching mail files in order to retrieve\r
+the headers.\r
+\r
+Compile directly from vala or the attached c source. Compiling the c source works with glib2.0-dev installed:\r
+\r
+cc -o addrlookup addrlookup.c `pkg-config --cflags --libs gobject-2.0`\r
+-lnotmuch\r
+\r
+\r
+--=-=-=\r
+Content-Type: text/x-csrc\r
+Content-Disposition: attachment; filename=addrlookup.c\r
+Content-Description: c source file\r
+\r
+/* addrlookup.c generated by valac, the Vala compiler\r
+ * generated from addrlookup.vala, do not modify */\r
+\r
+\r
+#include <glib.h>\r
+#include <glib-object.h>\r
+#include <notmuch.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+#include <stdio.h>\r
+#include <gobject/gvaluecollector.h>\r
+\r
+\r
+#define TYPE_ADDRESS_MATCHER (address_matcher_get_type ())\r
+#define ADDRESS_MATCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ADDRESS_MATCHER, AddressMatcher))\r
+#define ADDRESS_MATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ADDRESS_MATCHER, AddressMatcherClass))\r
+#define IS_ADDRESS_MATCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ADDRESS_MATCHER))\r
+#define IS_ADDRESS_MATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ADDRESS_MATCHER))\r
+#define ADDRESS_MATCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ADDRESS_MATCHER, AddressMatcherClass))\r
+\r
+typedef struct _AddressMatcher AddressMatcher;\r
+typedef struct _AddressMatcherClass AddressMatcherClass;\r
+typedef struct _AddressMatcherPrivate AddressMatcherPrivate;\r
+#define _notmuch_database_close0(var) ((var == NULL) ? NULL : (var = (notmuch_database_close (var), NULL)))\r
+#define _g_free0(var) (var = (g_free (var), NULL))\r
+#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))\r
+#define _g_key_file_free0(var) ((var == NULL) ? NULL : (var = (g_key_file_free (var), NULL)))\r
+\r
+#define ADDRESS_MATCHER_TYPE_MAILADDRESS_FREQ (address_matcher_mailaddress_freq_get_type ())\r
+typedef struct _AddressMatcherMailAddress_freq AddressMatcherMailAddress_freq;\r
+#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))\r
+#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))\r
+#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))\r
+#define _g_match_info_free0(var) ((var == NULL) ? NULL : (var = (g_match_info_free (var), NULL)))\r
+#define _0(var) ((var == NULL) ? NULL : (var = ( (var), NULL)))\r
+#define _address_matcher_mailaddress_freq_free0(var) ((var == NULL) ? NULL : (var = (address_matcher_mailaddress_freq_free (var), NULL)))\r
+#define __g_list_free_address_matcher_mailaddress_freq_free0(var) ((var == NULL) ? NULL : (var = (_g_list_free_address_matcher_mailaddress_freq_free (var), NULL)))\r
+#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))\r
+typedef struct _ParamSpecAddressMatcher ParamSpecAddressMatcher;\r
+#define _address_matcher_unref0(var) ((var == NULL) ? NULL : (var = (address_matcher_unref (var), NULL)))\r
+\r
+struct _AddressMatcher {\r
+       GTypeInstance parent_instance;\r
+       volatile int ref_count;\r
+       AddressMatcherPrivate * priv;\r
+};\r
+\r
+struct _AddressMatcherClass {\r
+       GTypeClass parent_class;\r
+       void (*finalize) (AddressMatcher *self);\r
+};\r
+\r
+struct _AddressMatcherPrivate {\r
+       notmuch_database_t* db;\r
+       char* user_db_path;\r
+       char* user_primary_email;\r
+       char* user_addrbook_tag;\r
+};\r
+\r
+struct _AddressMatcherMailAddress_freq {\r
+       char* address;\r
+       guint* occurances;\r
+       gint occurances_length1;\r
+       gint _occurances_size_;\r
+};\r
+\r
+struct _ParamSpecAddressMatcher {\r
+       GParamSpec parent_instance;\r
+};\r
+\r
+\r
+static gpointer address_matcher_parent_class = NULL;\r
+\r
+gpointer address_matcher_ref (gpointer instance);\r
+void address_matcher_unref (gpointer instance);\r
+GParamSpec* param_spec_address_matcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);\r
+void value_set_address_matcher (GValue* value, gpointer v_object);\r
+void value_take_address_matcher (GValue* value, gpointer v_object);\r
+gpointer value_get_address_matcher (const GValue* value);\r
+GType address_matcher_get_type (void);\r
+#define ADDRESS_MATCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_ADDRESS_MATCHER, AddressMatcherPrivate))\r
+enum  {\r
+       ADDRESS_MATCHER_DUMMY_PROPERTY\r
+};\r
+AddressMatcher* address_matcher_new (void);\r
+AddressMatcher* address_matcher_construct (GType object_type);\r
+static GType address_matcher_mailaddress_freq_get_type (void) G_GNUC_UNUSED;\r
+static AddressMatcherMailAddress_freq* address_matcher_mailaddress_freq_dup (const AddressMatcherMailAddress_freq* self);\r
+static void address_matcher_mailaddress_freq_free (AddressMatcherMailAddress_freq* self);\r
+static void address_matcher_mailaddress_freq_copy (const AddressMatcherMailAddress_freq* self, AddressMatcherMailAddress_freq* dest);\r
+static void address_matcher_mailaddress_freq_destroy (AddressMatcherMailAddress_freq* self);\r
+static gint address_matcher_sort_by_freq (AddressMatcherMailAddress_freq* mail1, AddressMatcherMailAddress_freq* mail2);\r
+char* address_matcher_frequent_fullname (AddressMatcher* self, GHashTable* frequencies);\r
+GHashTable* address_matcher_addresses_by_frequency (AddressMatcher* self, notmuch_messages_t* msgs, const char* name, guint pass, GHashTable** addr2realname);\r
+static void _vala_array_add1 (char*** array, int* length, int* size, char* value);\r
+static void _g_list_free_address_matcher_mailaddress_freq_free (GList* self);\r
+char** address_matcher_search_address_passes (AddressMatcher* self, notmuch_query_t** queries, int queries_length1, const char* name, int* result_length1);\r
+static void _vala_array_add2 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value);\r
+static void _vala_array_add3 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value);\r
+static void _vala_array_add4 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value);\r
+void address_matcher_run (AddressMatcher* self, const char* name);\r
+static guint* _vala_array_dup1 (guint* self, int length);\r
+static void address_matcher_finalize (AddressMatcher* obj);\r
+gint _vala_main (char** args, int args_length1);\r
+static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);\r
+static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);\r
+\r
+\r
+\r
+AddressMatcher* address_matcher_construct (GType object_type) {\r
+       GError * _inner_error_;\r
+       AddressMatcher* self;\r
+       GKeyFile* config;\r
+       char* home;\r
+       _inner_error_ = NULL;\r
+       self = (AddressMatcher*) g_type_create_instance (object_type);\r
+       config = g_key_file_new ();\r
+       home = g_strdup (g_getenv ("NOTMUCH_CONFIG"));\r
+       if (home == NULL) {\r
+               char* _tmp0_;\r
+               home = (_tmp0_ = g_strdup (g_get_home_dir ()), _g_free0 (home), _tmp0_);\r
+       }\r
+       {\r
+               char* _tmp1_;\r
+               char* _tmp2_;\r
+               char* _tmp3_;\r
+               g_key_file_load_from_file (config, _tmp1_ = g_strconcat (home, "/.notmuch-config", NULL), G_KEY_FILE_NONE, &_inner_error_);\r
+               _g_free0 (_tmp1_);\r
+               if (_inner_error_ != NULL) {\r
+                       goto __catch0_g_error;\r
+               }\r
+               _tmp2_ = g_key_file_get_string (config, "database", "path", &_inner_error_);\r
+               if (_inner_error_ != NULL) {\r
+                       goto __catch0_g_error;\r
+               }\r
+               self->priv->user_db_path = (_tmp3_ = _tmp2_, _g_free0 (self->priv->user_db_path), _tmp3_);\r
+       }\r
+       goto __finally0;\r
+       __catch0_g_error:\r
+       {\r
+               GError * ex;\r
+               ex = _inner_error_;\r
+               _inner_error_ = NULL;\r
+               {\r
+                       _g_error_free0 (ex);\r
+               }\r
+       }\r
+       __finally0:\r
+       if (_inner_error_ != NULL) {\r
+               _g_key_file_free0 (config);\r
+               _g_free0 (home);\r
+               g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);\r
+               g_clear_error (&_inner_error_);\r
+               return NULL;\r
+       }\r
+       {\r
+               char* _tmp4_;\r
+               char* _tmp5_;\r
+               _tmp4_ = g_key_file_get_string (config, "user", "primary_email", &_inner_error_);\r
+               if (_inner_error_ != NULL) {\r
+                       goto __catch1_g_error;\r
+               }\r
+               self->priv->user_primary_email = (_tmp5_ = _tmp4_, _g_free0 (self->priv->user_primary_email), _tmp5_);\r
+       }\r
+       goto __finally1;\r
+       __catch1_g_error:\r
+       {\r
+               GError * ex;\r
+               ex = _inner_error_;\r
+               _inner_error_ = NULL;\r
+               {\r
+                       _g_error_free0 (ex);\r
+               }\r
+       }\r
+       __finally1:\r
+       if (_inner_error_ != NULL) {\r
+               _g_key_file_free0 (config);\r
+               _g_free0 (home);\r
+               g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);\r
+               g_clear_error (&_inner_error_);\r
+               return NULL;\r
+       }\r
+       {\r
+               char* _tmp6_;\r
+               char* _tmp7_;\r
+               _tmp6_ = g_key_file_get_string (config, "user", "addrbook_tag", &_inner_error_);\r
+               if (_inner_error_ != NULL) {\r
+                       goto __catch2_g_error;\r
+               }\r
+               self->priv->user_addrbook_tag = (_tmp7_ = _tmp6_, _g_free0 (self->priv->user_addrbook_tag), _tmp7_);\r
+       }\r
+       goto __finally2;\r
+       __catch2_g_error:\r
+       {\r
+               GError * ex;\r
+               ex = _inner_error_;\r
+               _inner_error_ = NULL;\r
+               {\r
+                       char* _tmp8_;\r
+                       self->priv->user_addrbook_tag = (_tmp8_ = g_strdup ("addressbook"), _g_free0 (self->priv->user_addrbook_tag), _tmp8_);\r
+                       _g_error_free0 (ex);\r
+               }\r
+       }\r
+       __finally2:\r
+       if (_inner_error_ != NULL) {\r
+               _g_key_file_free0 (config);\r
+               _g_free0 (home);\r
+               g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);\r
+               g_clear_error (&_inner_error_);\r
+               return NULL;\r
+       }\r
+       _g_key_file_free0 (config);\r
+       _g_free0 (home);\r
+       return self;\r
+}\r
+\r
+\r
+AddressMatcher* address_matcher_new (void) {\r
+       return address_matcher_construct (TYPE_ADDRESS_MATCHER);\r
+}\r
+\r
+\r
+static gint address_matcher_sort_by_freq (AddressMatcherMailAddress_freq* mail1, AddressMatcherMailAddress_freq* mail2) {\r
+       gint result = 0;\r
+       gboolean _tmp0_ = FALSE;\r
+       gboolean _tmp1_ = FALSE;\r
+       gboolean _tmp2_ = FALSE;\r
+       gboolean _tmp3_ = FALSE;\r
+       if ((*mail1).occurances[0] == (*mail2).occurances[0]) {\r
+               _tmp1_ = (*mail1).occurances[1] == (*mail2).occurances[1];\r
+       } else {\r
+               _tmp1_ = FALSE;\r
+       }\r
+       if (_tmp1_) {\r
+               _tmp0_ = (*mail1).occurances[2] == (*mail2).occurances[2];\r
+       } else {\r
+               _tmp0_ = FALSE;\r
+       }\r
+       if (_tmp0_) {\r
+               result = 0;\r
+               return result;\r
+       }\r
+       if ((*mail1).occurances[0] > (*mail2).occurances[0]) {\r
+               _tmp3_ = TRUE;\r
+       } else {\r
+               gboolean _tmp4_ = FALSE;\r
+               if ((*mail1).occurances[0] == (*mail2).occurances[0]) {\r
+                       _tmp4_ = (*mail1).occurances[1] > (*mail2).occurances[1];\r
+               } else {\r
+                       _tmp4_ = FALSE;\r
+               }\r
+               _tmp3_ = _tmp4_;\r
+       }\r
+       if (_tmp3_) {\r
+               _tmp2_ = TRUE;\r
+       } else {\r
+               gboolean _tmp5_ = FALSE;\r
+               gboolean _tmp6_ = FALSE;\r
+               if ((*mail1).occurances[0] == (*mail2).occurances[0]) {\r
+                       _tmp6_ = (*mail1).occurances[1] == (*mail2).occurances[1];\r
+               } else {\r
+                       _tmp6_ = FALSE;\r
+               }\r
+               if (_tmp6_) {\r
+                       _tmp5_ = (*mail1).occurances[2] > (*mail2).occurances[2];\r
+               } else {\r
+                       _tmp5_ = FALSE;\r
+               }\r
+               _tmp2_ = _tmp5_;\r
+       }\r
+       if (_tmp2_) {\r
+               result = -1;\r
+               return result;\r
+       }\r
+       result = 1;\r
+       return result;\r
+}\r
+\r
+\r
+static gboolean string_contains (const char* self, const char* needle) {\r
+       gboolean result = FALSE;\r
+       g_return_val_if_fail (self != NULL, FALSE);\r
+       g_return_val_if_fail (needle != NULL, FALSE);\r
+       result = strstr (self, needle) != NULL;\r
+       return result;\r
+}\r
+\r
+\r
+char* address_matcher_frequent_fullname (AddressMatcher* self, GHashTable* frequencies) {\r
+       char* result = NULL;\r
+       guint maxfreq;\r
+       char* fullname;\r
+       g_return_val_if_fail (self != NULL, NULL);\r
+       g_return_val_if_fail (frequencies != NULL, NULL);\r
+       maxfreq = (guint) 0;\r
+       fullname = NULL;\r
+       {\r
+               GList* mail_collection;\r
+               GList* mail_it;\r
+               mail_collection = g_hash_table_get_keys (frequencies);\r
+               for (mail_it = mail_collection; mail_it != NULL; mail_it = mail_it->next) {\r
+                       const char* mail;\r
+                       mail = (const char*) mail_it->data;\r
+                       {\r
+                               guint freq;\r
+                               gboolean _tmp0_ = FALSE;\r
+                               gboolean _tmp1_ = FALSE;\r
+                               freq = GPOINTER_TO_UINT (g_hash_table_lookup (frequencies, mail));\r
+                               if (freq > maxfreq) {\r
+                                       _tmp1_ = string_contains (mail, " ");\r
+                               } else {\r
+                                       _tmp1_ = FALSE;\r
+                               }\r
+                               if (_tmp1_) {\r
+                                       _tmp0_ = TRUE;\r
+                               } else {\r
+                                       _tmp0_ = g_hash_table_size (frequencies) == 1;\r
+                               }\r
+                               if (_tmp0_) {\r
+                                       char* _tmp2_;\r
+                                       maxfreq = freq;\r
+                                       fullname = (_tmp2_ = g_strdup (mail), _g_free0 (fullname), _tmp2_);\r
+                               }\r
+                       }\r
+               }\r
+               _g_list_free0 (mail_collection);\r
+       }\r
+       result = fullname;\r
+       return result;\r
+}\r
+\r
+\r
+static gpointer _g_hash_table_ref0 (gpointer self) {\r
+       return self ? g_hash_table_ref (self) : NULL;\r
+}\r
+\r
+\r
+GHashTable* address_matcher_addresses_by_frequency (AddressMatcher* self, notmuch_messages_t* msgs, const char* name, guint pass, GHashTable** addr2realname) {\r
+       GHashTable* result = NULL;\r
+       GError * _inner_error_;\r
+       GHashTable* ht;\r
+       GRegex* re;\r
+       char** _tmp3_;\r
+       gint _headers_size_;\r
+       gint headers_length1;\r
+       char** _tmp2_ = NULL;\r
+       char** headers;\r
+       g_return_val_if_fail (self != NULL, NULL);\r
+       g_return_val_if_fail (msgs != NULL, NULL);\r
+       g_return_val_if_fail (name != NULL, NULL);\r
+       g_return_val_if_fail (addr2realname != NULL, NULL);\r
+       _inner_error_ = NULL;\r
+       ht = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);\r
+       re = NULL;\r
+       {\r
+               GRegex* _tmp0_;\r
+               GRegex* _tmp1_;\r
+               _tmp0_ = g_regex_new ("\\s*((\\\"(\\\\.|[^\\\\\"])*\\\"|[^,])*" "<?(?P<mail>\\b\\w+([-+.]\\w+)*\\@\\w+[-\\.\\w]*\\.([-\\.\\w]+)*\\w\\b)" \\r
+">?)", 0, 0, &_inner_error_);\r
+               if (_inner_error_ != NULL) {\r
+                       if (_inner_error_->domain == G_REGEX_ERROR) {\r
+                               goto __catch3_g_regex_error;\r
+                       }\r
+                       _g_hash_table_unref0 (ht);\r
+                       _g_regex_unref0 (re);\r
+                       g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);\r
+                       g_clear_error (&_inner_error_);\r
+                       return NULL;\r
+               }\r
+               re = (_tmp1_ = _tmp0_, _g_regex_unref0 (re), _tmp1_);\r
+       }\r
+       goto __finally3;\r
+       __catch3_g_regex_error:\r
+       {\r
+               GError * ex;\r
+               ex = _inner_error_;\r
+               _inner_error_ = NULL;\r
+               {\r
+                       _g_error_free0 (ex);\r
+               }\r
+       }\r
+       __finally3:\r
+       if (_inner_error_ != NULL) {\r
+               _g_hash_table_unref0 (ht);\r
+               _g_regex_unref0 (re);\r
+               g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);\r
+               g_clear_error (&_inner_error_);\r
+               return NULL;\r
+       }\r
+       headers = (_tmp3_ = (_tmp2_ = g_new0 (char*, 1 + 1), _tmp2_[0] = g_strdup ("from"), _tmp2_), headers_length1 = 1, _headers_size_ = headers_length1, _tmp3_);\r
+       if (pass == 1) {\r
+               char** _tmp5_;\r
+               char** _tmp4_ = NULL;\r
+               headers = (_tmp5_ = (_tmp4_ = g_new0 (char*, 3 + 1), _tmp4_[0] = g_strdup ("to"), _tmp4_[1] = g_strdup ("cc"), _tmp4_[2] = g_strdup ("bcc"), _tmp4_), headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL), headers_length1 = 3, _headers_size_ = headers_length1, _tmp5_);\r
+       }\r
+       while (TRUE) {\r
+               GMatchInfo* matches;\r
+               notmuch_message_t* msg;\r
+               if (!notmuch_messages_valid (msgs)) {\r
+                       break;\r
+               }\r
+               matches = NULL;\r
+               msg = notmuch_messages_get (msgs);\r
+               {\r
+                       char** header_collection;\r
+                       int header_collection_length1;\r
+                       int header_it;\r
+                       header_collection = headers;\r
+                       header_collection_length1 = headers_length1;\r
+                       for (header_it = 0; header_it < headers_length1; header_it = header_it + 1) {\r
+                               char* header;\r
+                               header = g_strdup (header_collection[header_it]);\r
+                               {\r
+                                       char* froms;\r
+                                       GMatchInfo* _tmp8_;\r
+                                       gboolean _tmp7_;\r
+                                       GMatchInfo* _tmp6_ = NULL;\r
+                                       gboolean found;\r
+                                       froms = g_strdup ((const char*) notmuch_message_get_header (msg, header));\r
+                                       found = (_tmp7_ = g_regex_match (re, froms, 0, &_tmp6_), matches = (_tmp8_ = _tmp6_, _g_match_info_free0 (matches), _tmp8_), _tmp7_);\r
+                                       while (TRUE) {\r
+                                               char* from;\r
+                                               char* addr;\r
+                                               char* _tmp9_;\r
+                                               char* _tmp11_;\r
+                                               gboolean _tmp12_;\r
+                                               gboolean is_match;\r
+                                               guint occurs;\r
+                                               GHashTable* realname_freq;\r
+                                               if (!found) {\r
+                                                       break;\r
+                                               }\r
+                                               from = g_match_info_fetch (matches, 1);\r
+                                               addr = g_match_info_fetch_named (matches, "mail");\r
+                                               addr = (_tmp9_ = g_utf8_strdown (addr, -1), _g_free0 (addr), _tmp9_);\r
+                                               {\r
+                                                       gboolean _tmp10_;\r
+                                                       _tmp10_ = g_match_info_next (matches, &_inner_error_);\r
+                                                       if (_inner_error_ != NULL) {\r
+                                                               if (_inner_error_->domain == G_REGEX_ERROR) {\r
+                                                                       goto __catch4_g_regex_error;\r
+                                                               }\r
+                                                               _g_free0 (from);\r
+                                                               _g_free0 (addr);\r
+                                                               _g_free0 (header);\r
+                                                               _g_free0 (froms);\r
+                                                               _g_match_info_free0 (matches);\r
+                                                               _0 (msg);\r
+                                                               _g_hash_table_unref0 (ht);\r
+                                                               _g_regex_unref0 (re);\r
+                                                               headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL);\r
+                                                               g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);\r
+                                                               g_clear_error (&_inner_error_);\r
+                                                               return NULL;\r
+                                                       }\r
+                                                       found = _tmp10_;\r
+                                               }\r
+                                               goto __finally4;\r
+                                               __catch4_g_regex_error:\r
+                                               {\r
+                                                       GError * ex;\r
+                                                       ex = _inner_error_;\r
+                                                       _inner_error_ = NULL;\r
+                                                       {\r
+                                                               _g_error_free0 (ex);\r
+                                                       }\r
+                                               }\r
+                                               __finally4:\r
+                                               if (_inner_error_ != NULL) {\r
+                                                       _g_free0 (from);\r
+                                                       _g_free0 (addr);\r
+                                                       _g_free0 (header);\r
+                                                       _g_free0 (froms);\r
+                                                       _g_match_info_free0 (matches);\r
+                                                       _0 (msg);\r
+                                                       _g_hash_table_unref0 (ht);\r
+                                                       _g_regex_unref0 (re);\r
+                                                       headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL);\r
+                                                       g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);\r
+                                                       g_clear_error (&_inner_error_);\r
+                                                       return NULL;\r
+                                               }\r
+                                               is_match = (_tmp12_ = g_regex_match_simple (_tmp11_ = g_strconcat ("\\b", name, NULL), from, G_REGEX_CASELESS, 0), _g_free0 (_tmp11_), _tmp12_);\r
+                                               if (!is_match) {\r
+                                                       _g_free0 (from);\r
+                                                       _g_free0 (addr);\r
+                                                       continue;\r
+                                               }\r
+                                               occurs = GPOINTER_TO_UINT (g_hash_table_lookup (ht, addr)) + 1;\r
+                                               g_hash_table_replace (ht, g_strdup (addr), GUINT_TO_POINTER (occurs));\r
+                                               realname_freq = _g_hash_table_ref0 ((GHashTable*) g_hash_table_lookup (*addr2realname, addr));\r
+                                               if (realname_freq == NULL) {\r
+                                                       GHashTable* _tmp13_;\r
+                                                       realname_freq = (_tmp13_ = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL), _g_hash_table_unref0 (realname_freq), _tmp13_);\r
+                                                       g_hash_table_insert (*addr2realname, g_strdup (addr), _g_hash_table_ref0 (realname_freq));\r
+                                               }\r
+                                               occurs = GPOINTER_TO_UINT (g_hash_table_lookup (realname_freq, from)) + 1;\r
+                                               g_hash_table_replace (realname_freq, g_strdup (from), GUINT_TO_POINTER (occurs));\r
+                                               _g_free0 (from);\r
+                                               _g_free0 (addr);\r
+                                               _g_hash_table_unref0 (realname_freq);\r
+                                       }\r
+                                       _g_free0 (header);\r
+                                       _g_free0 (froms);\r
+                               }\r
+                       }\r
+               }\r
+               notmuch_message_destroy (msg);\r
+               notmuch_messages_move_to_next (msgs);\r
+               _g_match_info_free0 (matches);\r
+               _0 (msg);\r
+       }\r
+       result = ht;\r
+       _g_regex_unref0 (re);\r
+       headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL);\r
+       return result;\r
+}\r
+\r
+\r
+static gpointer _address_matcher_mailaddress_freq_dup0 (gpointer self) {\r
+       return self ? address_matcher_mailaddress_freq_dup (self) : NULL;\r
+}\r
+\r
+\r
+static void _vala_array_add1 (char*** array, int* length, int* size, char* value) {\r
+       if ((*length) == (*size)) {\r
+               *size = (*size) ? (2 * (*size)) : 4;\r
+               *array = g_renew (char*, *array, (*size) + 1);\r
+       }\r
+       (*array)[(*length)++] = value;\r
+       (*array)[*length] = NULL;\r
+}\r
+\r
+\r
+static void _g_list_free_address_matcher_mailaddress_freq_free (GList* self) {\r
+       g_list_foreach (self, (GFunc) address_matcher_mailaddress_freq_free, NULL);\r
+       g_list_free (self);\r
+}\r
+\r
+\r
+char** address_matcher_search_address_passes (AddressMatcher* self, notmuch_query_t** queries, int queries_length1, const char* name, int* result_length1) {\r
+       char** result = NULL;\r
+       char** _tmp0_;\r
+       gint _return_value_size_;\r
+       gint return_value_length1;\r
+       char** return_value;\r
+       GHashTable* addrfreq;\r
+       GHashTable* addr2realname;\r
+       guint pass;\r
+       GList* addrs;\r
+       char** _tmp6_;\r
+       g_return_val_if_fail (self != NULL, NULL);\r
+       g_return_val_if_fail (name != NULL, NULL);\r
+       return_value = (_tmp0_ = NULL, return_value_length1 = 0, _return_value_size_ = return_value_length1, _tmp0_);\r
+       addrfreq = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);\r
+       addr2realname = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);\r
+       pass = (guint) 0;\r
+       {\r
+               notmuch_query_t** q_collection;\r
+               int q_collection_length1;\r
+               int q_it;\r
+               q_collection = queries;\r
+               q_collection_length1 = queries_length1;\r
+               for (q_it = 0; q_it < queries_length1; q_it = q_it + 1) {\r
+                       notmuch_query_t* q;\r
+                       q = q_collection[q_it];\r
+                       {\r
+                               notmuch_messages_t* msgs;\r
+                               GHashTable* ht;\r
+                               msgs = notmuch_query_search_messages (q);\r
+                               ht = address_matcher_addresses_by_frequency (self, msgs, name, pass, &addr2realname);\r
+                               {\r
+                                       GList* addr_collection;\r
+                                       GList* addr_it;\r
+                                       addr_collection = g_hash_table_get_keys (ht);\r
+                                       for (addr_it = addr_collection; addr_it != NULL; addr_it = addr_it->next) {\r
+                                               const char* addr;\r
+                                               addr = (const char*) addr_it->data;\r
+                                               {\r
+                                                       AddressMatcherMailAddress_freq* freq;\r
+                                                       freq = _address_matcher_mailaddress_freq_dup0 ((AddressMatcherMailAddress_freq*) g_hash_table_lookup (addrfreq, addr));\r
+                                                       if (freq == NULL) {\r
+                                                               AddressMatcherMailAddress_freq* _tmp5_;\r
+                                                               AddressMatcherMailAddress_freq _tmp4_;\r
+                                                               AddressMatcherMailAddress_freq _tmp3_;\r
+                                                               guint* _tmp1_ = NULL;\r
+                                                               AddressMatcherMailAddress_freq _tmp2_ = {0};\r
+                                                               freq = (_tmp5_ = _address_matcher_mailaddress_freq_dup0 ((_tmp4_ = _tmp3_ = (memset (&_tmp2_, 0, sizeof (AddressMatcherMailAddress_freq)), _tmp2_.address = g_strdup (addr), _tmp2_.occurances = (_tmp1_ = g_new0 (guint, 3), _tmp1_[0] = (guint) 0, _tmp1_[1] = (guint) 0, _tmp1_[2] = (guint) 0, _tmp1_), _tmp2_.occurances_length1 = 3, _tmp2_), &_tmp4_)), _address_matcher_mailaddress_freq_free0 (freq), _tmp5_);\r
+                                                               address_matcher_mailaddress_freq_destroy (&_tmp3_);\r
+                                                       }\r
+                                                       (*freq).occurances[pass] = GPOINTER_TO_UINT (g_hash_table_lookup (ht, addr));\r
+                                                       g_hash_table_replace (addrfreq, g_strdup (addr), _address_matcher_mailaddress_freq_dup0 (freq));\r
+                                                       _address_matcher_mailaddress_freq_free0 (freq);\r
+                                               }\r
+                                       }\r
+                                       _g_list_free0 (addr_collection);\r
+                               }\r
+                               notmuch_messages_destroy (msgs);\r
+                               pass = pass + ((guint) 1);\r
+                               _0 (msgs);\r
+                               _g_hash_table_unref0 (ht);\r
+                       }\r
+               }\r
+       }\r
+       addrs = g_hash_table_get_values (addrfreq);\r
+       addrs = g_list_sort (addrs, (GCompareFunc) address_matcher_sort_by_freq);\r
+       {\r
+               GList* addr_collection;\r
+               GList* addr_it;\r
+               addr_collection = addrs;\r
+               for (addr_it = addr_collection; addr_it != NULL; addr_it = addr_it->next) {\r
+                       AddressMatcherMailAddress_freq* addr;\r
+                       addr = _address_matcher_mailaddress_freq_dup0 ((AddressMatcherMailAddress_freq*) addr_it->data);\r
+                       {\r
+                               GHashTable* freqs;\r
+                               freqs = _g_hash_table_ref0 ((GHashTable*) g_hash_table_lookup (addr2realname, (*addr).address));\r
+                               _vala_array_add1 (&return_value, &return_value_length1, &_return_value_size_, address_matcher_frequent_fullname (self, freqs));\r
+                               _address_matcher_mailaddress_freq_free0 (addr);\r
+                               _g_hash_table_unref0 (freqs);\r
+                       }\r
+               }\r
+       }\r
+       result = (_tmp6_ = return_value, *result_length1 = return_value_length1, _tmp6_);\r
+       _g_hash_table_unref0 (addrfreq);\r
+       _g_hash_table_unref0 (addr2realname);\r
+       __g_list_free_address_matcher_mailaddress_freq_free0 (addrs);\r
+       return result;\r
+       return_value = (_vala_array_free (return_value, return_value_length1, (GDestroyNotify) g_free), NULL);\r
+       _g_hash_table_unref0 (addrfreq);\r
+       _g_hash_table_unref0 (addr2realname);\r
+       __g_list_free_address_matcher_mailaddress_freq_free0 (addrs);\r
+}\r
+\r
+\r
+static void _vala_array_add2 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value) {\r
+       if ((*length) == (*size)) {\r
+               *size = (*size) ? (2 * (*size)) : 4;\r
+               *array = g_renew (notmuch_query_t*, *array, *size);\r
+       }\r
+       (*array)[(*length)++] = value;\r
+}\r
+\r
+\r
+static void _vala_array_add3 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value) {\r
+       if ((*length) == (*size)) {\r
+               *size = (*size) ? (2 * (*size)) : 4;\r
+               *array = g_renew (notmuch_query_t*, *array, *size);\r
+       }\r
+       (*array)[(*length)++] = value;\r
+}\r
+\r
+\r
+static void _vala_array_add4 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value) {\r
+       if ((*length) == (*size)) {\r
+               *size = (*size) ? (2 * (*size)) : 4;\r
+               *array = g_renew (notmuch_query_t*, *array, *size);\r
+       }\r
+       (*array)[(*length)++] = value;\r
+}\r
+\r
+\r
+void address_matcher_run (AddressMatcher* self, const char* name) {\r
+       notmuch_query_t** _tmp1_;\r
+       gint _queries_size_;\r
+       gint queries_length1;\r
+       notmuch_query_t** _tmp0_ = NULL;\r
+       notmuch_query_t** queries;\r
+       notmuch_database_t* _tmp2_;\r
+       char* _tmp3_;\r
+       GString* _tmp4_;\r
+       GString* querystr;\r
+       GString* _tmp7_;\r
+       char** _tmp15_;\r
+       gint __result__size_;\r
+       gint _result__length1;\r
+       gint _tmp14_;\r
+       char** _result_;\r
+       g_return_if_fail (self != NULL);\r
+       queries = (_tmp1_ = (_tmp0_ = g_new0 (notmuch_query_t*, 0), _tmp0_), queries_length1 = 0, _queries_size_ = queries_length1, _tmp1_);\r
+       self->priv->db = (_tmp2_ = notmuch_database_open (self->priv->user_db_path, NOTMUCH_DATABASE_MODE_READ_ONLY), _notmuch_database_close0 (self->priv->db), _tmp2_);\r
+       querystr = (_tmp4_ = g_string_new (_tmp3_ = g_strconcat ("tag:", self->priv->user_addrbook_tag, NULL)), _g_free0 (_tmp3_), _tmp4_);\r
+       if (name != NULL) {\r
+               char* _tmp6_;\r
+               char* _tmp5_;\r
+               g_string_append (querystr, _tmp6_ = g_strconcat (_tmp5_ = g_strconcat (" and from:", name, NULL), "*", NULL));\r
+               _g_free0 (_tmp6_);\r
+               _g_free0 (_tmp5_);\r
+       } else {\r
+               name = "";\r
+       }\r
+       _vala_array_add2 (&queries, &queries_length1, &_queries_size_, notmuch_query_create (self->priv->db, querystr->str));\r
+       querystr = (_tmp7_ = g_string_new (""), _g_string_free0 (querystr), _tmp7_);\r
+       if (name != NULL) {\r
+               char* _tmp9_;\r
+               char* _tmp8_;\r
+               g_string_append (querystr, _tmp9_ = g_strconcat (_tmp8_ = g_strconcat ("to:", name, NULL), "*", NULL));\r
+               _g_free0 (_tmp9_);\r
+               _g_free0 (_tmp8_);\r
+       }\r
+       if (self->priv->user_primary_email != NULL) {\r
+               char* _tmp10_;\r
+               g_string_append (querystr, _tmp10_ = g_strconcat (" from:", self->priv->user_primary_email, NULL));\r
+               _g_free0 (_tmp10_);\r
+       }\r
+       _vala_array_add3 (&queries, &queries_length1, &_queries_size_, notmuch_query_create (self->priv->db, querystr->str));\r
+       if ((notmuch_query_count_messages (queries[0]) + notmuch_query_count_messages (queries[1])) < 10) {\r
+               GString* _tmp11_;\r
+               querystr = (_tmp11_ = g_string_new (""), _g_string_free0 (querystr), _tmp11_);\r
+               if (name != NULL) {\r
+                       char* _tmp13_;\r
+                       char* _tmp12_;\r
+                       g_string_append (querystr, _tmp13_ = g_strconcat (_tmp12_ = g_strconcat ("from:", name, NULL), "*", NULL));\r
+                       _g_free0 (_tmp13_);\r
+                       _g_free0 (_tmp12_);\r
+               }\r
+               _vala_array_add4 (&queries, &queries_length1, &_queries_size_, notmuch_query_create (self->priv->db, querystr->str));\r
+       }\r
+       _result_ = (_tmp15_ = address_matcher_search_address_passes (self, queries, queries_length1, name, &_tmp14_), _result__length1 = _tmp14_, __result__size_ = _result__length1, _tmp15_);\r
+       {\r
+               char** name_collection;\r
+               int name_collection_length1;\r
+               int name_it;\r
+               name_collection = _result_;\r
+               name_collection_length1 = _result__length1;\r
+               for (name_it = 0; name_it < _result__length1; name_it = name_it + 1) {\r
+                       char* name;\r
+                       name = g_strdup (name_collection[name_it]);\r
+                       {\r
+                               fprintf (stdout, "%s\n", name);\r
+                               _g_free0 (name);\r
+                       }\r
+               }\r
+       }\r
+       queries = (g_free (queries), NULL);\r
+       _g_string_free0 (querystr);\r
+       _result_ = (_vala_array_free (_result_, _result__length1, (GDestroyNotify) g_free), NULL);\r
+}\r
+\r
+\r
+static guint* _vala_array_dup1 (guint* self, int length) {\r
+       return g_memdup (self, length * sizeof (guint));\r
+}\r
+\r
+\r
+static void address_matcher_mailaddress_freq_copy (const AddressMatcherMailAddress_freq* self, AddressMatcherMailAddress_freq* dest) {\r
+       guint* _tmp0_;\r
+       dest->address = g_strdup (self->address);\r
+       dest->occurances = (_tmp0_ = self->occurances, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup1 (_tmp0_, (*self).occurances_length1));\r
+       dest->occurances_length1 = self->occurances_length1;\r
+}\r
+\r
+\r
+static void address_matcher_mailaddress_freq_destroy (AddressMatcherMailAddress_freq* self) {\r
+       _g_free0 (self->address);\r
+       self->occurances = (g_free (self->occurances), NULL);\r
+}\r
+\r
+\r
+static AddressMatcherMailAddress_freq* address_matcher_mailaddress_freq_dup (const AddressMatcherMailAddress_freq* self) {\r
+       AddressMatcherMailAddress_freq* dup;\r
+       dup = g_new0 (AddressMatcherMailAddress_freq, 1);\r
+       address_matcher_mailaddress_freq_copy (self, dup);\r
+       return dup;\r
+}\r
+\r
+\r
+static void address_matcher_mailaddress_freq_free (AddressMatcherMailAddress_freq* self) {\r
+       address_matcher_mailaddress_freq_destroy (self);\r
+       g_free (self);\r
+}\r
+\r
+\r
+static GType address_matcher_mailaddress_freq_get_type (void) {\r
+       static volatile gsize address_matcher_mailaddress_freq_type_id__volatile = 0;\r
+       if (g_once_init_enter (&address_matcher_mailaddress_freq_type_id__volatile)) {\r
+               GType address_matcher_mailaddress_freq_type_id;\r
+               address_matcher_mailaddress_freq_type_id = g_boxed_type_register_static ("AddressMatcherMailAddress_freq", (GBoxedCopyFunc) address_matcher_mailaddress_freq_dup, (GBoxedFreeFunc) address_matcher_mailaddress_freq_free);\r
+               g_once_init_leave (&address_matcher_mailaddress_freq_type_id__volatile, address_matcher_mailaddress_freq_type_id);\r
+       }\r
+       return address_matcher_mailaddress_freq_type_id__volatile;\r
+}\r
+\r
+\r
+static void value_address_matcher_init (GValue* value) {\r
+       value->data[0].v_pointer = NULL;\r
+}\r
+\r
+\r
+static void value_address_matcher_free_value (GValue* value) {\r
+       if (value->data[0].v_pointer) {\r
+               address_matcher_unref (value->data[0].v_pointer);\r
+       }\r
+}\r
+\r
+\r
+static void value_address_matcher_copy_value (const GValue* src_value, GValue* dest_value) {\r
+       if (src_value->data[0].v_pointer) {\r
+               dest_value->data[0].v_pointer = address_matcher_ref (src_value->data[0].v_pointer);\r
+       } else {\r
+               dest_value->data[0].v_pointer = NULL;\r
+       }\r
+}\r
+\r
+\r
+static gpointer value_address_matcher_peek_pointer (const GValue* value) {\r
+       return value->data[0].v_pointer;\r
+}\r
+\r
+\r
+static gchar* value_address_matcher_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {\r
+       if (collect_values[0].v_pointer) {\r
+               AddressMatcher* object;\r
+               object = collect_values[0].v_pointer;\r
+               if (object->parent_instance.g_class == NULL) {\r
+                       return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);\r
+               } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {\r
+                       return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);\r
+               }\r
+               value->data[0].v_pointer = address_matcher_ref (object);\r
+       } else {\r
+               value->data[0].v_pointer = NULL;\r
+       }\r
+       return NULL;\r
+}\r
+\r
+\r
+static gchar* value_address_matcher_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {\r
+       AddressMatcher** object_p;\r
+       object_p = collect_values[0].v_pointer;\r
+       if (!object_p) {\r
+               return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));\r
+       }\r
+       if (!value->data[0].v_pointer) {\r
+               *object_p = NULL;\r
+       } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {\r
+               *object_p = value->data[0].v_pointer;\r
+       } else {\r
+               *object_p = address_matcher_ref (value->data[0].v_pointer);\r
+       }\r
+       return NULL;\r
+}\r
+\r
+\r
+GParamSpec* param_spec_address_matcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {\r
+       ParamSpecAddressMatcher* spec;\r
+       g_return_val_if_fail (g_type_is_a (object_type, TYPE_ADDRESS_MATCHER), NULL);\r
+       spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);\r
+       G_PARAM_SPEC (spec)->value_type = object_type;\r
+       return G_PARAM_SPEC (spec);\r
+}\r
+\r
+\r
+gpointer value_get_address_matcher (const GValue* value) {\r
+       g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_ADDRESS_MATCHER), NULL);\r
+       return value->data[0].v_pointer;\r
+}\r
+\r
+\r
+void value_set_address_matcher (GValue* value, gpointer v_object) {\r
+       AddressMatcher* old;\r
+       g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_ADDRESS_MATCHER));\r
+       old = value->data[0].v_pointer;\r
+       if (v_object) {\r
+               g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_ADDRESS_MATCHER));\r
+               g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));\r
+               value->data[0].v_pointer = v_object;\r
+               address_matcher_ref (value->data[0].v_pointer);\r
+       } else {\r
+               value->data[0].v_pointer = NULL;\r
+       }\r
+       if (old) {\r
+               address_matcher_unref (old);\r
+       }\r
+}\r
+\r
+\r
+void value_take_address_matcher (GValue* value, gpointer v_object) {\r
+       AddressMatcher* old;\r
+       g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_ADDRESS_MATCHER));\r
+       old = value->data[0].v_pointer;\r
+       if (v_object) {\r
+               g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_ADDRESS_MATCHER));\r
+               g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));\r
+               value->data[0].v_pointer = v_object;\r
+       } else {\r
+               value->data[0].v_pointer = NULL;\r
+       }\r
+       if (old) {\r
+               address_matcher_unref (old);\r
+       }\r
+}\r
+\r
+\r
+static void address_matcher_class_init (AddressMatcherClass * klass) {\r
+       address_matcher_parent_class = g_type_class_peek_parent (klass);\r
+       ADDRESS_MATCHER_CLASS (klass)->finalize = address_matcher_finalize;\r
+       g_type_class_add_private (klass, sizeof (AddressMatcherPrivate));\r
+}\r
+\r
+\r
+static void address_matcher_instance_init (AddressMatcher * self) {\r
+       self->priv = ADDRESS_MATCHER_GET_PRIVATE (self);\r
+       self->priv->user_db_path = NULL;\r
+       self->priv->user_primary_email = NULL;\r
+       self->priv->user_addrbook_tag = NULL;\r
+       self->ref_count = 1;\r
+}\r
+\r
+\r
+static void address_matcher_finalize (AddressMatcher* obj) {\r
+       AddressMatcher * self;\r
+       self = ADDRESS_MATCHER (obj);\r
+       _notmuch_database_close0 (self->priv->db);\r
+       _g_free0 (self->priv->user_db_path);\r
+       _g_free0 (self->priv->user_primary_email);\r
+       _g_free0 (self->priv->user_addrbook_tag);\r
+}\r
+\r
+\r
+GType address_matcher_get_type (void) {\r
+       static volatile gsize address_matcher_type_id__volatile = 0;\r
+       if (g_once_init_enter (&address_matcher_type_id__volatile)) {\r
+               static const GTypeValueTable g_define_type_value_table = { value_address_matcher_init, value_address_matcher_free_value, value_address_matcher_copy_value, value_address_matcher_peek_pointer, "p", value_address_matcher_collect_value, "p", value_address_matcher_lcopy_value };\r
+               static const GTypeInfo g_define_type_info = { sizeof (AddressMatcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) address_matcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AddressMatcher), 0, (GInstanceInitFunc) address_matcher_instance_init, &g_define_type_value_table };\r
+               static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };\r
+               GType address_matcher_type_id;\r
+               address_matcher_type_id = g_type_register_fundamental (g_type_fundamental_next (), "AddressMatcher", &g_define_type_info, &g_define_type_fundamental_info, 0);\r
+               g_once_init_leave (&address_matcher_type_id__volatile, address_matcher_type_id);\r
+       }\r
+       return address_matcher_type_id__volatile;\r
+}\r
+\r
+\r
+gpointer address_matcher_ref (gpointer instance) {\r
+       AddressMatcher* self;\r
+       self = instance;\r
+       g_atomic_int_inc (&self->ref_count);\r
+       return instance;\r
+}\r
+\r
+\r
+void address_matcher_unref (gpointer instance) {\r
+       AddressMatcher* self;\r
+       self = instance;\r
+       if (g_atomic_int_dec_and_test (&self->ref_count)) {\r
+               ADDRESS_MATCHER_GET_CLASS (self)->finalize (self);\r
+               g_type_free_instance ((GTypeInstance *) self);\r
+       }\r
+}\r
+\r
+\r
+gint _vala_main (char** args, int args_length1) {\r
+       gint result = 0;\r
+       AddressMatcher* app;\r
+       app = address_matcher_new ();\r
+       address_matcher_run (app, args[1]);\r
+       result = 0;\r
+       _address_matcher_unref0 (app);\r
+       return result;\r
+}\r
+\r
+\r
+int main (int argc, char ** argv) {\r
+       g_type_init ();\r
+       return _vala_main (argv, argc);\r
+}\r
+\r
+\r
+static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {\r
+       if ((array != NULL) && (destroy_func != NULL)) {\r
+               int i;\r
+               for (i = 0; i < array_length; i = i + 1) {\r
+                       if (((gpointer*) array)[i] != NULL) {\r
+                               destroy_func (((gpointer*) array)[i]);\r
+                       }\r
+               }\r
+       }\r
+}\r
+\r
+\r
+static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {\r
+       _vala_array_destroy (array, array_length, destroy_func);\r
+       g_free (array);\r
+}\r
+\r
+\r
+\r
+\r
+\r
+--=-=-=\r
+\r
+\r
+Sebastian\r
+\r
+--=-=-=--\r