Diffstat (limited to 'libical/src/libical/icalderivedparameter.c') (more/less context) (ignore whitespace changes)
-rw-r--r-- | libical/src/libical/icalderivedparameter.c | 1205 |
1 files changed, 1205 insertions, 0 deletions
diff --git a/libical/src/libical/icalderivedparameter.c b/libical/src/libical/icalderivedparameter.c new file mode 100644 index 0000000..6898eb6 --- a/dev/null +++ b/libical/src/libical/icalderivedparameter.c | |||
@@ -0,0 +1,1205 @@ | |||
1 | /* -*- Mode: C -*- | ||
2 | ====================================================================== | ||
3 | FILE: icalderivedparameters.{c,h} | ||
4 | CREATOR: eric 09 May 1999 | ||
5 | |||
6 | $Id$ | ||
7 | $Locker$ | ||
8 | |||
9 | |||
10 | (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org | ||
11 | |||
12 | This program is free software; you can redistribute it and/or modify | ||
13 | it under the terms of either: | ||
14 | |||
15 | The LGPL as published by the Free Software Foundation, version | ||
16 | 2.1, available at: http://www.fsf.org/copyleft/lesser.html | ||
17 | |||
18 | Or: | ||
19 | |||
20 | The Mozilla Public License Version 1.0. You may obtain a copy of | ||
21 | the License at http://www.mozilla.org/MPL/ | ||
22 | |||
23 | The original code is icalderivedparameters.{c,h} | ||
24 | |||
25 | Contributions from: | ||
26 | Graham Davison (g.m.davison@computer.org) | ||
27 | |||
28 | ======================================================================*/ | ||
29 | /*#line 29 "icalparameter.c.in"*/ | ||
30 | #ifdef HAVE_CONFIG_H | ||
31 | #include <config.h> | ||
32 | #endif | ||
33 | |||
34 | |||
35 | #include "icalparameter.h" | ||
36 | #include "icalparameterimpl.h" | ||
37 | |||
38 | #include "icalproperty.h" | ||
39 | #include "icalerror.h" | ||
40 | #include "icalmemory.h" | ||
41 | |||
42 | #include <stdlib.h> /* for malloc() */ | ||
43 | #include <errno.h> | ||
44 | #include <string.h> /* for memset() */ | ||
45 | |||
46 | icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value); | ||
47 | |||
48 | struct icalparameter_impl* icalparameter_new_impl(icalparameter_kind kind); | ||
49 | |||
50 | /* This map associates each of the parameters with the string | ||
51 | representation of the paramter's name */ | ||
52 | struct icalparameter_kind_map { | ||
53 | icalparameter_kind kind; | ||
54 | char *name; | ||
55 | |||
56 | }; | ||
57 | |||
58 | extern struct icalparameter_kind_map parameter_map[]; | ||
59 | |||
60 | |||
61 | const char* icalparameter_kind_to_string(icalparameter_kind kind) | ||
62 | { | ||
63 | int i; | ||
64 | |||
65 | for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) { | ||
66 | if (parameter_map[i].kind == kind) { | ||
67 | return parameter_map[i].name; | ||
68 | } | ||
69 | } | ||
70 | |||
71 | return 0; | ||
72 | |||
73 | } | ||
74 | |||
75 | icalparameter_kind icalparameter_string_to_kind(const char* string) | ||
76 | { | ||
77 | int i; | ||
78 | |||
79 | if (string ==0 ) { | ||
80 | return ICAL_NO_PARAMETER; | ||
81 | } | ||
82 | |||
83 | for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) { | ||
84 | |||
85 | if (strcmp(parameter_map[i].name, string) == 0) { | ||
86 | return parameter_map[i].kind; | ||
87 | } | ||
88 | } | ||
89 | |||
90 | if(strncmp(string,"X-",2)==0){ | ||
91 | return ICAL_X_PARAMETER; | ||
92 | } | ||
93 | |||
94 | return ICAL_NO_PARAMETER; | ||
95 | } | ||
96 | |||
97 | /* This map associates the enumerations for the VALUE parameter with | ||
98 | the kinds of VALUEs. */ | ||
99 | |||
100 | struct icalparameter_value_kind_map { | ||
101 | icalparameter_value value; | ||
102 | icalvalue_kind kind; | ||
103 | }; | ||
104 | |||
105 | extern struct icalparameter_value_kind_map value_kind_map[]; | ||
106 | |||
107 | |||
108 | icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value) | ||
109 | { | ||
110 | int i; | ||
111 | |||
112 | for (i=0; value_kind_map[i].kind != ICAL_NO_VALUE; i++) { | ||
113 | |||
114 | if (value_kind_map[i].value == value) { | ||
115 | return value_kind_map[i].kind; | ||
116 | } | ||
117 | } | ||
118 | |||
119 | return ICAL_NO_VALUE; | ||
120 | } | ||
121 | |||
122 | |||
123 | /* This map associates the parameter enumerations with a specific parameter and the string representation of the enumeration */ | ||
124 | |||
125 | struct icalparameter_map { | ||
126 | icalparameter_kind kind; | ||
127 | int enumeration; | ||
128 | const char* str; | ||
129 | }; | ||
130 | |||
131 | |||
132 | extern struct icalparameter_map icalparameter_map[]; | ||
133 | |||
134 | |||
135 | const char* icalparameter_enum_to_string(int e) | ||
136 | { | ||
137 | int i; | ||
138 | |||
139 | icalerror_check_arg_rz(e >= ICALPARAMETER_FIRST_ENUM,"e"); | ||
140 | icalerror_check_arg_rz(e <= ICALPARAMETER_LAST_ENUM,"e"); | ||
141 | |||
142 | for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){ | ||
143 | if(e == icalparameter_map[i].enumeration){ | ||
144 | return icalparameter_map[i].str; | ||
145 | } | ||
146 | } | ||
147 | |||
148 | return 0; | ||
149 | } | ||
150 | |||
151 | int icalparameter_string_to_enum(const char* str) | ||
152 | { | ||
153 | int i; | ||
154 | |||
155 | icalerror_check_arg_rz(str != 0,"str"); | ||
156 | |||
157 | for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){ | ||
158 | if(strcmp(str,icalparameter_map[i].str) == 0) { | ||
159 | return icalparameter_map[i].enumeration; | ||
160 | } | ||
161 | } | ||
162 | |||
163 | return 0; | ||
164 | } | ||
165 | |||
166 | icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind,const char* val) | ||
167 | { | ||
168 | |||
169 | struct icalparameter_impl* param=0; | ||
170 | int found_kind = 0; | ||
171 | int i; | ||
172 | |||
173 | icalerror_check_arg_rz((val!=0),"val"); | ||
174 | |||
175 | /* Search through the parameter map to find a matching kind */ | ||
176 | |||
177 | param = icalparameter_new_impl(kind); | ||
178 | |||
179 | for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){ | ||
180 | if(kind == icalparameter_map[i].kind) { | ||
181 | found_kind = 1; | ||
182 | if(strcmp(val,icalparameter_map[i].str) == 0) { | ||
183 | |||
184 | param->data = (int)icalparameter_map[i].enumeration; | ||
185 | return param; | ||
186 | } | ||
187 | } | ||
188 | } | ||
189 | |||
190 | if(found_kind == 1){ | ||
191 | /* The kind was in the parameter map, but the string did not | ||
192 | match, so assume that it is an alternate value, like an | ||
193 | X-value.*/ | ||
194 | |||
195 | icalparameter_set_xvalue(param, val); | ||
196 | |||
197 | } else { | ||
198 | |||
199 | /* If the kind was not found, then it must be a string type */ | ||
200 | |||
201 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(val); | ||
202 | |||
203 | } | ||
204 | |||
205 | return param; | ||
206 | } | ||
207 | |||
208 | |||
209 | |||
210 | |||
211 | /* Everything below this line is machine generated. Do not edit. */ | ||
212 | struct icalparameter_value_kind_map value_kind_map[] = { | ||
213 | {ICAL_VALUE_BINARY,ICAL_BINARY_VALUE}, | ||
214 | {ICAL_VALUE_BOOLEAN,ICAL_BOOLEAN_VALUE}, | ||
215 | {ICAL_VALUE_DATE,ICAL_DATE_VALUE}, | ||
216 | {ICAL_VALUE_DURATION,ICAL_DURATION_VALUE}, | ||
217 | {ICAL_VALUE_FLOAT,ICAL_FLOAT_VALUE}, | ||
218 | {ICAL_VALUE_INTEGER,ICAL_INTEGER_VALUE}, | ||
219 | {ICAL_VALUE_PERIOD,ICAL_PERIOD_VALUE}, | ||
220 | {ICAL_VALUE_RECUR,ICAL_RECUR_VALUE}, | ||
221 | {ICAL_VALUE_TEXT,ICAL_TEXT_VALUE}, | ||
222 | {ICAL_VALUE_URI,ICAL_URI_VALUE}, | ||
223 | {ICAL_VALUE_DATETIME,ICAL_DATETIME_VALUE}, | ||
224 | {ICAL_VALUE_UTCOFFSET,ICAL_UTCOFFSET_VALUE}, | ||
225 | {ICAL_VALUE_CALADDRESS,ICAL_CALADDRESS_VALUE}, | ||
226 | {ICAL_VALUE_X,ICAL_X_VALUE}, | ||
227 | {ICAL_VALUE_NONE,ICAL_NO_VALUE} | ||
228 | }; | ||
229 | |||
230 | static struct icalparameter_kind_map parameter_map[] = { | ||
231 | {ICAL_ALTREP_PARAMETER,"ALTREP"}, | ||
232 | {ICAL_CN_PARAMETER,"CN"}, | ||
233 | {ICAL_CUTYPE_PARAMETER,"CUTYPE"}, | ||
234 | {ICAL_DELEGATEDFROM_PARAMETER,"DELEGATED-FROM"}, | ||
235 | {ICAL_DELEGATEDTO_PARAMETER,"DELEGATED-TO"}, | ||
236 | {ICAL_DIR_PARAMETER,"DIR"}, | ||
237 | {ICAL_ENCODING_PARAMETER,"ENCODING"}, | ||
238 | {ICAL_FBTYPE_PARAMETER,"FBTYPE"}, | ||
239 | {ICAL_FMTTYPE_PARAMETER,"FMTTYPE"}, | ||
240 | {ICAL_LANGUAGE_PARAMETER,"LANGUAGE"}, | ||
241 | {ICAL_MEMBER_PARAMETER,"MEMBER"}, | ||
242 | {ICAL_PARTSTAT_PARAMETER,"PARTSTAT"}, | ||
243 | {ICAL_RANGE_PARAMETER,"RANGE"}, | ||
244 | {ICAL_RELATED_PARAMETER,"RELATED"}, | ||
245 | {ICAL_RELTYPE_PARAMETER,"RELTYPE"}, | ||
246 | {ICAL_ROLE_PARAMETER,"ROLE"}, | ||
247 | {ICAL_RSVP_PARAMETER,"RSVP"}, | ||
248 | {ICAL_SENTBY_PARAMETER,"SENT-BY"}, | ||
249 | {ICAL_TZID_PARAMETER,"TZID"}, | ||
250 | {ICAL_VALUE_PARAMETER,"VALUE"}, | ||
251 | {ICAL_X_PARAMETER,"X"}, | ||
252 | {ICAL_XLICCOMPARETYPE_PARAMETER,"X-LIC-COMPARETYPE"}, | ||
253 | {ICAL_XLICERRORTYPE_PARAMETER,"X-LIC-ERRORTYPE"}, | ||
254 | { ICAL_NO_PARAMETER, ""} | ||
255 | }; | ||
256 | |||
257 | static struct icalparameter_map icalparameter_map[] = { | ||
258 | {ICAL_ANY_PARAMETER,0,""}, | ||
259 | {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_INDIVIDUAL,"INDIVIDUAL"}, | ||
260 | {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_GROUP,"GROUP"}, | ||
261 | {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_RESOURCE,"RESOURCE"}, | ||
262 | {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_ROOM,"ROOM"}, | ||
263 | {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_UNKNOWN,"UNKNOWN"}, | ||
264 | {ICAL_ENCODING_PARAMETER,ICAL_ENCODING_8BIT,"8BIT"}, | ||
265 | {ICAL_ENCODING_PARAMETER,ICAL_ENCODING_BASE64,"BASE64"}, | ||
266 | {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_FREE,"FREE"}, | ||
267 | {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSY,"BUSY"}, | ||
268 | {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYUNAVAILABLE,"BUSYUNAVAILABLE"}, | ||
269 | {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYTENTATIVE,"BUSYTENTATIVE"}, | ||
270 | {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_NEEDSACTION,"NEEDS-ACTION"}, | ||
271 | {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_ACCEPTED,"ACCEPTED"}, | ||
272 | {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DECLINED,"DECLINED"}, | ||
273 | {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_TENTATIVE,"TENTATIVE"}, | ||
274 | {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DELEGATED,"DELEGATED"}, | ||
275 | {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_COMPLETED,"COMPLETED"}, | ||
276 | {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_INPROCESS,"INPROCESS"}, | ||
277 | {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDPRIOR,"THISANDPRIOR"}, | ||
278 | {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDFUTURE,"THISANDFUTURE"}, | ||
279 | {ICAL_RELATED_PARAMETER,ICAL_RELATED_START,"START"}, | ||
280 | {ICAL_RELATED_PARAMETER,ICAL_RELATED_END ,"END "}, | ||
281 | {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_PARENT,"PARENT"}, | ||
282 | {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_CHILD,"CHILD"}, | ||
283 | {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_SIBLING,"SIBLING"}, | ||
284 | {ICAL_ROLE_PARAMETER,ICAL_ROLE_CHAIR,"CHAIR"}, | ||
285 | {ICAL_ROLE_PARAMETER,ICAL_ROLE_REQPARTICIPANT,"REQ-PARTICIPANT"}, | ||
286 | {ICAL_ROLE_PARAMETER,ICAL_ROLE_OPTPARTICIPANT,"OPT-PARTICIPANT"}, | ||
287 | {ICAL_ROLE_PARAMETER,ICAL_ROLE_NONPARTICIPANT,"NON-PARTICIPANT"}, | ||
288 | {ICAL_RSVP_PARAMETER,ICAL_RSVP_TRUE,"TRUE"}, | ||
289 | {ICAL_RSVP_PARAMETER,ICAL_RSVP_FALSE,"FALSE"}, | ||
290 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_BINARY,"BINARY"}, | ||
291 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_BOOLEAN,"BOOLEAN"}, | ||
292 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_DATE,"DATE"}, | ||
293 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_DURATION,"DURATION"}, | ||
294 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_FLOAT,"FLOAT"}, | ||
295 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_INTEGER,"INTEGER"}, | ||
296 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_PERIOD,"PERIOD"}, | ||
297 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_RECUR,"RECUR"}, | ||
298 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_TEXT,"TEXT"}, | ||
299 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_URI,"URI"}, | ||
300 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_ERROR,"ERROR"}, | ||
301 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_DATETIME,"DATE-TIME"}, | ||
302 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_UTCOFFSET,"UTC-OFFSET"}, | ||
303 | {ICAL_VALUE_PARAMETER,ICAL_VALUE_CALADDRESS,"CAL-ADDRESS"}, | ||
304 | {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_EQUAL,"EQUAL"}, | ||
305 | {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_NOTEQUAL,"NOTEQUAL"}, | ||
306 | {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESS,"LESS"}, | ||
307 | {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATER,"GREATER"}, | ||
308 | {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESSEQUAL,"LESSEQUAL"}, | ||
309 | {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATEREQUAL,"GREATEREQUAL"}, | ||
310 | {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_REGEX,"REGEX"}, | ||
311 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_COMPONENTPARSEERROR,"COMPONENT-PARSE-ERROR"}, | ||
312 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PROPERTYPARSEERROR,"PROPERTY-PARSE-ERROR"}, | ||
313 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR,"PARAMETER-NAME-PARSE-ERROR"}, | ||
314 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR,"PARAMETER-VALUE-PARSE-ERROR"}, | ||
315 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_VALUEPARSEERROR,"VALUE-PARSE-ERROR"}, | ||
316 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_INVALIDITIP,"INVALID-ITIP"}, | ||
317 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_UNKNOWNVCALPROPERROR,"UNKNOWN-VCAL-PROP-ERROR"}, | ||
318 | {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_MIMEPARSEERROR,"MIME-PARSE-ERROR"}, | ||
319 | {ICAL_NO_PARAMETER,0,""}}; | ||
320 | |||
321 | /* DELEGATED-FROM */ | ||
322 | icalparameter* icalparameter_new_delegatedfrom(const char* v) | ||
323 | { | ||
324 | struct icalparameter_impl *impl; | ||
325 | icalerror_clear_errno(); | ||
326 | icalerror_check_arg_rz( (v!=0),"v"); | ||
327 | impl = icalparameter_new_impl(ICAL_DELEGATEDFROM_PARAMETER); | ||
328 | if (impl == 0) { | ||
329 | return 0; | ||
330 | } | ||
331 | |||
332 | icalparameter_set_delegatedfrom((icalparameter*) impl,v); | ||
333 | if (icalerrno != ICAL_NO_ERROR) { | ||
334 | icalparameter_free((icalparameter*) impl); | ||
335 | return 0; | ||
336 | } | ||
337 | |||
338 | return (icalparameter*) impl; | ||
339 | } | ||
340 | |||
341 | const char* icalparameter_get_delegatedfrom(icalparameter* param) | ||
342 | { | ||
343 | icalerror_clear_errno(); | ||
344 | icalerror_check_arg_rz( (param!=0), "param"); | ||
345 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
346 | } | ||
347 | |||
348 | void icalparameter_set_delegatedfrom(icalparameter* param, const char* v) | ||
349 | { | ||
350 | icalerror_check_arg_rv( (v!=0),"v"); | ||
351 | icalerror_check_arg_rv( (param!=0), "param"); | ||
352 | icalerror_clear_errno(); | ||
353 | |||
354 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
355 | } | ||
356 | |||
357 | /* DELEGATED-TO */ | ||
358 | icalparameter* icalparameter_new_delegatedto(const char* v) | ||
359 | { | ||
360 | struct icalparameter_impl *impl; | ||
361 | icalerror_clear_errno(); | ||
362 | icalerror_check_arg_rz( (v!=0),"v"); | ||
363 | impl = icalparameter_new_impl(ICAL_DELEGATEDTO_PARAMETER); | ||
364 | if (impl == 0) { | ||
365 | return 0; | ||
366 | } | ||
367 | |||
368 | icalparameter_set_delegatedto((icalparameter*) impl,v); | ||
369 | if (icalerrno != ICAL_NO_ERROR) { | ||
370 | icalparameter_free((icalparameter*) impl); | ||
371 | return 0; | ||
372 | } | ||
373 | |||
374 | return (icalparameter*) impl; | ||
375 | } | ||
376 | |||
377 | const char* icalparameter_get_delegatedto(icalparameter* param) | ||
378 | { | ||
379 | icalerror_clear_errno(); | ||
380 | icalerror_check_arg_rz( (param!=0), "param"); | ||
381 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
382 | } | ||
383 | |||
384 | void icalparameter_set_delegatedto(icalparameter* param, const char* v) | ||
385 | { | ||
386 | icalerror_check_arg_rv( (v!=0),"v"); | ||
387 | icalerror_check_arg_rv( (param!=0), "param"); | ||
388 | icalerror_clear_errno(); | ||
389 | |||
390 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
391 | } | ||
392 | |||
393 | /* RANGE */ | ||
394 | icalparameter* icalparameter_new_range(icalparameter_range v) | ||
395 | { | ||
396 | struct icalparameter_impl *impl; | ||
397 | icalerror_clear_errno(); | ||
398 | icalerror_check_arg_rz(v >= ICAL_RANGE_X,"v"); | ||
399 | icalerror_check_arg_rz(v < ICAL_RANGE_NONE,"v"); | ||
400 | impl = icalparameter_new_impl(ICAL_RANGE_PARAMETER); | ||
401 | if (impl == 0) { | ||
402 | return 0; | ||
403 | } | ||
404 | |||
405 | icalparameter_set_range((icalparameter*) impl,v); | ||
406 | if (icalerrno != ICAL_NO_ERROR) { | ||
407 | icalparameter_free((icalparameter*) impl); | ||
408 | return 0; | ||
409 | } | ||
410 | |||
411 | return (icalparameter*) impl; | ||
412 | } | ||
413 | |||
414 | icalparameter_range icalparameter_get_range(icalparameter* param) | ||
415 | { | ||
416 | icalerror_clear_errno(); | ||
417 | icalerror_check_arg( (param!=0), "param"); | ||
418 | |||
419 | return (icalparameter_range)((struct icalparameter_impl*)param)->data; | ||
420 | } | ||
421 | |||
422 | void icalparameter_set_range(icalparameter* param, icalparameter_range v) | ||
423 | { | ||
424 | icalerror_check_arg_rv(v >= ICAL_RANGE_X,"v"); | ||
425 | icalerror_check_arg_rv(v < ICAL_RANGE_NONE,"v"); | ||
426 | icalerror_check_arg_rv( (param!=0), "param"); | ||
427 | icalerror_clear_errno(); | ||
428 | |||
429 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
430 | } | ||
431 | |||
432 | /* ENCODING */ | ||
433 | icalparameter* icalparameter_new_encoding(icalparameter_encoding v) | ||
434 | { | ||
435 | struct icalparameter_impl *impl; | ||
436 | icalerror_clear_errno(); | ||
437 | icalerror_check_arg_rz(v >= ICAL_ENCODING_X,"v"); | ||
438 | icalerror_check_arg_rz(v < ICAL_ENCODING_NONE,"v"); | ||
439 | impl = icalparameter_new_impl(ICAL_ENCODING_PARAMETER); | ||
440 | if (impl == 0) { | ||
441 | return 0; | ||
442 | } | ||
443 | |||
444 | icalparameter_set_encoding((icalparameter*) impl,v); | ||
445 | if (icalerrno != ICAL_NO_ERROR) { | ||
446 | icalparameter_free((icalparameter*) impl); | ||
447 | return 0; | ||
448 | } | ||
449 | |||
450 | return (icalparameter*) impl; | ||
451 | } | ||
452 | |||
453 | icalparameter_encoding icalparameter_get_encoding(icalparameter* param) | ||
454 | { | ||
455 | icalerror_clear_errno(); | ||
456 | icalerror_check_arg( (param!=0), "param"); | ||
457 | if ( ((struct icalparameter_impl*)param)->string != 0){ | ||
458 | return ICAL_ENCODING_X; | ||
459 | } | ||
460 | |||
461 | return (icalparameter_encoding)((struct icalparameter_impl*)param)->data; | ||
462 | } | ||
463 | |||
464 | void icalparameter_set_encoding(icalparameter* param, icalparameter_encoding v) | ||
465 | { | ||
466 | icalerror_check_arg_rv(v >= ICAL_ENCODING_X,"v"); | ||
467 | icalerror_check_arg_rv(v < ICAL_ENCODING_NONE,"v"); | ||
468 | icalerror_check_arg_rv( (param!=0), "param"); | ||
469 | icalerror_clear_errno(); | ||
470 | |||
471 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
472 | } | ||
473 | |||
474 | /* RSVP */ | ||
475 | icalparameter* icalparameter_new_rsvp(icalparameter_rsvp v) | ||
476 | { | ||
477 | struct icalparameter_impl *impl; | ||
478 | icalerror_clear_errno(); | ||
479 | icalerror_check_arg_rz(v >= ICAL_RSVP_X,"v"); | ||
480 | icalerror_check_arg_rz(v < ICAL_RSVP_NONE,"v"); | ||
481 | impl = icalparameter_new_impl(ICAL_RSVP_PARAMETER); | ||
482 | if (impl == 0) { | ||
483 | return 0; | ||
484 | } | ||
485 | |||
486 | icalparameter_set_rsvp((icalparameter*) impl,v); | ||
487 | if (icalerrno != ICAL_NO_ERROR) { | ||
488 | icalparameter_free((icalparameter*) impl); | ||
489 | return 0; | ||
490 | } | ||
491 | |||
492 | return (icalparameter*) impl; | ||
493 | } | ||
494 | |||
495 | icalparameter_rsvp icalparameter_get_rsvp(icalparameter* param) | ||
496 | { | ||
497 | icalerror_clear_errno(); | ||
498 | icalerror_check_arg( (param!=0), "param"); | ||
499 | |||
500 | return (icalparameter_rsvp)((struct icalparameter_impl*)param)->data; | ||
501 | } | ||
502 | |||
503 | void icalparameter_set_rsvp(icalparameter* param, icalparameter_rsvp v) | ||
504 | { | ||
505 | icalerror_check_arg_rv(v >= ICAL_RSVP_X,"v"); | ||
506 | icalerror_check_arg_rv(v < ICAL_RSVP_NONE,"v"); | ||
507 | icalerror_check_arg_rv( (param!=0), "param"); | ||
508 | icalerror_clear_errno(); | ||
509 | |||
510 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
511 | } | ||
512 | |||
513 | /* PARTSTAT */ | ||
514 | icalparameter* icalparameter_new_partstat(icalparameter_partstat v) | ||
515 | { | ||
516 | struct icalparameter_impl *impl; | ||
517 | icalerror_clear_errno(); | ||
518 | icalerror_check_arg_rz(v >= ICAL_PARTSTAT_X,"v"); | ||
519 | icalerror_check_arg_rz(v < ICAL_PARTSTAT_NONE,"v"); | ||
520 | impl = icalparameter_new_impl(ICAL_PARTSTAT_PARAMETER); | ||
521 | if (impl == 0) { | ||
522 | return 0; | ||
523 | } | ||
524 | |||
525 | icalparameter_set_partstat((icalparameter*) impl,v); | ||
526 | if (icalerrno != ICAL_NO_ERROR) { | ||
527 | icalparameter_free((icalparameter*) impl); | ||
528 | return 0; | ||
529 | } | ||
530 | |||
531 | return (icalparameter*) impl; | ||
532 | } | ||
533 | |||
534 | icalparameter_partstat icalparameter_get_partstat(icalparameter* param) | ||
535 | { | ||
536 | icalerror_clear_errno(); | ||
537 | icalerror_check_arg( (param!=0), "param"); | ||
538 | if ( ((struct icalparameter_impl*)param)->string != 0){ | ||
539 | return ICAL_PARTSTAT_X; | ||
540 | } | ||
541 | |||
542 | return (icalparameter_partstat)((struct icalparameter_impl*)param)->data; | ||
543 | } | ||
544 | |||
545 | void icalparameter_set_partstat(icalparameter* param, icalparameter_partstat v) | ||
546 | { | ||
547 | icalerror_check_arg_rv(v >= ICAL_PARTSTAT_X,"v"); | ||
548 | icalerror_check_arg_rv(v < ICAL_PARTSTAT_NONE,"v"); | ||
549 | icalerror_check_arg_rv( (param!=0), "param"); | ||
550 | icalerror_clear_errno(); | ||
551 | |||
552 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
553 | } | ||
554 | |||
555 | /* RELTYPE */ | ||
556 | icalparameter* icalparameter_new_reltype(icalparameter_reltype v) | ||
557 | { | ||
558 | struct icalparameter_impl *impl; | ||
559 | icalerror_clear_errno(); | ||
560 | icalerror_check_arg_rz(v >= ICAL_RELTYPE_X,"v"); | ||
561 | icalerror_check_arg_rz(v < ICAL_RELTYPE_NONE,"v"); | ||
562 | impl = icalparameter_new_impl(ICAL_RELTYPE_PARAMETER); | ||
563 | if (impl == 0) { | ||
564 | return 0; | ||
565 | } | ||
566 | |||
567 | icalparameter_set_reltype((icalparameter*) impl,v); | ||
568 | if (icalerrno != ICAL_NO_ERROR) { | ||
569 | icalparameter_free((icalparameter*) impl); | ||
570 | return 0; | ||
571 | } | ||
572 | |||
573 | return (icalparameter*) impl; | ||
574 | } | ||
575 | |||
576 | icalparameter_reltype icalparameter_get_reltype(icalparameter* param) | ||
577 | { | ||
578 | icalerror_clear_errno(); | ||
579 | icalerror_check_arg( (param!=0), "param"); | ||
580 | if ( ((struct icalparameter_impl*)param)->string != 0){ | ||
581 | return ICAL_RELTYPE_X; | ||
582 | } | ||
583 | |||
584 | return (icalparameter_reltype)((struct icalparameter_impl*)param)->data; | ||
585 | } | ||
586 | |||
587 | void icalparameter_set_reltype(icalparameter* param, icalparameter_reltype v) | ||
588 | { | ||
589 | icalerror_check_arg_rv(v >= ICAL_RELTYPE_X,"v"); | ||
590 | icalerror_check_arg_rv(v < ICAL_RELTYPE_NONE,"v"); | ||
591 | icalerror_check_arg_rv( (param!=0), "param"); | ||
592 | icalerror_clear_errno(); | ||
593 | |||
594 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
595 | } | ||
596 | |||
597 | /* CUTYPE */ | ||
598 | icalparameter* icalparameter_new_cutype(icalparameter_cutype v) | ||
599 | { | ||
600 | struct icalparameter_impl *impl; | ||
601 | icalerror_clear_errno(); | ||
602 | icalerror_check_arg_rz(v >= ICAL_CUTYPE_X,"v"); | ||
603 | icalerror_check_arg_rz(v < ICAL_CUTYPE_NONE,"v"); | ||
604 | impl = icalparameter_new_impl(ICAL_CUTYPE_PARAMETER); | ||
605 | if (impl == 0) { | ||
606 | return 0; | ||
607 | } | ||
608 | |||
609 | icalparameter_set_cutype((icalparameter*) impl,v); | ||
610 | if (icalerrno != ICAL_NO_ERROR) { | ||
611 | icalparameter_free((icalparameter*) impl); | ||
612 | return 0; | ||
613 | } | ||
614 | |||
615 | return (icalparameter*) impl; | ||
616 | } | ||
617 | |||
618 | icalparameter_cutype icalparameter_get_cutype(icalparameter* param) | ||
619 | { | ||
620 | icalerror_clear_errno(); | ||
621 | icalerror_check_arg( (param!=0), "param"); | ||
622 | if ( ((struct icalparameter_impl*)param)->string != 0){ | ||
623 | return ICAL_CUTYPE_X; | ||
624 | } | ||
625 | |||
626 | return (icalparameter_cutype)((struct icalparameter_impl*)param)->data; | ||
627 | } | ||
628 | |||
629 | void icalparameter_set_cutype(icalparameter* param, icalparameter_cutype v) | ||
630 | { | ||
631 | icalerror_check_arg_rv(v >= ICAL_CUTYPE_X,"v"); | ||
632 | icalerror_check_arg_rv(v < ICAL_CUTYPE_NONE,"v"); | ||
633 | icalerror_check_arg_rv( (param!=0), "param"); | ||
634 | icalerror_clear_errno(); | ||
635 | |||
636 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
637 | } | ||
638 | |||
639 | /* MEMBER */ | ||
640 | icalparameter* icalparameter_new_member(const char* v) | ||
641 | { | ||
642 | struct icalparameter_impl *impl; | ||
643 | icalerror_clear_errno(); | ||
644 | icalerror_check_arg_rz( (v!=0),"v"); | ||
645 | impl = icalparameter_new_impl(ICAL_MEMBER_PARAMETER); | ||
646 | if (impl == 0) { | ||
647 | return 0; | ||
648 | } | ||
649 | |||
650 | icalparameter_set_member((icalparameter*) impl,v); | ||
651 | if (icalerrno != ICAL_NO_ERROR) { | ||
652 | icalparameter_free((icalparameter*) impl); | ||
653 | return 0; | ||
654 | } | ||
655 | |||
656 | return (icalparameter*) impl; | ||
657 | } | ||
658 | |||
659 | const char* icalparameter_get_member(icalparameter* param) | ||
660 | { | ||
661 | icalerror_clear_errno(); | ||
662 | icalerror_check_arg_rz( (param!=0), "param"); | ||
663 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
664 | } | ||
665 | |||
666 | void icalparameter_set_member(icalparameter* param, const char* v) | ||
667 | { | ||
668 | icalerror_check_arg_rv( (v!=0),"v"); | ||
669 | icalerror_check_arg_rv( (param!=0), "param"); | ||
670 | icalerror_clear_errno(); | ||
671 | |||
672 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
673 | } | ||
674 | |||
675 | /* FMTTYPE */ | ||
676 | icalparameter* icalparameter_new_fmttype(const char* v) | ||
677 | { | ||
678 | struct icalparameter_impl *impl; | ||
679 | icalerror_clear_errno(); | ||
680 | icalerror_check_arg_rz( (v!=0),"v"); | ||
681 | impl = icalparameter_new_impl(ICAL_FMTTYPE_PARAMETER); | ||
682 | if (impl == 0) { | ||
683 | return 0; | ||
684 | } | ||
685 | |||
686 | icalparameter_set_fmttype((icalparameter*) impl,v); | ||
687 | if (icalerrno != ICAL_NO_ERROR) { | ||
688 | icalparameter_free((icalparameter*) impl); | ||
689 | return 0; | ||
690 | } | ||
691 | |||
692 | return (icalparameter*) impl; | ||
693 | } | ||
694 | |||
695 | const char* icalparameter_get_fmttype(icalparameter* param) | ||
696 | { | ||
697 | icalerror_clear_errno(); | ||
698 | icalerror_check_arg_rz( (param!=0), "param"); | ||
699 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
700 | } | ||
701 | |||
702 | void icalparameter_set_fmttype(icalparameter* param, const char* v) | ||
703 | { | ||
704 | icalerror_check_arg_rv( (v!=0),"v"); | ||
705 | icalerror_check_arg_rv( (param!=0), "param"); | ||
706 | icalerror_clear_errno(); | ||
707 | |||
708 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
709 | } | ||
710 | |||
711 | /* SENT-BY */ | ||
712 | icalparameter* icalparameter_new_sentby(const char* v) | ||
713 | { | ||
714 | struct icalparameter_impl *impl; | ||
715 | icalerror_clear_errno(); | ||
716 | icalerror_check_arg_rz( (v!=0),"v"); | ||
717 | impl = icalparameter_new_impl(ICAL_SENTBY_PARAMETER); | ||
718 | if (impl == 0) { | ||
719 | return 0; | ||
720 | } | ||
721 | |||
722 | icalparameter_set_sentby((icalparameter*) impl,v); | ||
723 | if (icalerrno != ICAL_NO_ERROR) { | ||
724 | icalparameter_free((icalparameter*) impl); | ||
725 | return 0; | ||
726 | } | ||
727 | |||
728 | return (icalparameter*) impl; | ||
729 | } | ||
730 | |||
731 | const char* icalparameter_get_sentby(icalparameter* param) | ||
732 | { | ||
733 | icalerror_clear_errno(); | ||
734 | icalerror_check_arg_rz( (param!=0), "param"); | ||
735 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
736 | } | ||
737 | |||
738 | void icalparameter_set_sentby(icalparameter* param, const char* v) | ||
739 | { | ||
740 | icalerror_check_arg_rv( (v!=0),"v"); | ||
741 | icalerror_check_arg_rv( (param!=0), "param"); | ||
742 | icalerror_clear_errno(); | ||
743 | |||
744 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
745 | } | ||
746 | |||
747 | /* VALUE */ | ||
748 | icalparameter* icalparameter_new_value(icalparameter_value v) | ||
749 | { | ||
750 | struct icalparameter_impl *impl; | ||
751 | icalerror_clear_errno(); | ||
752 | icalerror_check_arg_rz(v >= ICAL_VALUE_X,"v"); | ||
753 | icalerror_check_arg_rz(v < ICAL_VALUE_NONE,"v"); | ||
754 | impl = icalparameter_new_impl(ICAL_VALUE_PARAMETER); | ||
755 | if (impl == 0) { | ||
756 | return 0; | ||
757 | } | ||
758 | |||
759 | icalparameter_set_value((icalparameter*) impl,v); | ||
760 | if (icalerrno != ICAL_NO_ERROR) { | ||
761 | icalparameter_free((icalparameter*) impl); | ||
762 | return 0; | ||
763 | } | ||
764 | |||
765 | return (icalparameter*) impl; | ||
766 | } | ||
767 | |||
768 | icalparameter_value icalparameter_get_value(icalparameter* param) | ||
769 | { | ||
770 | icalerror_clear_errno(); | ||
771 | icalerror_check_arg( (param!=0), "param"); | ||
772 | if ( ((struct icalparameter_impl*)param)->string != 0){ | ||
773 | return ICAL_VALUE_X; | ||
774 | } | ||
775 | |||
776 | return (icalparameter_value)((struct icalparameter_impl*)param)->data; | ||
777 | } | ||
778 | |||
779 | void icalparameter_set_value(icalparameter* param, icalparameter_value v) | ||
780 | { | ||
781 | icalerror_check_arg_rv(v >= ICAL_VALUE_X,"v"); | ||
782 | icalerror_check_arg_rv(v < ICAL_VALUE_NONE,"v"); | ||
783 | icalerror_check_arg_rv( (param!=0), "param"); | ||
784 | icalerror_clear_errno(); | ||
785 | |||
786 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
787 | } | ||
788 | |||
789 | /* ALTREP */ | ||
790 | icalparameter* icalparameter_new_altrep(const char* v) | ||
791 | { | ||
792 | struct icalparameter_impl *impl; | ||
793 | icalerror_clear_errno(); | ||
794 | icalerror_check_arg_rz( (v!=0),"v"); | ||
795 | impl = icalparameter_new_impl(ICAL_ALTREP_PARAMETER); | ||
796 | if (impl == 0) { | ||
797 | return 0; | ||
798 | } | ||
799 | |||
800 | icalparameter_set_altrep((icalparameter*) impl,v); | ||
801 | if (icalerrno != ICAL_NO_ERROR) { | ||
802 | icalparameter_free((icalparameter*) impl); | ||
803 | return 0; | ||
804 | } | ||
805 | |||
806 | return (icalparameter*) impl; | ||
807 | } | ||
808 | |||
809 | const char* icalparameter_get_altrep(icalparameter* param) | ||
810 | { | ||
811 | icalerror_clear_errno(); | ||
812 | icalerror_check_arg_rz( (param!=0), "param"); | ||
813 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
814 | } | ||
815 | |||
816 | void icalparameter_set_altrep(icalparameter* param, const char* v) | ||
817 | { | ||
818 | icalerror_check_arg_rv( (v!=0),"v"); | ||
819 | icalerror_check_arg_rv( (param!=0), "param"); | ||
820 | icalerror_clear_errno(); | ||
821 | |||
822 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
823 | } | ||
824 | |||
825 | /* DIR */ | ||
826 | icalparameter* icalparameter_new_dir(const char* v) | ||
827 | { | ||
828 | struct icalparameter_impl *impl; | ||
829 | icalerror_clear_errno(); | ||
830 | icalerror_check_arg_rz( (v!=0),"v"); | ||
831 | impl = icalparameter_new_impl(ICAL_DIR_PARAMETER); | ||
832 | if (impl == 0) { | ||
833 | return 0; | ||
834 | } | ||
835 | |||
836 | icalparameter_set_dir((icalparameter*) impl,v); | ||
837 | if (icalerrno != ICAL_NO_ERROR) { | ||
838 | icalparameter_free((icalparameter*) impl); | ||
839 | return 0; | ||
840 | } | ||
841 | |||
842 | return (icalparameter*) impl; | ||
843 | } | ||
844 | |||
845 | const char* icalparameter_get_dir(icalparameter* param) | ||
846 | { | ||
847 | icalerror_clear_errno(); | ||
848 | icalerror_check_arg_rz( (param!=0), "param"); | ||
849 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
850 | } | ||
851 | |||
852 | void icalparameter_set_dir(icalparameter* param, const char* v) | ||
853 | { | ||
854 | icalerror_check_arg_rv( (v!=0),"v"); | ||
855 | icalerror_check_arg_rv( (param!=0), "param"); | ||
856 | icalerror_clear_errno(); | ||
857 | |||
858 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
859 | } | ||
860 | |||
861 | /* RELATED */ | ||
862 | icalparameter* icalparameter_new_related(icalparameter_related v) | ||
863 | { | ||
864 | struct icalparameter_impl *impl; | ||
865 | icalerror_clear_errno(); | ||
866 | icalerror_check_arg_rz(v >= ICAL_RELATED_X,"v"); | ||
867 | icalerror_check_arg_rz(v < ICAL_RELATED_NONE,"v"); | ||
868 | impl = icalparameter_new_impl(ICAL_RELATED_PARAMETER); | ||
869 | if (impl == 0) { | ||
870 | return 0; | ||
871 | } | ||
872 | |||
873 | icalparameter_set_related((icalparameter*) impl,v); | ||
874 | if (icalerrno != ICAL_NO_ERROR) { | ||
875 | icalparameter_free((icalparameter*) impl); | ||
876 | return 0; | ||
877 | } | ||
878 | |||
879 | return (icalparameter*) impl; | ||
880 | } | ||
881 | |||
882 | icalparameter_related icalparameter_get_related(icalparameter* param) | ||
883 | { | ||
884 | icalerror_clear_errno(); | ||
885 | icalerror_check_arg( (param!=0), "param"); | ||
886 | |||
887 | return (icalparameter_related)((struct icalparameter_impl*)param)->data; | ||
888 | } | ||
889 | |||
890 | void icalparameter_set_related(icalparameter* param, icalparameter_related v) | ||
891 | { | ||
892 | icalerror_check_arg_rv(v >= ICAL_RELATED_X,"v"); | ||
893 | icalerror_check_arg_rv(v < ICAL_RELATED_NONE,"v"); | ||
894 | icalerror_check_arg_rv( (param!=0), "param"); | ||
895 | icalerror_clear_errno(); | ||
896 | |||
897 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
898 | } | ||
899 | |||
900 | /* CN */ | ||
901 | icalparameter* icalparameter_new_cn(const char* v) | ||
902 | { | ||
903 | struct icalparameter_impl *impl; | ||
904 | icalerror_clear_errno(); | ||
905 | icalerror_check_arg_rz( (v!=0),"v"); | ||
906 | impl = icalparameter_new_impl(ICAL_CN_PARAMETER); | ||
907 | if (impl == 0) { | ||
908 | return 0; | ||
909 | } | ||
910 | |||
911 | icalparameter_set_cn((icalparameter*) impl,v); | ||
912 | if (icalerrno != ICAL_NO_ERROR) { | ||
913 | icalparameter_free((icalparameter*) impl); | ||
914 | return 0; | ||
915 | } | ||
916 | |||
917 | return (icalparameter*) impl; | ||
918 | } | ||
919 | |||
920 | const char* icalparameter_get_cn(icalparameter* param) | ||
921 | { | ||
922 | icalerror_clear_errno(); | ||
923 | icalerror_check_arg_rz( (param!=0), "param"); | ||
924 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
925 | } | ||
926 | |||
927 | void icalparameter_set_cn(icalparameter* param, const char* v) | ||
928 | { | ||
929 | icalerror_check_arg_rv( (v!=0),"v"); | ||
930 | icalerror_check_arg_rv( (param!=0), "param"); | ||
931 | icalerror_clear_errno(); | ||
932 | |||
933 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
934 | } | ||
935 | |||
936 | /* X-LIC-ERRORTYPE */ | ||
937 | icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v) | ||
938 | { | ||
939 | struct icalparameter_impl *impl; | ||
940 | icalerror_clear_errno(); | ||
941 | icalerror_check_arg_rz(v >= ICAL_XLICERRORTYPE_X,"v"); | ||
942 | icalerror_check_arg_rz(v < ICAL_XLICERRORTYPE_NONE,"v"); | ||
943 | impl = icalparameter_new_impl(ICAL_XLICERRORTYPE_PARAMETER); | ||
944 | if (impl == 0) { | ||
945 | return 0; | ||
946 | } | ||
947 | |||
948 | icalparameter_set_xlicerrortype((icalparameter*) impl,v); | ||
949 | if (icalerrno != ICAL_NO_ERROR) { | ||
950 | icalparameter_free((icalparameter*) impl); | ||
951 | return 0; | ||
952 | } | ||
953 | |||
954 | return (icalparameter*) impl; | ||
955 | } | ||
956 | |||
957 | icalparameter_xlicerrortype icalparameter_get_xlicerrortype(icalparameter* param) | ||
958 | { | ||
959 | icalerror_clear_errno(); | ||
960 | icalerror_check_arg( (param!=0), "param"); | ||
961 | |||
962 | return (icalparameter_xlicerrortype)((struct icalparameter_impl*)param)->data; | ||
963 | } | ||
964 | |||
965 | void icalparameter_set_xlicerrortype(icalparameter* param, icalparameter_xlicerrortype v) | ||
966 | { | ||
967 | icalerror_check_arg_rv(v >= ICAL_XLICERRORTYPE_X,"v"); | ||
968 | icalerror_check_arg_rv(v < ICAL_XLICERRORTYPE_NONE,"v"); | ||
969 | icalerror_check_arg_rv( (param!=0), "param"); | ||
970 | icalerror_clear_errno(); | ||
971 | |||
972 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
973 | } | ||
974 | |||
975 | /* X */ | ||
976 | icalparameter* icalparameter_new_x(const char* v) | ||
977 | { | ||
978 | struct icalparameter_impl *impl; | ||
979 | icalerror_clear_errno(); | ||
980 | icalerror_check_arg_rz( (v!=0),"v"); | ||
981 | impl = icalparameter_new_impl(ICAL_X_PARAMETER); | ||
982 | if (impl == 0) { | ||
983 | return 0; | ||
984 | } | ||
985 | |||
986 | icalparameter_set_x((icalparameter*) impl,v); | ||
987 | if (icalerrno != ICAL_NO_ERROR) { | ||
988 | icalparameter_free((icalparameter*) impl); | ||
989 | return 0; | ||
990 | } | ||
991 | |||
992 | return (icalparameter*) impl; | ||
993 | } | ||
994 | |||
995 | const char* icalparameter_get_x(icalparameter* param) | ||
996 | { | ||
997 | icalerror_clear_errno(); | ||
998 | icalerror_check_arg_rz( (param!=0), "param"); | ||
999 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
1000 | } | ||
1001 | |||
1002 | void icalparameter_set_x(icalparameter* param, const char* v) | ||
1003 | { | ||
1004 | icalerror_check_arg_rv( (v!=0),"v"); | ||
1005 | icalerror_check_arg_rv( (param!=0), "param"); | ||
1006 | icalerror_clear_errno(); | ||
1007 | |||
1008 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
1009 | } | ||
1010 | |||
1011 | /* LANGUAGE */ | ||
1012 | icalparameter* icalparameter_new_language(const char* v) | ||
1013 | { | ||
1014 | struct icalparameter_impl *impl; | ||
1015 | icalerror_clear_errno(); | ||
1016 | icalerror_check_arg_rz( (v!=0),"v"); | ||
1017 | impl = icalparameter_new_impl(ICAL_LANGUAGE_PARAMETER); | ||
1018 | if (impl == 0) { | ||
1019 | return 0; | ||
1020 | } | ||
1021 | |||
1022 | icalparameter_set_language((icalparameter*) impl,v); | ||
1023 | if (icalerrno != ICAL_NO_ERROR) { | ||
1024 | icalparameter_free((icalparameter*) impl); | ||
1025 | return 0; | ||
1026 | } | ||
1027 | |||
1028 | return (icalparameter*) impl; | ||
1029 | } | ||
1030 | |||
1031 | const char* icalparameter_get_language(icalparameter* param) | ||
1032 | { | ||
1033 | icalerror_clear_errno(); | ||
1034 | icalerror_check_arg_rz( (param!=0), "param"); | ||
1035 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
1036 | } | ||
1037 | |||
1038 | void icalparameter_set_language(icalparameter* param, const char* v) | ||
1039 | { | ||
1040 | icalerror_check_arg_rv( (v!=0),"v"); | ||
1041 | icalerror_check_arg_rv( (param!=0), "param"); | ||
1042 | icalerror_clear_errno(); | ||
1043 | |||
1044 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
1045 | } | ||
1046 | |||
1047 | /* ROLE */ | ||
1048 | icalparameter* icalparameter_new_role(icalparameter_role v) | ||
1049 | { | ||
1050 | struct icalparameter_impl *impl; | ||
1051 | icalerror_clear_errno(); | ||
1052 | icalerror_check_arg_rz(v >= ICAL_ROLE_X,"v"); | ||
1053 | icalerror_check_arg_rz(v < ICAL_ROLE_NONE,"v"); | ||
1054 | impl = icalparameter_new_impl(ICAL_ROLE_PARAMETER); | ||
1055 | if (impl == 0) { | ||
1056 | return 0; | ||
1057 | } | ||
1058 | |||
1059 | icalparameter_set_role((icalparameter*) impl,v); | ||
1060 | if (icalerrno != ICAL_NO_ERROR) { | ||
1061 | icalparameter_free((icalparameter*) impl); | ||
1062 | return 0; | ||
1063 | } | ||
1064 | |||
1065 | return (icalparameter*) impl; | ||
1066 | } | ||
1067 | |||
1068 | icalparameter_role icalparameter_get_role(icalparameter* param) | ||
1069 | { | ||
1070 | icalerror_clear_errno(); | ||
1071 | icalerror_check_arg( (param!=0), "param"); | ||
1072 | if ( ((struct icalparameter_impl*)param)->string != 0){ | ||
1073 | return ICAL_ROLE_X; | ||
1074 | } | ||
1075 | |||
1076 | return (icalparameter_role)((struct icalparameter_impl*)param)->data; | ||
1077 | } | ||
1078 | |||
1079 | void icalparameter_set_role(icalparameter* param, icalparameter_role v) | ||
1080 | { | ||
1081 | icalerror_check_arg_rv(v >= ICAL_ROLE_X,"v"); | ||
1082 | icalerror_check_arg_rv(v < ICAL_ROLE_NONE,"v"); | ||
1083 | icalerror_check_arg_rv( (param!=0), "param"); | ||
1084 | icalerror_clear_errno(); | ||
1085 | |||
1086 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
1087 | } | ||
1088 | |||
1089 | /* X-LIC-COMPARETYPE */ | ||
1090 | icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v) | ||
1091 | { | ||
1092 | struct icalparameter_impl *impl; | ||
1093 | icalerror_clear_errno(); | ||
1094 | icalerror_check_arg_rz(v >= ICAL_XLICCOMPARETYPE_X,"v"); | ||
1095 | icalerror_check_arg_rz(v < ICAL_XLICCOMPARETYPE_NONE,"v"); | ||
1096 | impl = icalparameter_new_impl(ICAL_XLICCOMPARETYPE_PARAMETER); | ||
1097 | if (impl == 0) { | ||
1098 | return 0; | ||
1099 | } | ||
1100 | |||
1101 | icalparameter_set_xliccomparetype((icalparameter*) impl,v); | ||
1102 | if (icalerrno != ICAL_NO_ERROR) { | ||
1103 | icalparameter_free((icalparameter*) impl); | ||
1104 | return 0; | ||
1105 | } | ||
1106 | |||
1107 | return (icalparameter*) impl; | ||
1108 | } | ||
1109 | |||
1110 | icalparameter_xliccomparetype icalparameter_get_xliccomparetype(icalparameter* param) | ||
1111 | { | ||
1112 | icalerror_clear_errno(); | ||
1113 | icalerror_check_arg( (param!=0), "param"); | ||
1114 | |||
1115 | return (icalparameter_xliccomparetype)((struct icalparameter_impl*)param)->data; | ||
1116 | } | ||
1117 | |||
1118 | void icalparameter_set_xliccomparetype(icalparameter* param, icalparameter_xliccomparetype v) | ||
1119 | { | ||
1120 | icalerror_check_arg_rv(v >= ICAL_XLICCOMPARETYPE_X,"v"); | ||
1121 | icalerror_check_arg_rv(v < ICAL_XLICCOMPARETYPE_NONE,"v"); | ||
1122 | icalerror_check_arg_rv( (param!=0), "param"); | ||
1123 | icalerror_clear_errno(); | ||
1124 | |||
1125 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
1126 | } | ||
1127 | |||
1128 | /* FBTYPE */ | ||
1129 | icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v) | ||
1130 | { | ||
1131 | struct icalparameter_impl *impl; | ||
1132 | icalerror_clear_errno(); | ||
1133 | icalerror_check_arg_rz(v >= ICAL_FBTYPE_X,"v"); | ||
1134 | icalerror_check_arg_rz(v < ICAL_FBTYPE_NONE,"v"); | ||
1135 | impl = icalparameter_new_impl(ICAL_FBTYPE_PARAMETER); | ||
1136 | if (impl == 0) { | ||
1137 | return 0; | ||
1138 | } | ||
1139 | |||
1140 | icalparameter_set_fbtype((icalparameter*) impl,v); | ||
1141 | if (icalerrno != ICAL_NO_ERROR) { | ||
1142 | icalparameter_free((icalparameter*) impl); | ||
1143 | return 0; | ||
1144 | } | ||
1145 | |||
1146 | return (icalparameter*) impl; | ||
1147 | } | ||
1148 | |||
1149 | icalparameter_fbtype icalparameter_get_fbtype(icalparameter* param) | ||
1150 | { | ||
1151 | icalerror_clear_errno(); | ||
1152 | icalerror_check_arg( (param!=0), "param"); | ||
1153 | if ( ((struct icalparameter_impl*)param)->string != 0){ | ||
1154 | return ICAL_FBTYPE_X; | ||
1155 | } | ||
1156 | |||
1157 | return (icalparameter_fbtype)((struct icalparameter_impl*)param)->data; | ||
1158 | } | ||
1159 | |||
1160 | void icalparameter_set_fbtype(icalparameter* param, icalparameter_fbtype v) | ||
1161 | { | ||
1162 | icalerror_check_arg_rv(v >= ICAL_FBTYPE_X,"v"); | ||
1163 | icalerror_check_arg_rv(v < ICAL_FBTYPE_NONE,"v"); | ||
1164 | icalerror_check_arg_rv( (param!=0), "param"); | ||
1165 | icalerror_clear_errno(); | ||
1166 | |||
1167 | ((struct icalparameter_impl*)param)->data = (int)v; | ||
1168 | } | ||
1169 | |||
1170 | /* TZID */ | ||
1171 | icalparameter* icalparameter_new_tzid(const char* v) | ||
1172 | { | ||
1173 | struct icalparameter_impl *impl; | ||
1174 | icalerror_clear_errno(); | ||
1175 | icalerror_check_arg_rz( (v!=0),"v"); | ||
1176 | impl = icalparameter_new_impl(ICAL_TZID_PARAMETER); | ||
1177 | if (impl == 0) { | ||
1178 | return 0; | ||
1179 | } | ||
1180 | |||
1181 | icalparameter_set_tzid((icalparameter*) impl,v); | ||
1182 | if (icalerrno != ICAL_NO_ERROR) { | ||
1183 | icalparameter_free((icalparameter*) impl); | ||
1184 | return 0; | ||
1185 | } | ||
1186 | |||
1187 | return (icalparameter*) impl; | ||
1188 | } | ||
1189 | |||
1190 | const char* icalparameter_get_tzid(icalparameter* param) | ||
1191 | { | ||
1192 | icalerror_clear_errno(); | ||
1193 | icalerror_check_arg_rz( (param!=0), "param"); | ||
1194 | return (const char*)((struct icalparameter_impl*)param)->string; | ||
1195 | } | ||
1196 | |||
1197 | void icalparameter_set_tzid(icalparameter* param, const char* v) | ||
1198 | { | ||
1199 | icalerror_check_arg_rv( (v!=0),"v"); | ||
1200 | icalerror_check_arg_rv( (param!=0), "param"); | ||
1201 | icalerror_clear_errno(); | ||
1202 | |||
1203 | ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v); | ||
1204 | } | ||
1205 | |||