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