[evolution-data-server/wip/camel-more-gobject] Seal CamelAddress properties

[Milan Crha <mcrha src gnome org>]

commit a96d4914c42a4644173351383f5f7fcc01a1f374
Author: Milan Crha <mcrha redhat com>
Date:   Wed Nov 2 17:08:28 2016 +0100

    Seal CamelAddress properties

 src/camel/camel-address.c          |   42 +++++++-------
 src/camel/camel-address.h          |    3 +-
 src/camel/camel-internet-address.c |  113 +++++++++++++++++++++++++-----------
 src/camel/camel-nntp-address.c     |   92 +++++++++++++++++++++--------
 src/camel/camel-nntp-address.h     |    4 +-
 5 files changed, 169 insertions(+), 85 deletions(-)
---
diff --git a/src/camel/camel-address.c b/src/camel/camel-address.c
index 9b6e6d3..8897cd1 100644
--- a/src/camel/camel-address.c
+++ b/src/camel/camel-address.c
@@ -18,33 +18,22 @@
 
 #include "camel-address.h"
 
-G_DEFINE_TYPE (CamelAddress, camel_address, G_TYPE_OBJECT)
-
-static void
-address_finalize (GObject *object)
-{
-       CamelAddress *address = CAMEL_ADDRESS (object);
+struct _CamelAddressPrivate {
+       guint dummy;
+};
 
-       camel_address_remove (address, -1);
-       g_ptr_array_free (address->addresses, TRUE);
-
-       /* Chain up to parent's finalize() method. */
-       G_OBJECT_CLASS (camel_address_parent_class)->finalize (object);
-}
+G_DEFINE_TYPE (CamelAddress, camel_address, G_TYPE_OBJECT)
 
 static void
 camel_address_class_init (CamelAddressClass *class)
 {
-       GObjectClass *object_class;
-
-       object_class = G_OBJECT_CLASS (class);
-       object_class->finalize = address_finalize;
+       g_type_class_add_private (class, sizeof (CamelAddressPrivate));
 }
 
 static void
 camel_address_init (CamelAddress *address)
 {
-       address->addresses = g_ptr_array_new ();
+       address->priv = G_TYPE_INSTANCE_GET_PRIVATE (address, CAMEL_TYPE_ADDRESS, CamelAddressPrivate);
 }
 
 /**
@@ -90,7 +79,14 @@ camel_address_new_clone (CamelAddress *addr)
 gint
 camel_address_length (CamelAddress *addr)
 {
-       return addr->addresses->len;
+       CamelAddressClass *class;
+
+       g_return_val_if_fail (CAMEL_IS_ADDRESS (addr), -1);
+
+       class = CAMEL_ADDRESS_GET_CLASS (addr);
+       g_return_val_if_fail (class->length != NULL, -1);
+
+       return class->length (addr);
 }
 
 /**
@@ -236,7 +232,7 @@ camel_address_copy (CamelAddress *dest,
  **/
 void
 camel_address_remove (CamelAddress *addr,
-                      gint index)
+                     gint index)
 {
        CamelAddressClass *class;
 
@@ -246,8 +242,12 @@ camel_address_remove (CamelAddress *addr,
        g_return_if_fail (class->remove != NULL);
 
        if (index == -1) {
-               for (index = addr->addresses->len; index>-1; index--)
+               gint len = camel_address_length (addr);
+
+               for (index = len - 1; index >= 0; index--) {
                        class->remove (addr, index);
-       } else
+               }
+       } else {
                class->remove (addr, index);
+       }
 }
