camel/camel-address.c

   1 /*
   2  *  Copyright (C) 2000 Ximian Inc.
   3  *
   4  *  Authors: Michael Zucchi <notzed@ximian.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of version 2 of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "camel-address.h"
  22
  23
  24 static void camel_address_class_init (CamelAddressClass *klass);
  25 static void camel_address_init       (CamelAddress *obj);
  26 static void camel_address_finalize   (CamelObject *obj);
  27
  28 static CamelObjectClass *camel_address_parent;
  29
  30 static void
  31 camel_address_class_init (CamelAddressClass *klass)
  32 {
  33         camel_address_parent = camel_type_get_global_classfuncs (camel_object_get_type ());
  34 }
  35
  36 static void
  37 camel_address_init (CamelAddress *obj)
  38 {
  39         obj->addresses = g_ptr_array_new();
  40 }
  41
  42 static void
  43 camel_address_finalize (CamelObject *obj)
  44 {
  45         camel_address_remove((CamelAddress *)obj, -1);
  46         g_ptr_array_free(((CamelAddress *)obj)->addresses, TRUE);
  47 }
  48
  49 CamelType
  50 camel_address_get_type (void)
  51 {
  52         static CamelType type = CAMEL_INVALID_TYPE;
  53
  54         if (type == CAMEL_INVALID_TYPE) {
  55                 type = camel_type_register (camel_object_get_type (), "CamelAddress",
  56                                             sizeof (CamelAddress),
  57                                             sizeof (CamelAddressClass),
  58                                             (CamelObjectClassInitFunc) camel_address_class_init,
  59                                             NULL,
  60                                             (CamelObjectInitFunc) camel_address_init,
  61                                             (CamelObjectFinalizeFunc) camel_address_finalize);
  62         }
  63
  64         return type;
  65 }
  66
  67 /**
  68  * camel_address_new:
  69  *
  70  * Create a new #CamelAddress object.
  71  *
  72  * Returns a new #CamelAddress object
  73  **/
  74 CamelAddress *
  75 camel_address_new (void)
  76 {
  77         CamelAddress *new = CAMEL_ADDRESS(camel_object_new(camel_address_get_type()));
  78         return new;
  79 }
  80
  81
  82 /**
  83  * camel_address_new_clone:
  84  * @addr: a #CamelAddress object
  85  *
  86  * Clone an existing address type.
  87  *
  88  * Returns the cloned address
  89  **/
  90 CamelAddress *
  91 camel_address_new_clone (const CamelAddress *addr)
  92 {
  93         CamelAddress *new = CAMEL_ADDRESS(camel_object_new(CAMEL_OBJECT_GET_TYPE(addr)));
  94
  95         camel_address_cat(new, addr);
  96         return new;
  97 }
  98
  99
 100 /**
 101  * camel_address_length:
 102  * @addr: a #CamelAddress object
 103  *
 104  * Get the number of addresses stored in the address @addr.
 105  *
 106  * Returns the number of addresses contained in @addr
 107  **/
 108 int
 109 camel_address_length (CamelAddress *addr)
 110 {
 111         return addr->addresses->len;
 112 }
 113
 114
 115 /**
 116  * camel_address_decode:
 117  * @addr: a #CamelAddress object
 118  * @raw: raw address description
 119  *
 120  * Construct a new address from a raw address field.
 121  *
 122  * Returns the number of addresses parsed or %-1 on fail
 123  **/
 124 int
 125 camel_address_decode (CamelAddress *addr, const char *raw)
 126 {
 127         g_return_val_if_fail(CAMEL_IS_ADDRESS(addr), -1);
 128
 129         return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->decode(addr, raw);
 130 }
 131
 132
 133 /**
 134  * camel_address_encode:
 135  * @addr: a #CamelAddress object
 136  *
 137  * Encode an address in a format suitable for a raw header.
 138  *
 139  * Returns the encoded address
 140  **/
 141 char *
 142 camel_address_encode (CamelAddress *addr)
 143 {
 144         g_return_val_if_fail(CAMEL_IS_ADDRESS(addr), NULL);
 145
 146         return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->encode(addr);
 147 }
 148
 149
 150 /**
 151  * camel_address_unformat:
 152  * @addr: a #CamelAddress object
 153  * @raw: raw address description
 154  *
 155  * Attempt to convert a previously formatted and/or edited
 156  * address back into internal form.
 157  *
 158  * Returns the number of addresses parsed or %-1 on fail
 159  **/
 160 int
 161 camel_address_unformat(CamelAddress *addr, const char *raw)
 162 {
 163         g_return_val_if_fail(CAMEL_IS_ADDRESS(addr), -1);
 164
 165         return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->unformat(addr, raw);
 166 }
 167
 168
 169 /**
 170  * camel_address_format:
 171  * @addr: a #CamelAddress object
 172  *
 173  * Format an address in a format suitable for display.
 174  *
 175  * Returns a newly allocated string containing the formatted addresses
 176  **/
 177 char *
 178 camel_address_format (CamelAddress *addr)
 179 {
 180         g_return_val_if_fail(CAMEL_IS_ADDRESS(addr), NULL);
 181
 182         return CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->format(addr);
 183 }
 184
 185
 186 /**
 187  * camel_address_cat:
 188  * @dest: destination #CamelAddress object
 189  * @source: source #CamelAddress object
 190  *
 191  * Concatenate one address onto another. The addresses must
 192  * be of the same type.
 193  *
 194  * Returns the number of addresses concatenated
 195  **/
 196 int
 197 camel_address_cat (CamelAddress *dest, const CamelAddress *source)
 198 {
 199         g_return_val_if_fail(CAMEL_IS_ADDRESS(dest), -1);
 200         g_return_val_if_fail(CAMEL_IS_ADDRESS(source), -1);
 201
 202         return CAMEL_ADDRESS_CLASS(CAMEL_OBJECT_GET_CLASS(dest))->cat(dest, source);
 203 }
 204
 205
 206 /**
 207  * camel_address_copy:
 208  * @dest: destination #CamelAddress object
 209  * @source: source #CamelAddress object
 210  *
 211  * Copy the contents of one address into another.
 212  *
 213  * Returns the number of addresses copied
 214  **/
 215 int
 216 camel_address_copy (CamelAddress *dest, const CamelAddress *source)
 217 {
 218         g_return_val_if_fail(CAMEL_IS_ADDRESS(dest), -1);
 219         g_return_val_if_fail(CAMEL_IS_ADDRESS(source), -1);
 220
 221         camel_address_remove(dest, -1);
 222         return camel_address_cat(dest, source);
 223 }
 224
 225
 226 /**
 227  * camel_address_remove:
 228  * @addr: a #CamelAddress object
 229  * @index: The address to remove, use %-1 to remove all address.
 230  *
 231  * Remove an address by index, or all addresses.
 232  **/
 233 void
 234 camel_address_remove (CamelAddress *addr, int index)
 235 {
 236         g_return_if_fail(CAMEL_IS_ADDRESS(addr));
 237
 238         if (index == -1) {
 239                 for (index = addr->addresses->len; index>-1; index--)
 240                         CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->remove(addr, index);
 241         } else {
 242                 CAMEL_ADDRESS_CLASS (CAMEL_OBJECT_GET_CLASS (addr))->remove(addr, index);
 243         }
 244 }