Mercurial > pidgin3 / file comparison

comparison: libgaim/value.c

libgaim/value.c

branch
gaim
changeset 20470
77693555855f
parent 8809
4fc1959df5ce
parent 14254
77edc7a6191a
child 20471
1966704b3e42
equal deleted inserted replaced
13071:b98e72d4089a 20470:77693555855f
1 /**
2 * @file value.c Value wrapper API
3 * @ingroup core
4 *
5 * gaim
6 *
7 * Gaim is the legal property of its developers, whose names are too numerous
8 * to list here. Please refer to the COPYRIGHT file distributed with this
9 * source distribution.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25 #include "internal.h"
26
27 #include "value.h"
28
29 #define OUTGOING_FLAG 0x01
30
31 GaimValue *
32 gaim_value_new(GaimType type, ...)
33 {
34 GaimValue *value;
35 va_list args;
36
37 g_return_val_if_fail(type != GAIM_TYPE_UNKNOWN, NULL);
38
39 value = g_new0(GaimValue, 1);
40
41 value->type = type;
42
43 va_start(args, type);
44
45 if (type == GAIM_TYPE_SUBTYPE)
46 value->u.subtype = va_arg(args, int);
47 else if (type == GAIM_TYPE_BOXED)
48 value->u.specific_type = g_strdup(va_arg(args, char *));
49
50 va_end(args);
51
52 return value;
53 }
54
55 GaimValue *
56 gaim_value_new_outgoing(GaimType type, ...)
57 {
58 GaimValue *value;
59 va_list args;
60
61 g_return_val_if_fail(type != GAIM_TYPE_UNKNOWN, NULL);
62
63 value = g_new0(GaimValue, 1);
64
65 value->type = type;
66
67 va_start(args, type);
68
69 if (type == GAIM_TYPE_SUBTYPE)
70 value->u.subtype = va_arg(args, int);
71 else if (type == GAIM_TYPE_BOXED)
72 value->u.specific_type = g_strdup(va_arg(args, char *));
73
74 va_end(args);
75
76 value->flags |= OUTGOING_FLAG;
77
78 return value;
79 }
80
81 void
82 gaim_value_destroy(GaimValue *value)
83 {
84 g_return_if_fail(value != NULL);
85
86 if (gaim_value_get_type(value) == GAIM_TYPE_BOXED)
87 {
88 g_free(value->u.specific_type);
89 }
90 else if (gaim_value_get_type(value) == GAIM_TYPE_STRING)
91 {
92 g_free(value->data.string_data);
93 }
94
95 g_free(value);
96 }
97
98 GaimValue *
99 gaim_value_dup(const GaimValue *value)
100 {
101 GaimValue *new_value;
102 GaimType type;
103
104 g_return_val_if_fail(value != NULL, NULL);
105
106 type = gaim_value_get_type(value);
107
108 if (type == GAIM_TYPE_SUBTYPE)
109 {
110 new_value = gaim_value_new(GAIM_TYPE_SUBTYPE,
111 gaim_value_get_subtype(value));
112 }
113 else if (type == GAIM_TYPE_BOXED)
114 {
115 new_value = gaim_value_new(GAIM_TYPE_BOXED,
116 gaim_value_get_specific_type(value));
117 }
118 else
119 new_value = gaim_value_new(type);
120
121 new_value->flags = value->flags;
122
123 switch (type)
124 {
125 case GAIM_TYPE_CHAR:
126 gaim_value_set_char(new_value, gaim_value_get_char(value));
127 break;
128
129 case GAIM_TYPE_UCHAR:
130 gaim_value_set_uchar(new_value, gaim_value_get_uchar(value));
131 break;
132
133 case GAIM_TYPE_BOOLEAN:
134 gaim_value_set_boolean(new_value, gaim_value_get_boolean(value));
135 break;
136
137 case GAIM_TYPE_SHORT:
138 gaim_value_set_short(new_value, gaim_value_get_short(value));
139 break;
140
141 case GAIM_TYPE_USHORT:
142 gaim_value_set_ushort(new_value, gaim_value_get_ushort(value));
143 break;
144
145 case GAIM_TYPE_INT:
146 gaim_value_set_int(new_value, gaim_value_get_int(value));
147 break;
148
149 case GAIM_TYPE_UINT:
150 gaim_value_set_uint(new_value, gaim_value_get_uint(value));
151 break;
152
153 case GAIM_TYPE_LONG:
154 gaim_value_set_long(new_value, gaim_value_get_long(value));
155 break;
156
157 case GAIM_TYPE_ULONG:
158 gaim_value_set_ulong(new_value, gaim_value_get_ulong(value));
159 break;
160
161 case GAIM_TYPE_INT64:
162 gaim_value_set_int64(new_value, gaim_value_get_int64(value));
163 break;
164
165 case GAIM_TYPE_UINT64:
166 gaim_value_set_uint64(new_value, gaim_value_get_uint64(value));
167 break;
168
169 case GAIM_TYPE_STRING:
170 gaim_value_set_string(new_value, gaim_value_get_string(value));
171 break;
172
173 case GAIM_TYPE_OBJECT:
174 gaim_value_set_object(new_value, gaim_value_get_object(value));
175 break;
176
177 case GAIM_TYPE_POINTER:
178 gaim_value_set_pointer(new_value, gaim_value_get_pointer(value));
179 break;
180
181 case GAIM_TYPE_ENUM:
182 gaim_value_set_enum(new_value, gaim_value_get_enum(value));
183 break;
184
185 case GAIM_TYPE_BOXED:
186 gaim_value_set_boxed(new_value, gaim_value_get_boxed(value));
187 break;
188
189 default:
190 break;
191 }
192
193 return new_value;
194 }
195
196 GaimType
197 gaim_value_get_type(const GaimValue *value)
198 {
199 g_return_val_if_fail(value != NULL, GAIM_TYPE_UNKNOWN);
200
201 return value->type;
202 }
203
204 unsigned int
205 gaim_value_get_subtype(const GaimValue *value)
206 {
207 g_return_val_if_fail(value != NULL, 0);
208 g_return_val_if_fail(gaim_value_get_type(value) == GAIM_TYPE_SUBTYPE, 0);
209
210 return value->u.subtype;
211 }
212
213 const char *
214 gaim_value_get_specific_type(const GaimValue *value)
215 {
216 g_return_val_if_fail(value != NULL, NULL);
217 g_return_val_if_fail(gaim_value_get_type(value) == GAIM_TYPE_BOXED, NULL);
218
219 return value->u.specific_type;
220 }
221
222 gboolean
223 gaim_value_is_outgoing(const GaimValue *value)
224 {
225 g_return_val_if_fail(value != NULL, FALSE);
226
227 return (value->flags & OUTGOING_FLAG);
228 }
229
230 void
231 gaim_value_set_char(GaimValue *value, char data)
232 {
233 g_return_if_fail(value != NULL);
234
235 value->data.char_data = data;
236 }
237
238 void
239 gaim_value_set_uchar(GaimValue *value, unsigned char data)
240 {
241 g_return_if_fail(value != NULL);
242
243 value->data.uchar_data = data;
244 }
245
246 void
247 gaim_value_set_boolean(GaimValue *value, gboolean data)
248 {
249 g_return_if_fail(value != NULL);
250
251 value->data.boolean_data = data;
252 }
253
254 void
255 gaim_value_set_short(GaimValue *value, short data)
256 {
257 g_return_if_fail(value != NULL);
258
259 value->data.short_data = data;
260 }
261
262 void
263 gaim_value_set_ushort(GaimValue *value, unsigned short data)
264 {
265 g_return_if_fail(value != NULL);
266
267 value->data.ushort_data = data;
268 }
269
270 void
271 gaim_value_set_int(GaimValue *value, int data)
272 {
273 g_return_if_fail(value != NULL);
274
275 value->data.int_data = data;
276 }
277
278 void
279 gaim_value_set_uint(GaimValue *value, unsigned int data)
280 {
281 g_return_if_fail(value != NULL);
282
283 value->data.int_data = data;
284 }
285
286 void
287 gaim_value_set_long(GaimValue *value, long data)
288 {
289 g_return_if_fail(value != NULL);
290
291 value->data.long_data = data;
292 }
293
294 void
295 gaim_value_set_ulong(GaimValue *value, unsigned long data)
296 {
297 g_return_if_fail(value != NULL);
298
299 value->data.long_data = data;
300 }
301
302 void
303 gaim_value_set_int64(GaimValue *value, gint64 data)
304 {
305 g_return_if_fail(value != NULL);
306
307 value->data.int64_data = data;
308 }
309
310 void
311 gaim_value_set_uint64(GaimValue *value, guint64 data)
312 {
313 g_return_if_fail(value != NULL);
314
315 value->data.uint64_data = data;
316 }
317
318 void
319 gaim_value_set_string(GaimValue *value, const char *data)
320 {
321 g_return_if_fail(value != NULL);
322
323 g_free(value->data.string_data);
324 value->data.string_data = g_strdup(data);
325 }
326
327 void
328 gaim_value_set_object(GaimValue *value, void *data)
329 {
330 g_return_if_fail(value != NULL);
331
332 value->data.object_data = data;
333 }
334
335 void
336 gaim_value_set_pointer(GaimValue *value, void *data)
337 {
338 g_return_if_fail(value != NULL);
339
340 value->data.pointer_data = data;
341 }
342
343 void
344 gaim_value_set_enum(GaimValue *value, int data)
345 {
346 g_return_if_fail(value != NULL);
347
348 value->data.enum_data = data;
349 }
350
351 void
352 gaim_value_set_boxed(GaimValue *value, void *data)
353 {
354 g_return_if_fail(value != NULL);
355
356 value->data.boxed_data = data;
357 }
358
359 char
360 gaim_value_get_char(const GaimValue *value)
361 {
362 g_return_val_if_fail(value != NULL, 0);
363
364 return value->data.char_data;
365 }
366
367 unsigned char
368 gaim_value_get_uchar(const GaimValue *value)
369 {
370 g_return_val_if_fail(value != NULL, 0);
371
372 return value->data.uchar_data;
373 }
374
375 gboolean
376 gaim_value_get_boolean(const GaimValue *value)
377 {
378 g_return_val_if_fail(value != NULL, FALSE);
379
380 return value->data.boolean_data;
381 }
382
383 short
384 gaim_value_get_short(const GaimValue *value)
385 {
386 g_return_val_if_fail(value != NULL, 0);
387
388 return value->data.short_data;
389 }
390
391 unsigned short
392 gaim_value_get_ushort(const GaimValue *value)
393 {
394 g_return_val_if_fail(value != NULL, 0);
395
396 return value->data.ushort_data;
397 }
398
399 int
400 gaim_value_get_int(const GaimValue *value)
401 {
402 g_return_val_if_fail(value != NULL, 0);
403
404 return value->data.int_data;
405 }
406
407 unsigned int
408 gaim_value_get_uint(const GaimValue *value)
409 {
410 g_return_val_if_fail(value != NULL, 0);
411
412 return value->data.int_data;
413 }
414
415 long
416 gaim_value_get_long(const GaimValue *value)
417 {
418 g_return_val_if_fail(value != NULL, 0);
419
420 return value->data.long_data;
421 }
422
423 unsigned long
424 gaim_value_get_ulong(const GaimValue *value)
425 {
426 g_return_val_if_fail(value != NULL, 0);
427
428 return value->data.long_data;
429 }
430
431 gint64
432 gaim_value_get_int64(const GaimValue *value)
433 {
434 g_return_val_if_fail(value != NULL, 0);
435
436 return value->data.int64_data;
437 }
438
439 guint64
440 gaim_value_get_uint64(const GaimValue *value)
441 {
442 g_return_val_if_fail(value != NULL, 0);
443
444 return value->data.uint64_data;
445 }
446
447 const char *
448 gaim_value_get_string(const GaimValue *value)
449 {
450 g_return_val_if_fail(value != NULL, NULL);
451
452 return value->data.string_data;
453 }
454
455 void *
456 gaim_value_get_object(const GaimValue *value)
457 {
458 g_return_val_if_fail(value != NULL, NULL);
459
460 return value->data.object_data;
461 }
462
463 void *
464 gaim_value_get_pointer(const GaimValue *value)
465 {
466 g_return_val_if_fail(value != NULL, NULL);
467
468 return value->data.pointer_data;
469 }
470
471 int
472 gaim_value_get_enum(const GaimValue *value)
473 {
474 g_return_val_if_fail(value != NULL, -1);
475
476 return value->data.enum_data;
477 }
478
479 void *
480 gaim_value_get_boxed(const GaimValue *value)
481 {
482 g_return_val_if_fail(value != NULL, NULL);
483
484 return value->data.boxed_data;
485 }
486

Mercurial Repository: pidgin3

mercurial