diff --git a/src/camel/camel-address.h b/src/camel/camel-address.h
index 31c52a5..6965eb2 100644
--- a/src/camel/camel-address.h
+++ b/src/camel/camel-address.h
@@ -54,14 +54,13 @@ typedef struct _CamelAddressPrivate CamelAddressPrivate;
 struct _CamelAddress {
        GObject parent;
 
-       GPtrArray *addresses;
-
        CamelAddressPrivate *priv;
 };
 
 struct _CamelAddressClass {
        GObjectClass parent_class;
 
+       gint            (*length)               (CamelAddress *addr);
        gint            (*decode)               (CamelAddress *addr,
                                                 const gchar *raw);
        gchar *         (*encode)               (CamelAddress *addr);
diff --git a/src/camel/camel-internet-address.c b/src/camel/camel-internet-address.c
index 42f87ca..ef7ee51 100644
--- a/src/camel/camel-internet-address.c
+++ b/src/camel/camel-internet-address.c
@@ -25,6 +25,10 @@
 
 #define d(x)
 
+struct _CamelInternetAddressPrivate {
+       GPtrArray *addresses;
+};
+
 struct _address {
        gchar *name;
        gchar *address;
@@ -33,11 +37,21 @@ struct _address {
 G_DEFINE_TYPE (CamelInternetAddress, camel_internet_address, CAMEL_TYPE_ADDRESS)
 
 static gint
-internet_address_decode (CamelAddress *a,
+internet_address_length (CamelAddress *paddr)
+{
+       CamelInternetAddress *inet_addr = CAMEL_INTERNET_ADDRESS (paddr);
+
+       g_return_val_if_fail (inet_addr != NULL, -1);
+
+       return inet_addr->priv->addresses->len;
+}
+
+static gint
+internet_address_decode (CamelAddress *addr,
                          const gchar *raw)
 {
        CamelHeaderAddress *ha, *n;
-       gint count = a->addresses->len;
+       gint count = camel_address_length (addr);
 
        /* Should probably use its own decoder or something */
        ha = camel_header_address_decode (raw, NULL);
@@ -45,12 +59,12 @@ internet_address_decode (CamelAddress *a,
                n = ha;
                while (n) {
                        if (n->type == CAMEL_HEADER_ADDRESS_NAME) {
-                               camel_internet_address_add ((CamelInternetAddress *) a, n->name, n->v.addr);
+                               camel_internet_address_add ((CamelInternetAddress *) addr, n->name, 
n->v.addr);
                        } else if (n->type == CAMEL_HEADER_ADDRESS_GROUP) {
                                CamelHeaderAddress *g = n->v.members;
                                while (g) {
                                        if (g->type == CAMEL_HEADER_ADDRESS_NAME)
-                                               camel_internet_address_add ((CamelInternetAddress *) a, 
g->name, g->v.addr);
+                                               camel_internet_address_add ((CamelInternetAddress *) addr, 
g->name, g->v.addr);
                                        /* otherwise, it's an error, infact */
                                        g = g->next;
                                }
@@ -60,24 +74,25 @@ internet_address_decode (CamelAddress *a,
                camel_header_address_list_clear (&ha);
        }
 
-       return a->addresses->len - count;
+       return camel_address_length (addr) - count;
 }
 
 static gchar *
-internet_address_encode (CamelAddress *a)
+internet_address_encode (CamelAddress *paddr)
 {
+       CamelInternetAddress *inet_addr = CAMEL_INTERNET_ADDRESS (paddr);
        gint i;
        GString *out;
        gchar *ret;
        gint len = 6;           /* "From: ", assume longer of the address headers */
 
-       if (a->addresses->len == 0)
+       if (inet_addr->priv->addresses->len == 0)
                return NULL;
 
        out = g_string_new ("");
 
-       for (i = 0; i < a->addresses->len; i++) {
-               struct _address *addr = g_ptr_array_index (a->addresses, i);
+       for (i = 0; i < inet_addr->priv->addresses->len; i++) {
+               struct _address *addr = g_ptr_array_index (inet_addr->priv->addresses, i);
                gchar *enc;
 
                if (i != 0)
@@ -95,12 +110,13 @@ internet_address_encode (CamelAddress *a)
 }
 
 static gint
-internet_address_unformat (CamelAddress *a,
+internet_address_unformat (CamelAddress *paddr,
                            const gchar *raw)
 {
+       CamelInternetAddress *inet_addr = CAMEL_INTERNET_ADDRESS (paddr);
        gchar *buffer, *p, *name, *addr;
        gint c;
-       gint count = a->addresses->len;
+       gint count = inet_addr->priv->addresses->len;
 
        if (raw == NULL)
                return 0;
@@ -148,7 +164,7 @@ internet_address_unformat (CamelAddress *a,
                        addr = g_strstrip (addr);
                        if (addr[0]) {
                                d (printf ("found address: '%s' <%s>\n", name, addr));
-                               camel_internet_address_add ((CamelInternetAddress *) a, name, addr);
+                               camel_internet_address_add (inet_addr, name, addr);
                        }
                        name = NULL;
                        addr = p;
@@ -158,23 +174,24 @@ internet_address_unformat (CamelAddress *a,
 
        g_free (buffer);
 
-       return a->addresses->len - count;
+       return inet_addr->priv->addresses->len - count;
 }
 
 static gchar *
-internet_address_format (CamelAddress *a)
+internet_address_format (CamelAddress *paddr)
 {
+       CamelInternetAddress *inet_addr = CAMEL_INTERNET_ADDRESS (paddr);
        gint i;
        GString *out;
        gchar *ret;
 
-       if (a->addresses->len == 0)
+       if (inet_addr->priv->addresses->len == 0)
                return NULL;
 
        out = g_string_new ("");
 
-       for (i = 0; i < a->addresses->len; i++) {
-               struct _address *addr = g_ptr_array_index (a->addresses, i);
+       for (i = 0; i < inet_addr->priv->addresses->len; i++) {
+               struct _address *addr = g_ptr_array_index (inet_addr->priv->addresses, i);
                gchar *enc;
 
                if (i != 0)
@@ -192,43 +209,69 @@ internet_address_format (CamelAddress *a)
 }
 
 static void
-internet_address_remove (CamelAddress *a,
+internet_address_remove (CamelAddress *paddr,
                          gint index)
 {
+       CamelInternetAddress *inet_addr = CAMEL_INTERNET_ADDRESS (paddr);
        struct _address *addr;
 
-       if (index < 0 || index >= a->addresses->len)
+       if (index < 0 || index >= inet_addr->priv->addresses->len)
                return;
 
-       addr = g_ptr_array_index (a->addresses, index);
+       addr = g_ptr_array_index (inet_addr->priv->addresses, index);
        g_free (addr->name);
        g_free (addr->address);
        g_free (addr);
-       g_ptr_array_remove_index (a->addresses, index);
+       g_ptr_array_remove_index (inet_addr->priv->addresses, index);
 }
 
 static gint
 internet_address_cat (CamelAddress *dest,
                       CamelAddress *source)
 {
+       CamelInternetAddress *dest_inet_addr;
+       CamelInternetAddress *source_inet_addr;
        gint i;
 
+       g_return_val_if_fail (CAMEL_IS_INTERNET_ADDRESS (dest), -1);
        g_return_val_if_fail (CAMEL_IS_INTERNET_ADDRESS (source), -1);
 
-       for (i = 0; i < source->addresses->len; i++) {
-               struct _address *addr = g_ptr_array_index (source->addresses, i);
-               camel_internet_address_add ((CamelInternetAddress *) dest, addr->name, addr->address);
+       dest_inet_addr = CAMEL_INTERNET_ADDRESS (dest);
+       source_inet_addr = CAMEL_INTERNET_ADDRESS (source);
+
+       for (i = 0; i < source_inet_addr->priv->addresses->len; i++) {
+               struct _address *addr = g_ptr_array_index (source_inet_addr->priv->addresses, i);
+               camel_internet_address_add (dest_inet_addr, addr->name, addr->address);
        }
 
        return i;
 }
 
 static void
+internet_address_finalize (GObject *object)
+{
+       CamelInternetAddress *inet_addr = CAMEL_INTERNET_ADDRESS (object);
+
+       camel_address_remove (CAMEL_ADDRESS (inet_addr), -1);
+       g_ptr_array_free (inet_addr->priv->addresses, TRUE);
+
+       /* Chain up to parent's finalize() method. */
+       G_OBJECT_CLASS (camel_internet_address_parent_class)->finalize (object);
+}
+
+static void
 camel_internet_address_class_init (CamelInternetAddressClass *class)
 {
        CamelAddressClass *address_class;
+       GObjectClass *object_class;
+
+       g_type_class_add_private (class, sizeof (CamelInternetAddressPrivate));
+
+       object_class = G_OBJECT_CLASS (class);
+       object_class->finalize = internet_address_finalize;
 
        address_class = CAMEL_ADDRESS_CLASS (class);
+       address_class->length = internet_address_length;
        address_class->decode = internet_address_decode;
        address_class->encode = internet_address_encode;
        address_class->unformat = internet_address_unformat;
@@ -240,6 +283,8 @@ camel_internet_address_class_init (CamelInternetAddressClass *class)
 static void
 camel_internet_address_init (CamelInternetAddress *internet_address)
 {
+       internet_address->priv = G_TYPE_INSTANCE_GET_PRIVATE (internet_address, CAMEL_TYPE_INTERNET_ADDRESS, 
CamelInternetAddressPrivate);
+       internet_address->priv->addresses = g_ptr_array_new ();
 }
 
 /**
@@ -278,8 +323,8 @@ camel_internet_address_add (CamelInternetAddress *addr,
        new = g_malloc (sizeof (*new));
        new->name = g_strdup (name);
        new->address = g_strdup (address);
-       index = ((CamelAddress *) addr)->addresses->len;
-       g_ptr_array_add (((CamelAddress *) addr)->addresses, new);
+       index = addr->priv->addresses->len;
+       g_ptr_array_add (addr->priv->addresses, new);
 
        return index;
 }
@@ -305,10 +350,10 @@ camel_internet_address_get (CamelInternetAddress *addr,
 
        g_return_val_if_fail (CAMEL_IS_INTERNET_ADDRESS (addr), FALSE);
 
-       if (index < 0 || index >= ((CamelAddress *) addr)->addresses->len)
+       if (index < 0 || index >= addr->priv->addresses->len)
                return FALSE;
 
-       a = g_ptr_array_index (((CamelAddress *) addr)->addresses, index);
+       a = g_ptr_array_index (addr->priv->addresses, index);
        if (namep)
                *namep = a->name;
        if (addressp)
@@ -337,9 +382,9 @@ camel_internet_address_find_name (CamelInternetAddress *addr,
 
        g_return_val_if_fail (CAMEL_IS_INTERNET_ADDRESS (addr), -1);
 
-       len = ((CamelAddress *) addr)->addresses->len;
+       len = addr->priv->addresses->len;
        for (i = 0; i < len; i++) {
-               a = g_ptr_array_index (((CamelAddress *) addr)->addresses, i);
+               a = g_ptr_array_index (addr->priv->addresses, i);
                if (a->name && !strcmp (a->name, name)) {
                        if (addressp)
                                *addressp = a->address;
@@ -391,10 +436,10 @@ camel_internet_address_ensure_ascii_domains (CamelInternetAddress *addr)
 
        g_return_if_fail (CAMEL_IS_INTERNET_ADDRESS (addr));
 
-       len = ((CamelAddress *) addr)->addresses->len;
+       len = addr->priv->addresses->len;
        for (i = 0; i < len; i++) {
                gint at_pos = -1;
-               a = g_ptr_array_index (((CamelAddress *) addr)->addresses, i);
+               a = g_ptr_array_index (addr->priv->addresses, i);
                if (a->address && !domain_contains_only_ascii (a->address, &at_pos)) {
                        gchar *address, *domain;
 
@@ -434,9 +479,9 @@ camel_internet_address_find_address (CamelInternetAddress *addr,
 
        g_return_val_if_fail (CAMEL_IS_INTERNET_ADDRESS (addr), -1);
 
-       len = ((CamelAddress *) addr)->addresses->len;
+       len = addr->priv->addresses->len;
        for (i = 0; i < len; i++) {
-               a = g_ptr_array_index (((CamelAddress *) addr)->addresses, i);
+               a = g_ptr_array_index (addr->priv->addresses, i);
                if (!strcmp (a->address, address)) {
                        if (namep)
                                *namep = a->name;
diff --git a/src/camel/camel-nntp-address.c b/src/camel/camel-nntp-address.c
index 3e16a29..60729dc 100644
--- a/src/camel/camel-nntp-address.c
+++ b/src/camel/camel-nntp-address.c
@@ -24,20 +24,30 @@
 
 #define d(x)
 
-struct _address {
-       gchar *name;
-       gchar *address;
+struct _CamelNNTPAddressPrivate {
+       GPtrArray *addresses;
 };
 
 G_DEFINE_TYPE (CamelNNTPAddress, camel_nntp_address, CAMEL_TYPE_ADDRESS)
 
+static gint
+nntp_address_length (CamelAddress *paddr)
+{
+       CamelNNTPAddress *nntp_addr = CAMEL_NNTP_ADDRESS (paddr);
+
+       g_return_val_if_fail (nntp_addr != NULL, -1);
+
+       return nntp_addr->priv->addresses->len;
+}
+
 /* since newsgropus are 7bit ascii, decode/unformat are the same */
 static gint
 nntp_address_decode (CamelAddress *address,
                      const gchar *raw)
 {
+       CamelNNTPAddress *nntp_addr = CAMEL_NNTP_ADDRESS (address);
        GSList *ha, *n;
-       gint count = address->addresses->len;
+       gint count = nntp_addr->priv->addresses->len;
 
        ha = camel_header_newsgroups_decode (raw);
        for (n = ha; n != NULL; n = n->next) {
@@ -45,27 +55,28 @@ nntp_address_decode (CamelAddress *address,
        }
 
        g_slist_free_full (ha, g_free);
-       return address->addresses->len - count;
+       return nntp_addr->priv->addresses->len - count;
 }
 
 /* since newsgropus are 7bit ascii, encode/format are the same */
 static gchar *
 nntp_address_encode (CamelAddress *address)
 {
+       CamelNNTPAddress *nntp_addr = CAMEL_NNTP_ADDRESS (address);
        gint i;
        GString *out;
        gchar *ret;
 
-       if (address->addresses->len == 0)
+       if (nntp_addr->priv->addresses->len == 0)
                return NULL;
 
        out = g_string_new ("");
 
-       for (i = 0; i < address->addresses->len; i++) {
+       for (i = 0; i < nntp_addr->priv->addresses->len; i++) {
                if (i != 0)
                        g_string_append (out, ", ");
 
-               g_string_append (out, g_ptr_array_index (address->addresses, i));
+               g_string_append (out, g_ptr_array_index (nntp_addr->priv->addresses, i));
        }
 
        ret = out->str;
@@ -78,14 +89,19 @@ static gint
 nntp_address_cat (CamelAddress *dest,
                   CamelAddress *source)
 {
+       CamelNNTPAddress *dest_nntp_addr;
+       CamelNNTPAddress *source_nntp_addr;
        gint ii;
 
+       g_return_val_if_fail (CAMEL_IS_NNTP_ADDRESS (dest), -1);
        g_return_val_if_fail (CAMEL_IS_NNTP_ADDRESS (source), -1);
 
-       for (ii = 0; ii < source->addresses->len; ii++)
-               camel_nntp_address_add (
-                       CAMEL_NNTP_ADDRESS (dest),
-                       g_ptr_array_index (source->addresses, ii));
+       dest_nntp_addr = CAMEL_NNTP_ADDRESS (dest);
+       source_nntp_addr = CAMEL_NNTP_ADDRESS (source);
+
+       for (ii = 0; ii < source_nntp_addr->priv->addresses->len; ii++) {
+               camel_nntp_address_add (dest_nntp_addr, g_ptr_array_index (source_nntp_addr->priv->addresses, 
ii));
+       }
 
        return ii;
 }
@@ -94,19 +110,41 @@ static void
 nntp_address_remove (CamelAddress *address,
                      gint index)
 {
-       if (index < 0 || index >= address->addresses->len)
+       CamelNNTPAddress *nntp_addr = CAMEL_NNTP_ADDRESS (address);
+
+       if (index < 0 || index >= nntp_addr->priv->addresses->len)
                return;
 
-       g_free (g_ptr_array_index (address->addresses, index));
-       g_ptr_array_remove_index (address->addresses, index);
+       g_free (g_ptr_array_index (nntp_addr->priv->addresses, index));
+       g_ptr_array_remove_index (nntp_addr->priv->addresses, index);
+}
+
+
+static void
+nntp_address_finalize (GObject *object)
+{
+       CamelNNTPAddress *nntp_addr = CAMEL_NNTP_ADDRESS (object);
+
+       camel_address_remove (CAMEL_ADDRESS (nntp_addr), -1);
+       g_ptr_array_free (nntp_addr->priv->addresses, TRUE);
+
+       /* Chain up to parent's finalize() method. */
+       G_OBJECT_CLASS (camel_nntp_address_parent_class)->finalize (object);
 }
 
 static void
 camel_nntp_address_class_init (CamelNNTPAddressClass *class)
 {
        CamelAddressClass *address_class;
+       GObjectClass *object_class;
+
+       g_type_class_add_private (class, sizeof (CamelNNTPAddressPrivate));
+
+       object_class = G_OBJECT_CLASS (class);
+       object_class->finalize = nntp_address_finalize;
 
        address_class = CAMEL_ADDRESS_CLASS (class);
+       address_class->length = nntp_address_length;
        address_class->decode = nntp_address_decode;
        address_class->encode = nntp_address_encode;
        address_class->unformat = nntp_address_decode;
@@ -118,6 +156,8 @@ camel_nntp_address_class_init (CamelNNTPAddressClass *class)
 static void
 camel_nntp_address_init (CamelNNTPAddress *nntp_address)
 {
+       nntp_address->priv = G_TYPE_INSTANCE_GET_PRIVATE (nntp_address, CAMEL_TYPE_NNTP_ADDRESS, 
CamelNNTPAddressPrivate);
+       nntp_address->priv->addresses = g_ptr_array_new ();
 }
 
 /**
@@ -135,7 +175,7 @@ camel_nntp_address_new (void)
 
 /**
  * camel_nntp_address_add:
- * @a: nntp address object
+ * @addr: nntp address object
  * @name:
  *
  * Add a new nntp address to the address object.  Duplicates are not added twice.
@@ -143,26 +183,26 @@ camel_nntp_address_new (void)
  * Returns: Index of added entry, or existing matching entry.
  **/
 gint
-camel_nntp_address_add (CamelNNTPAddress *a,
+camel_nntp_address_add (CamelNNTPAddress *addr,
                         const gchar *name)
 {
        gint index, i;
 
-       g_return_val_if_fail (CAMEL_IS_NNTP_ADDRESS (a), -1);
+       g_return_val_if_fail (CAMEL_IS_NNTP_ADDRESS (addr), -1);
 
-       index = ((CamelAddress *) a)->addresses->len;
+       index = addr->priv->addresses->len;
        for (i = 0; i < index; i++)
-               if (!strcmp (g_ptr_array_index (((CamelAddress *) a)->addresses, i), name))
+               if (!strcmp (g_ptr_array_index (addr->priv->addresses, i), name))
                        return i;
 
-       g_ptr_array_add (((CamelAddress *) a)->addresses, g_strdup (name));
+       g_ptr_array_add (addr->priv->addresses, g_strdup (name));
 
        return index;
 }
 
 /**
  * camel_nntp_address_get:
- * @a: nntp address object
+ * @addr: nntp address object
  * @index: address's array index
  * @namep: Holder for the returned address, or NULL, if not required.
  *
@@ -171,17 +211,17 @@ camel_nntp_address_add (CamelNNTPAddress *a,
  * Returns: TRUE if such an address exists, or FALSE otherwise.
  **/
 gboolean
-camel_nntp_address_get (CamelNNTPAddress *a,
+camel_nntp_address_get (CamelNNTPAddress *addr,
                         gint index,
                         const gchar **namep)
 {
-       g_return_val_if_fail (CAMEL_IS_NNTP_ADDRESS (a), FALSE);
+       g_return_val_if_fail (CAMEL_IS_NNTP_ADDRESS (addr), FALSE);
 
-       if (index < 0 || index >= ((CamelAddress *) a)->addresses->len)
+       if (index < 0 || index >= addr->priv->addresses->len)
                return FALSE;
 
        if (namep)
-               *namep = g_ptr_array_index( ((CamelAddress *)a)->addresses, index);
+               *namep = g_ptr_array_index (addr->priv->addresses, index);
 
        return TRUE;
 }
diff --git a/src/camel/camel-nntp-address.h b/src/camel/camel-nntp-address.h
index da60b0b..4831aa7 100644
--- a/src/camel/camel-nntp-address.h
+++ b/src/camel/camel-nntp-address.h
@@ -66,9 +66,9 @@ struct _CamelNNTPAddressClass {
 GType          camel_nntp_address_get_type     (void);
 CamelNNTPAddress *
                camel_nntp_address_new          (void);
-gint           camel_nntp_address_add          (CamelNNTPAddress *a,
+gint           camel_nntp_address_add          (CamelNNTPAddress *addr,
                                                 const gchar *name);
-gboolean       camel_nntp_address_get          (CamelNNTPAddress *a,
+gboolean       camel_nntp_address_get          (CamelNNTPAddress *addr,
                                                 gint index,
                                                 const gchar **namep);