src/plugins/vcalendar/libical/libical/icalderivedproperty.c

   1 /* -*- Mode: C -*- */
   2
   3 /*======================================================================
   4   FILE: icalderivedproperty.c
   5   CREATOR: eric 15 Feb 2001
   6
   7   $Id$
   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 icalproperty.c
  24
  25 ======================================================================*/
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include <config.h>
  29 #endif
  30
  31 #include "icalproperty.h"
  32 #include "icalcomponent.h"
  33 #include "pvl.h"
  34 #include "icalenums.h"
  35 #include "icalerror.h"
  36 #include "icalmemory.h"
  37 #include "icalparser.h"
  38
  39 #include <string.h> /* For icalmemory_strdup, rindex */
  40 #include <assert.h>
  41 #include <stdlib.h>
  42 #include <errno.h>
  43 #include <stdio.h> /* for printf */
  44 #include <stdarg.h> /* for va_list, va_start, etc. */
  45
  46 #define TMP_BUF_SIZE 1024
  47
  48 struct icalproperty_impl*
  49 icalproperty_new_impl (icalproperty_kind kind);
  50
  51 void icalproperty_add_parameters (struct icalproperty_impl *prop, va_list args);
  52
  53 /* This map associates the property kinds with the string
  54    representation of the property name and the kind of VALUE that the
  55    property uses as a default */
  56
  57 struct  icalproperty_map {
  58         icalproperty_kind kind;
  59         const char *name;
  60         icalvalue_kind value;
  61
  62 };
  63
  64 static struct icalproperty_map property_map[];
  65
  66 const char* icalproperty_kind_to_string(icalproperty_kind kind)
  67 {
  68     int i;
  69
  70     for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
  71         if (property_map[i].kind == kind) {
  72             return property_map[i].name;
  73         }
  74     }
  75
  76     return 0;
  77
  78 }
  79
  80
  81 icalproperty_kind icalproperty_string_to_kind(const char* string)
  82 {
  83     int i;
  84
  85     if (string ==0 ) {
  86         return ICAL_NO_PROPERTY;
  87     }
  88
  89
  90     for (i=0; property_map[i].kind  != ICAL_NO_PROPERTY; i++) {
  91         if (strcmp(property_map[i].name, string) == 0) {
  92             return property_map[i].kind;
  93         }
  94     }
  95
  96     if(strncmp(string,"X-",2)==0){
  97         return ICAL_X_PROPERTY;
  98     }
  99
 100
 101     return ICAL_NO_PROPERTY;
 102 }
 103
 104
 105 icalvalue_kind icalproperty_value_kind_to_kind(icalvalue_kind kind)
 106 {
 107     int i;
 108
 109     for (i=0; property_map[i].kind  != ICAL_NO_PROPERTY; i++) {
 110         if ( property_map[i].value == kind ) {
 111             return property_map[i].kind;
 112         }
 113     }
 114
 115     return ICAL_NO_VALUE;
 116 }
 117
 118
 119
 120 icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind)
 121 {
 122     int i;
 123
 124     for (i=0; property_map[i].kind  != ICAL_NO_PROPERTY; i++) {
 125         if ( property_map[i].kind == kind ) {
 126             return property_map[i].value;
 127         }
 128     }
 129
 130     return ICAL_NO_VALUE;
 131 }
 132
 133
 134 /* This map associates the property enumerations with the king of
 135    property that they are used in and the string representation of the
 136    enumeration */
 137
 138 struct icalproperty_enum_map {
 139     icalproperty_kind prop;
 140     int prop_enum;
 141     const char* str;
 142 };
 143
 144 static struct icalproperty_enum_map enum_map[];
 145
 146
 147 const char* icalproperty_enum_to_string(int e)
 148 {
 149     icalerror_check_arg_rz(e >= ICALPROPERTY_FIRST_ENUM,"e");
 150     icalerror_check_arg_rz(e <= ICALPROPERTY_LAST_ENUM,"e");
 151
 152     return enum_map[e-ICALPROPERTY_FIRST_ENUM].str;
 153 }
 154
 155 int icalproperty_string_to_enum(const char* str)
 156 {
 157     int i;
 158
 159     icalerror_check_arg_rz(str!=0,"str")
 160
 161     while(*str == ' '){
 162         str++;
 163     }
 164
 165     for (i=ICALPROPERTY_FIRST_ENUM; i != ICALPROPERTY_LAST_ENUM; i++) {
 166         if ( strcmp(enum_map[i-ICALPROPERTY_FIRST_ENUM].str, str) == 0) {
 167             return enum_map[i-ICALPROPERTY_FIRST_ENUM].prop_enum;
 168         }
 169     }
 170
 171     return 0;
 172 }
 173
 174 int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e)
 175 {
 176     int i;
 177
 178
 179     for (i=ICALPROPERTY_FIRST_ENUM; i != ICALPROPERTY_LAST_ENUM; i++) {
 180         if(enum_map[i-ICALPROPERTY_FIRST_ENUM].prop_enum == e &&
 181            enum_map[i-ICALPROPERTY_FIRST_ENUM].prop == kind ){
 182             return 1;
 183         }
 184     }
 185
 186     return 0;
 187 }
 188
 189
 190 const char* icalproperty_method_to_string(icalproperty_method method)
 191 {
 192     icalerror_check_arg_rz(method >= ICAL_METHOD_X,"method");
 193     icalerror_check_arg_rz(method <= ICAL_METHOD_NONE,"method");
 194
 195     return enum_map[method-ICALPROPERTY_FIRST_ENUM].str;
 196 }
 197
 198 icalproperty_method icalproperty_string_to_method(const char* str)
 199 {
 200     int i;
 201
 202     icalerror_check_arg_rx(str!=0,"str",ICAL_METHOD_NONE)
 203
 204     while(*str == ' '){
 205         str++;
 206     }
 207
 208     for (i=ICAL_METHOD_X-ICALPROPERTY_FIRST_ENUM;
 209          i != ICAL_METHOD_NONE-ICALPROPERTY_FIRST_ENUM;
 210          i++) {
 211         if ( strcmp(enum_map[i].str, str) == 0) {
 212             return (icalproperty_method)enum_map[i].prop_enum;
 213         }
 214     }
 215
 216     return ICAL_METHOD_NONE;
 217 }
 218
 219
 220 const char* icalenum_status_to_string(icalproperty_status status)
 221 {
 222     icalerror_check_arg_rz(status >= ICAL_STATUS_X,"status");
 223     icalerror_check_arg_rz(status <= ICAL_STATUS_NONE,"status");
 224
 225     return enum_map[status-ICALPROPERTY_FIRST_ENUM].str;
 226 }
 227
 228 icalproperty_status icalenum_string_to_status(const char* str)
 229 {
 230     int i;
 231
 232     icalerror_check_arg_rx(str!=0,"str",ICAL_STATUS_NONE)
 233
 234     while(*str == ' '){
 235         str++;
 236     }
 237
 238     for (i=ICAL_STATUS_X-ICALPROPERTY_FIRST_ENUM;
 239          i != ICAL_STATUS_NONE-ICALPROPERTY_FIRST_ENUM;
 240          i++) {
 241         if ( strcmp(enum_map[i].str, str) == 0) {
 242             return (icalproperty_method)enum_map[i].prop_enum;
 243         }
 244     }
 245
 246     return ICAL_STATUS_NONE;
 247
 248 }
 249
 250
 251
 252 /* Everything below this line is machine generated. Do not edit. */
 253 static struct icalproperty_map property_map[] = {
 254 {ICAL_ACTION_PROPERTY,"ACTION",ICAL_ACTION_VALUE},
 255 {ICAL_ANY_PROPERTY,"ANY",ICAL_NO_VALUE},
 256 {ICAL_ATTACH_PROPERTY,"ATTACH",ICAL_ATTACH_VALUE},
 257 {ICAL_ATTENDEE_PROPERTY,"ATTENDEE",ICAL_CALADDRESS_VALUE},
 258 {ICAL_CALSCALE_PROPERTY,"CALSCALE",ICAL_TEXT_VALUE},
 259 {ICAL_CATEGORIES_PROPERTY,"CATEGORIES",ICAL_TEXT_VALUE},
 260 {ICAL_CLASS_PROPERTY,"CLASS",ICAL_TEXT_VALUE},
 261 {ICAL_COMMENT_PROPERTY,"COMMENT",ICAL_TEXT_VALUE},
 262 {ICAL_COMPLETED_PROPERTY,"COMPLETED",ICAL_DATETIME_VALUE},
 263 {ICAL_CONTACT_PROPERTY,"CONTACT",ICAL_TEXT_VALUE},
 264 {ICAL_CREATED_PROPERTY,"CREATED",ICAL_DATETIME_VALUE},
 265 {ICAL_DESCRIPTION_PROPERTY,"DESCRIPTION",ICAL_TEXT_VALUE},
 266 {ICAL_DTEND_PROPERTY,"DTEND",ICAL_DATETIME_VALUE},
 267 {ICAL_DTSTAMP_PROPERTY,"DTSTAMP",ICAL_DATETIME_VALUE},
 268 {ICAL_DTSTART_PROPERTY,"DTSTART",ICAL_DATETIME_VALUE},
 269 {ICAL_DUE_PROPERTY,"DUE",ICAL_DATETIME_VALUE},
 270 {ICAL_DURATION_PROPERTY,"DURATION",ICAL_DURATION_VALUE},
 271 {ICAL_EXDATE_PROPERTY,"EXDATE",ICAL_DATETIME_VALUE},
 272 {ICAL_EXRULE_PROPERTY,"EXRULE",ICAL_RECUR_VALUE},
 273 {ICAL_FREEBUSY_PROPERTY,"FREEBUSY",ICAL_PERIOD_VALUE},
 274 {ICAL_GEO_PROPERTY,"GEO",ICAL_GEO_VALUE},
 275 {ICAL_LASTMODIFIED_PROPERTY,"LAST-MODIFIED",ICAL_DATETIME_VALUE},
 276 {ICAL_LOCATION_PROPERTY,"LOCATION",ICAL_TEXT_VALUE},
 277 {ICAL_MAXRESULTS_PROPERTY,"MAXRESULTS",ICAL_INTEGER_VALUE},
 278 {ICAL_MAXRESULTSSIZE_PROPERTY,"MAXRESULTSSIZE",ICAL_INTEGER_VALUE},
 279 {ICAL_METHOD_PROPERTY,"METHOD",ICAL_METHOD_VALUE},
 280 {ICAL_ORGANIZER_PROPERTY,"ORGANIZER",ICAL_CALADDRESS_VALUE},
 281 {ICAL_PERCENTCOMPLETE_PROPERTY,"PERCENT-COMPLETE",ICAL_INTEGER_VALUE},
 282 {ICAL_PRIORITY_PROPERTY,"PRIORITY",ICAL_INTEGER_VALUE},
 283 {ICAL_PRODID_PROPERTY,"PRODID",ICAL_TEXT_VALUE},
 284 {ICAL_QUERY_PROPERTY,"QUERY",ICAL_QUERY_VALUE},
 285 {ICAL_QUERYNAME_PROPERTY,"QUERYNAME",ICAL_TEXT_VALUE},
 286 {ICAL_RDATE_PROPERTY,"RDATE",ICAL_DATETIMEPERIOD_VALUE},
 287 {ICAL_RECURRENCEID_PROPERTY,"RECURRENCE-ID",ICAL_DATETIME_VALUE},
 288 {ICAL_RELATEDTO_PROPERTY,"RELATED-TO",ICAL_TEXT_VALUE},
 289 {ICAL_REPEAT_PROPERTY,"REPEAT",ICAL_INTEGER_VALUE},
 290 {ICAL_REQUESTSTATUS_PROPERTY,"REQUEST-STATUS",ICAL_STRING_VALUE},
 291 {ICAL_RESOURCES_PROPERTY,"RESOURCES",ICAL_TEXT_VALUE},
 292 {ICAL_RRULE_PROPERTY,"RRULE",ICAL_RECUR_VALUE},
 293 {ICAL_SCOPE_PROPERTY,"SCOPE",ICAL_TEXT_VALUE},
 294 {ICAL_SEQUENCE_PROPERTY,"SEQUENCE",ICAL_INTEGER_VALUE},
 295 {ICAL_STATUS_PROPERTY,"STATUS",ICAL_STATUS_VALUE},
 296 {ICAL_SUMMARY_PROPERTY,"SUMMARY",ICAL_TEXT_VALUE},
 297 {ICAL_TARGET_PROPERTY,"TARGET",ICAL_CALADDRESS_VALUE},
 298 {ICAL_TRANSP_PROPERTY,"TRANSP",ICAL_TEXT_VALUE},
 299 {ICAL_TRIGGER_PROPERTY,"TRIGGER",ICAL_TRIGGER_VALUE},
 300 {ICAL_TZID_PROPERTY,"TZID",ICAL_TEXT_VALUE},
 301 {ICAL_TZNAME_PROPERTY,"TZNAME",ICAL_TEXT_VALUE},
 302 {ICAL_TZOFFSETFROM_PROPERTY,"TZOFFSETFROM",ICAL_UTCOFFSET_VALUE},
 303 {ICAL_TZOFFSETTO_PROPERTY,"TZOFFSETTO",ICAL_UTCOFFSET_VALUE},
 304 {ICAL_TZURL_PROPERTY,"TZURL",ICAL_URI_VALUE},
 305 {ICAL_UID_PROPERTY,"UID",ICAL_TEXT_VALUE},
 306 {ICAL_URL_PROPERTY,"URL",ICAL_URI_VALUE},
 307 {ICAL_VERSION_PROPERTY,"VERSION",ICAL_TEXT_VALUE},
 308 {ICAL_X_PROPERTY,"X",ICAL_TEXT_VALUE},
 309 {ICAL_XLICCLUSTERCOUNT_PROPERTY,"X-LIC-CLUSTERCOUNT",ICAL_STRING_VALUE},
 310 {ICAL_XLICERROR_PROPERTY,"X-LIC-ERROR",ICAL_TEXT_VALUE},
 311 {ICAL_XLICMIMECHARSET_PROPERTY,"X-LIC-MIMECHARSET",ICAL_STRING_VALUE},
 312 {ICAL_XLICMIMECID_PROPERTY,"X-LIC-MIMECID",ICAL_STRING_VALUE},
 313 {ICAL_XLICMIMECONTENTTYPE_PROPERTY,"X-LIC-MIMECONTENTTYPE",ICAL_STRING_VALUE},
 314 {ICAL_XLICMIMEENCODING_PROPERTY,"X-LIC-MIMEENCODING",ICAL_STRING_VALUE},
 315 {ICAL_XLICMIMEFILENAME_PROPERTY,"X-LIC-MIMEFILENAME",ICAL_STRING_VALUE},
 316 {ICAL_XLICMIMEOPTINFO_PROPERTY,"X-LIC-MIMEOPTINFO",ICAL_STRING_VALUE},
 317 {ICAL_NO_PROPERTY,"",ICAL_NO_VALUE}};
 318
 319 static struct icalproperty_enum_map enum_map[] = {
 320     {ICAL_ACTION_PROPERTY,ICAL_ACTION_X,"" }, /*10000*/
 321     {ICAL_ACTION_PROPERTY,ICAL_ACTION_AUDIO,"AUDIO" }, /*10001*/
 322     {ICAL_ACTION_PROPERTY,ICAL_ACTION_DISPLAY,"DISPLAY" }, /*10002*/
 323     {ICAL_ACTION_PROPERTY,ICAL_ACTION_EMAIL,"EMAIL" }, /*10003*/
 324     {ICAL_ACTION_PROPERTY,ICAL_ACTION_PROCEDURE,"PROCEDURE" }, /*10004*/
 325     {ICAL_ACTION_PROPERTY,ICAL_ACTION_NONE,"" }, /*10005*/
 326     {ICAL_CLASS_PROPERTY,ICAL_CLASS_X,"" }, /*10006*/
 327     {ICAL_CLASS_PROPERTY,ICAL_CLASS_PUBLIC,"PUBLIC" }, /*10007*/
 328     {ICAL_CLASS_PROPERTY,ICAL_CLASS_PRIVATE,"PRIVATE" }, /*10008*/
 329     {ICAL_CLASS_PROPERTY,ICAL_CLASS_CONFIDENTIAL,"CONFIDENTIAL" }, /*10009*/
 330     {ICAL_CLASS_PROPERTY,ICAL_CLASS_NONE,"" }, /*10010*/
 331     {ICAL_METHOD_PROPERTY,ICAL_METHOD_X,"" }, /*10011*/
 332     {ICAL_METHOD_PROPERTY,ICAL_METHOD_PUBLISH,"PUBLISH" }, /*10012*/
 333     {ICAL_METHOD_PROPERTY,ICAL_METHOD_REQUEST,"REQUEST" }, /*10013*/
 334     {ICAL_METHOD_PROPERTY,ICAL_METHOD_REPLY,"REPLY" }, /*10014*/
 335     {ICAL_METHOD_PROPERTY,ICAL_METHOD_ADD,"ADD" }, /*10015*/
 336     {ICAL_METHOD_PROPERTY,ICAL_METHOD_CANCEL,"CANCEL" }, /*10016*/
 337     {ICAL_METHOD_PROPERTY,ICAL_METHOD_REFRESH,"REFRESH" }, /*10017*/
 338     {ICAL_METHOD_PROPERTY,ICAL_METHOD_COUNTER,"COUNTER" }, /*10018*/
 339     {ICAL_METHOD_PROPERTY,ICAL_METHOD_DECLINECOUNTER,"DECLINECOUNTER" }, /*10019*/
 340     {ICAL_METHOD_PROPERTY,ICAL_METHOD_CREATE,"CREATE" }, /*10020*/
 341     {ICAL_METHOD_PROPERTY,ICAL_METHOD_READ,"READ" }, /*10021*/
 342     {ICAL_METHOD_PROPERTY,ICAL_METHOD_RESPONSE,"RESPONSE" }, /*10022*/
 343     {ICAL_METHOD_PROPERTY,ICAL_METHOD_MOVE,"MOVE" }, /*10023*/
 344     {ICAL_METHOD_PROPERTY,ICAL_METHOD_MODIFY,"MODIFY" }, /*10024*/
 345     {ICAL_METHOD_PROPERTY,ICAL_METHOD_GENERATEUID,"GENERATEUID" }, /*10025*/
 346     {ICAL_METHOD_PROPERTY,ICAL_METHOD_DELETE,"DELETE" }, /*10026*/
 347     {ICAL_METHOD_PROPERTY,ICAL_METHOD_NONE,"" }, /*10027*/
 348     {ICAL_STATUS_PROPERTY,ICAL_STATUS_X,"" }, /*10028*/
 349     {ICAL_STATUS_PROPERTY,ICAL_STATUS_TENTATIVE,"TENTATIVE" }, /*10029*/
 350     {ICAL_STATUS_PROPERTY,ICAL_STATUS_CONFIRMED,"CONFIRMED" }, /*10030*/
 351     {ICAL_STATUS_PROPERTY,ICAL_STATUS_COMPLETED,"COMPLETED" }, /*10031*/
 352     {ICAL_STATUS_PROPERTY,ICAL_STATUS_NEEDSACTION,"NEEDS-ACTION" }, /*10032*/
 353     {ICAL_STATUS_PROPERTY,ICAL_STATUS_CANCELLED,"CANCELLED" }, /*10033*/
 354     {ICAL_STATUS_PROPERTY,ICAL_STATUS_INPROCESS,"IN-PROCESS" }, /*10034*/
 355     {ICAL_STATUS_PROPERTY,ICAL_STATUS_DRAFT,"DRAFT" }, /*10035*/
 356     {ICAL_STATUS_PROPERTY,ICAL_STATUS_FINAL,"FINAL" }, /*10036*/
 357     {ICAL_STATUS_PROPERTY,ICAL_STATUS_NONE,"" }, /*10037*/
 358     {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_X,"" }, /*10038*/
 359     {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_OPAQUE,"OPAQUE" }, /*10039*/
 360     {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_TRANSPARENT,"TRANSPARENT" }, /*10040*/
 361     {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_NONE,"" }, /*10041*/
 362     {ICAL_NO_PROPERTY,0,""}
 363 };
 364
 365 /* ACTION */
 366 icalproperty* icalproperty_new_action(enum icalproperty_action v) {
 367    struct icalproperty_impl *impl;
 368
 369    impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY);
 370    icalproperty_set_action((icalproperty*)impl,v);
 371    return (icalproperty*)impl;
 372 }
 373 icalproperty* icalproperty_vanew_action(enum icalproperty_action v, ...){
 374    va_list args;
 375    struct icalproperty_impl *impl;
 376
 377    impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY);
 378    icalproperty_set_action((icalproperty*)impl,v);
 379    va_start(args,v);
 380    icalproperty_add_parameters(impl, args);
 381    va_end(args);
 382    return (icalproperty*)impl;
 383 }
 384 void icalproperty_set_action(icalproperty* prop, enum icalproperty_action v){
 385     icalvalue *value;
 386
 387     icalerror_check_arg_rv( (prop!=0),"prop");
 388     value = icalvalue_new_action(v);
 389     icalproperty_set_value(prop,value);
 390 }
 391 enum icalproperty_action icalproperty_get_action(icalproperty* prop){
 392     icalvalue *value;
 393     icalerror_check_arg( (prop!=0),"prop");
 394     value = icalproperty_get_value(prop);
 395     return icalvalue_get_action(value);
 396 }
 397 /* ATTACH */
 398 icalproperty* icalproperty_new_attach(struct icalattachtype v) {
 399    struct icalproperty_impl *impl;
 400
 401    impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY);
 402    icalproperty_set_attach((icalproperty*)impl,v);
 403    return (icalproperty*)impl;
 404 }
 405 icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...){
 406    va_list args;
 407    struct icalproperty_impl *impl;
 408
 409    impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY);
 410    icalproperty_set_attach((icalproperty*)impl,v);
 411    va_start(args,v);
 412    icalproperty_add_parameters(impl, args);
 413    va_end(args);
 414    return (icalproperty*)impl;
 415 }
 416 void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v){
 417     icalvalue *value;
 418
 419     icalerror_check_arg_rv( (prop!=0),"prop");
 420     value = icalvalue_new_attach(v);
 421     icalproperty_set_value(prop,value);
 422 }
 423 struct icalattachtype icalproperty_get_attach(icalproperty* prop){
 424     icalvalue *value;
 425     icalerror_check_arg( (prop!=0),"prop");
 426     value = icalproperty_get_value(prop);
 427     return icalvalue_get_attach(value);
 428 }
 429 /* ATTENDEE */
 430 icalproperty* icalproperty_new_attendee(const char* v) {
 431    struct icalproperty_impl *impl;
 432    icalerror_check_arg_rz( (v!=0),"v");
 433
 434    impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY);
 435    icalproperty_set_attendee((icalproperty*)impl,v);
 436    return (icalproperty*)impl;
 437 }
 438 icalproperty* icalproperty_vanew_attendee(const char* v, ...){
 439    va_list args;
 440    struct icalproperty_impl *impl;
 441    icalerror_check_arg_rz( (v!=0),"v");
 442
 443    impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY);
 444    icalproperty_set_attendee((icalproperty*)impl,v);
 445    va_start(args,v);
 446    icalproperty_add_parameters(impl, args);
 447    va_end(args);
 448    return (icalproperty*)impl;
 449 }
 450 void icalproperty_set_attendee(icalproperty* prop, const char* v){
 451     icalvalue *value;
 452     icalerror_check_arg_rv( (v!=0),"v");
 453
 454     icalerror_check_arg_rv( (prop!=0),"prop");
 455     value = icalvalue_new_caladdress(v);
 456     icalproperty_set_value(prop,value);
 457 }
 458 const char* icalproperty_get_attendee(icalproperty* prop){
 459     icalvalue *value;
 460     icalerror_check_arg( (prop!=0),"prop");
 461     value = icalproperty_get_value(prop);
 462     return icalvalue_get_caladdress(value);
 463 }
 464 /* CALSCALE */
 465 icalproperty* icalproperty_new_calscale(const char* v) {
 466    struct icalproperty_impl *impl;
 467    icalerror_check_arg_rz( (v!=0),"v");
 468
 469    impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY);
 470    icalproperty_set_calscale((icalproperty*)impl,v);
 471    return (icalproperty*)impl;
 472 }
 473 icalproperty* icalproperty_vanew_calscale(const char* v, ...){
 474    va_list args;
 475    struct icalproperty_impl *impl;
 476    icalerror_check_arg_rz( (v!=0),"v");
 477
 478    impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY);
 479    icalproperty_set_calscale((icalproperty*)impl,v);
 480    va_start(args,v);
 481    icalproperty_add_parameters(impl, args);
 482    va_end(args);
 483    return (icalproperty*)impl;
 484 }
 485 void icalproperty_set_calscale(icalproperty* prop, const char* v){
 486     icalvalue *value;
 487     icalerror_check_arg_rv( (v!=0),"v");
 488
 489     icalerror_check_arg_rv( (prop!=0),"prop");
 490     value = icalvalue_new_text(v);
 491     icalproperty_set_value(prop,value);
 492 }
 493 const char* icalproperty_get_calscale(icalproperty* prop){
 494     icalvalue *value;
 495     icalerror_check_arg( (prop!=0),"prop");
 496     value = icalproperty_get_value(prop);
 497     return icalvalue_get_text(value);
 498 }
 499 /* CATEGORIES */
 500 icalproperty* icalproperty_new_categories(const char* v) {
 501    struct icalproperty_impl *impl;
 502    icalerror_check_arg_rz( (v!=0),"v");
 503
 504    impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY);
 505    icalproperty_set_categories((icalproperty*)impl,v);
 506    return (icalproperty*)impl;
 507 }
 508 icalproperty* icalproperty_vanew_categories(const char* v, ...){
 509    va_list args;
 510    struct icalproperty_impl *impl;
 511    icalerror_check_arg_rz( (v!=0),"v");
 512
 513    impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY);
 514    icalproperty_set_categories((icalproperty*)impl,v);
 515    va_start(args,v);
 516    icalproperty_add_parameters(impl, args);
 517    va_end(args);
 518    return (icalproperty*)impl;
 519 }
 520 void icalproperty_set_categories(icalproperty* prop, const char* v){
 521     icalvalue *value;
 522     icalerror_check_arg_rv( (v!=0),"v");
 523
 524     icalerror_check_arg_rv( (prop!=0),"prop");
 525     value = icalvalue_new_text(v);
 526     icalproperty_set_value(prop,value);
 527 }
 528 const char* icalproperty_get_categories(icalproperty* prop){
 529     icalvalue *value;
 530     icalerror_check_arg( (prop!=0),"prop");
 531     value = icalproperty_get_value(prop);
 532     return icalvalue_get_text(value);
 533 }
 534 /* CLASS */
 535 icalproperty* icalproperty_new_class(const char* v) {
 536    struct icalproperty_impl *impl;
 537    icalerror_check_arg_rz( (v!=0),"v");
 538
 539    impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY);
 540    icalproperty_set_class((icalproperty*)impl,v);
 541    return (icalproperty*)impl;
 542 }
 543 icalproperty* icalproperty_vanew_class(const char* v, ...){
 544    va_list args;
 545    struct icalproperty_impl *impl;
 546    icalerror_check_arg_rz( (v!=0),"v");
 547
 548    impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY);
 549    icalproperty_set_class((icalproperty*)impl,v);
 550    va_start(args,v);
 551    icalproperty_add_parameters(impl, args);
 552    va_end(args);
 553    return (icalproperty*)impl;
 554 }
 555 void icalproperty_set_class(icalproperty* prop, const char* v){
 556     icalvalue *value;
 557     icalerror_check_arg_rv( (v!=0),"v");
 558
 559     icalerror_check_arg_rv( (prop!=0),"prop");
 560     value = icalvalue_new_text(v);
 561     icalproperty_set_value(prop,value);
 562 }
 563 const char* icalproperty_get_class(icalproperty* prop){
 564     icalvalue *value;
 565     icalerror_check_arg( (prop!=0),"prop");
 566     value = icalproperty_get_value(prop);
 567     return icalvalue_get_text(value);
 568 }
 569 /* COMMENT */
 570 icalproperty* icalproperty_new_comment(const char* v) {
 571    struct icalproperty_impl *impl;
 572    icalerror_check_arg_rz( (v!=0),"v");
 573
 574    impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY);
 575    icalproperty_set_comment((icalproperty*)impl,v);
 576    return (icalproperty*)impl;
 577 }
 578 icalproperty* icalproperty_vanew_comment(const char* v, ...){
 579    va_list args;
 580    struct icalproperty_impl *impl;
 581    icalerror_check_arg_rz( (v!=0),"v");
 582
 583    impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY);
 584    icalproperty_set_comment((icalproperty*)impl,v);
 585    va_start(args,v);
 586    icalproperty_add_parameters(impl, args);
 587    va_end(args);
 588    return (icalproperty*)impl;
 589 }
 590 void icalproperty_set_comment(icalproperty* prop, const char* v){
 591     icalvalue *value;
 592     icalerror_check_arg_rv( (v!=0),"v");
 593
 594     icalerror_check_arg_rv( (prop!=0),"prop");
 595     value = icalvalue_new_text(v);
 596     icalproperty_set_value(prop,value);
 597 }
 598 const char* icalproperty_get_comment(icalproperty* prop){
 599     icalvalue *value;
 600     icalerror_check_arg( (prop!=0),"prop");
 601     value = icalproperty_get_value(prop);
 602     return icalvalue_get_text(value);
 603 }
 604 /* COMPLETED */
 605 icalproperty* icalproperty_new_completed(struct icaltimetype v) {
 606    struct icalproperty_impl *impl;
 607
 608    impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY);
 609    icalproperty_set_completed((icalproperty*)impl,v);
 610    return (icalproperty*)impl;
 611 }
 612 icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...){
 613    va_list args;
 614    struct icalproperty_impl *impl;
 615
 616    impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY);
 617    icalproperty_set_completed((icalproperty*)impl,v);
 618    va_start(args,v);
 619    icalproperty_add_parameters(impl, args);
 620    va_end(args);
 621    return (icalproperty*)impl;
 622 }
 623 void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v){
 624     icalvalue *value;
 625
 626     icalerror_check_arg_rv( (prop!=0),"prop");
 627     value = icalvalue_new_datetime(v);
 628     icalproperty_set_value(prop,value);
 629 }
 630 struct icaltimetype icalproperty_get_completed(icalproperty* prop){
 631     icalvalue *value;
 632     icalerror_check_arg( (prop!=0),"prop");
 633     value = icalproperty_get_value(prop);
 634     return icalvalue_get_datetime(value);
 635 }
 636 /* CONTACT */
 637 icalproperty* icalproperty_new_contact(const char* v) {
 638    struct icalproperty_impl *impl;
 639    icalerror_check_arg_rz( (v!=0),"v");
 640
 641    impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY);
 642    icalproperty_set_contact((icalproperty*)impl,v);
 643    return (icalproperty*)impl;
 644 }
 645 icalproperty* icalproperty_vanew_contact(const char* v, ...){
 646    va_list args;
 647    struct icalproperty_impl *impl;
 648    icalerror_check_arg_rz( (v!=0),"v");
 649
 650    impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY);
 651    icalproperty_set_contact((icalproperty*)impl,v);
 652    va_start(args,v);
 653    icalproperty_add_parameters(impl, args);
 654    va_end(args);
 655    return (icalproperty*)impl;
 656 }
 657 void icalproperty_set_contact(icalproperty* prop, const char* v){
 658     icalvalue *value;
 659     icalerror_check_arg_rv( (v!=0),"v");
 660
 661     icalerror_check_arg_rv( (prop!=0),"prop");
 662     value = icalvalue_new_text(v);
 663     icalproperty_set_value(prop,value);
 664 }
 665 const char* icalproperty_get_contact(icalproperty* prop){
 666     icalvalue *value;
 667     icalerror_check_arg( (prop!=0),"prop");
 668     value = icalproperty_get_value(prop);
 669     return icalvalue_get_text(value);
 670 }
 671 /* CREATED */
 672 icalproperty* icalproperty_new_created(struct icaltimetype v) {
 673    struct icalproperty_impl *impl;
 674
 675    impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY);
 676    icalproperty_set_created((icalproperty*)impl,v);
 677    return (icalproperty*)impl;
 678 }
 679 icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...){
 680    va_list args;
 681    struct icalproperty_impl *impl;
 682
 683    impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY);
 684    icalproperty_set_created((icalproperty*)impl,v);
 685    va_start(args,v);
 686    icalproperty_add_parameters(impl, args);
 687    va_end(args);
 688    return (icalproperty*)impl;
 689 }
 690 void icalproperty_set_created(icalproperty* prop, struct icaltimetype v){
 691     icalvalue *value;
 692
 693     icalerror_check_arg_rv( (prop!=0),"prop");
 694     value = icalvalue_new_datetime(v);
 695     icalproperty_set_value(prop,value);
 696 }
 697 struct icaltimetype icalproperty_get_created(icalproperty* prop){
 698     icalvalue *value;
 699     icalerror_check_arg( (prop!=0),"prop");
 700     value = icalproperty_get_value(prop);
 701     return icalvalue_get_datetime(value);
 702 }
 703 /* DESCRIPTION */
 704 icalproperty* icalproperty_new_description(const char* v) {
 705    struct icalproperty_impl *impl;
 706    icalerror_check_arg_rz( (v!=0),"v");
 707
 708    impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY);
 709    icalproperty_set_description((icalproperty*)impl,v);
 710    return (icalproperty*)impl;
 711 }
 712 icalproperty* icalproperty_vanew_description(const char* v, ...){
 713    va_list args;
 714    struct icalproperty_impl *impl;
 715    icalerror_check_arg_rz( (v!=0),"v");
 716
 717    impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY);
 718    icalproperty_set_description((icalproperty*)impl,v);
 719    va_start(args,v);
 720    icalproperty_add_parameters(impl, args);
 721    va_end(args);
 722    return (icalproperty*)impl;
 723 }
 724 void icalproperty_set_description(icalproperty* prop, const char* v){
 725     icalvalue *value;
 726     icalerror_check_arg_rv( (v!=0),"v");
 727
 728     icalerror_check_arg_rv( (prop!=0),"prop");
 729     value = icalvalue_new_text(v);
 730     icalproperty_set_value(prop,value);
 731 }
 732 const char* icalproperty_get_description(icalproperty* prop){
 733     icalvalue *value;
 734     icalerror_check_arg( (prop!=0),"prop");
 735     value = icalproperty_get_value(prop);
 736     return icalvalue_get_text(value);
 737 }
 738 /* DTEND */
 739 icalproperty* icalproperty_new_dtend(struct icaltimetype v) {
 740    struct icalproperty_impl *impl;
 741
 742    impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY);
 743    icalproperty_set_dtend((icalproperty*)impl,v);
 744    return (icalproperty*)impl;
 745 }
 746 icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...){
 747    va_list args;
 748    struct icalproperty_impl *impl;
 749
 750    impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY);
 751    icalproperty_set_dtend((icalproperty*)impl,v);
 752    va_start(args,v);
 753    icalproperty_add_parameters(impl, args);
 754    va_end(args);
 755    return (icalproperty*)impl;
 756 }
 757 void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v){
 758     icalvalue *value;
 759
 760     icalerror_check_arg_rv( (prop!=0),"prop");
 761     value = icalvalue_new_datetime(v);
 762     icalproperty_set_value(prop,value);
 763 }
 764 struct icaltimetype icalproperty_get_dtend(icalproperty* prop){
 765     icalvalue *value;
 766     icalerror_check_arg( (prop!=0),"prop");
 767     value = icalproperty_get_value(prop);
 768     return icalvalue_get_datetime(value);
 769 }
 770 /* DTSTAMP */
 771 icalproperty* icalproperty_new_dtstamp(struct icaltimetype v) {
 772    struct icalproperty_impl *impl;
 773
 774    impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY);
 775    icalproperty_set_dtstamp((icalproperty*)impl,v);
 776    return (icalproperty*)impl;
 777 }
 778 icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...){
 779    va_list args;
 780    struct icalproperty_impl *impl;
 781
 782    impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY);
 783    icalproperty_set_dtstamp((icalproperty*)impl,v);
 784    va_start(args,v);
 785    icalproperty_add_parameters(impl, args);
 786    va_end(args);
 787    return (icalproperty*)impl;
 788 }
 789 void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v){
 790     icalvalue *value;
 791
 792     icalerror_check_arg_rv( (prop!=0),"prop");
 793     value = icalvalue_new_datetime(v);
 794     icalproperty_set_value(prop,value);
 795 }
 796 struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop){
 797     icalvalue *value;
 798     icalerror_check_arg( (prop!=0),"prop");
 799     value = icalproperty_get_value(prop);
 800     return icalvalue_get_datetime(value);
 801 }
 802 /* DTSTART */
 803 icalproperty* icalproperty_new_dtstart(struct icaltimetype v) {
 804    struct icalproperty_impl *impl;
 805
 806    impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY);
 807    icalproperty_set_dtstart((icalproperty*)impl,v);
 808    return (icalproperty*)impl;
 809 }
 810 icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...){
 811    va_list args;
 812    struct icalproperty_impl *impl;
 813
 814    impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY);
 815    icalproperty_set_dtstart((icalproperty*)impl,v);
 816    va_start(args,v);
 817    icalproperty_add_parameters(impl, args);
 818    va_end(args);
 819    return (icalproperty*)impl;
 820 }
 821 void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v){
 822     icalvalue *value;
 823
 824     icalerror_check_arg_rv( (prop!=0),"prop");
 825     value = icalvalue_new_datetime(v);
 826     icalproperty_set_value(prop,value);
 827 }
 828 struct icaltimetype icalproperty_get_dtstart(icalproperty* prop){
 829     icalvalue *value;
 830     icalerror_check_arg( (prop!=0),"prop");
 831     value = icalproperty_get_value(prop);
 832     return icalvalue_get_datetime(value);
 833 }
 834 /* DUE */
 835 icalproperty* icalproperty_new_due(struct icaltimetype v) {
 836    struct icalproperty_impl *impl;
 837
 838    impl = icalproperty_new_impl(ICAL_DUE_PROPERTY);
 839    icalproperty_set_due((icalproperty*)impl,v);
 840    return (icalproperty*)impl;
 841 }
 842 icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...){
 843    va_list args;
 844    struct icalproperty_impl *impl;
 845
 846    impl = icalproperty_new_impl(ICAL_DUE_PROPERTY);
 847    icalproperty_set_due((icalproperty*)impl,v);
 848    va_start(args,v);
 849    icalproperty_add_parameters(impl, args);
 850    va_end(args);
 851    return (icalproperty*)impl;
 852 }
 853 void icalproperty_set_due(icalproperty* prop, struct icaltimetype v){
 854     icalvalue *value;
 855
 856     icalerror_check_arg_rv( (prop!=0),"prop");
 857     value = icalvalue_new_datetime(v);
 858     icalproperty_set_value(prop,value);
 859 }
 860 struct icaltimetype icalproperty_get_due(icalproperty* prop){
 861     icalvalue *value;
 862     icalerror_check_arg( (prop!=0),"prop");
 863     value = icalproperty_get_value(prop);
 864     return icalvalue_get_datetime(value);
 865 }
 866 /* DURATION */
 867 icalproperty* icalproperty_new_duration(struct icaldurationtype v) {
 868    struct icalproperty_impl *impl;
 869
 870    impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY);
 871    icalproperty_set_duration((icalproperty*)impl,v);
 872    return (icalproperty*)impl;
 873 }
 874 icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...){
 875    va_list args;
 876    struct icalproperty_impl *impl;
 877
 878    impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY);
 879    icalproperty_set_duration((icalproperty*)impl,v);
 880    va_start(args,v);
 881    icalproperty_add_parameters(impl, args);
 882    va_end(args);
 883    return (icalproperty*)impl;
 884 }
 885 void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v){
 886     icalvalue *value;
 887
 888     icalerror_check_arg_rv( (prop!=0),"prop");
 889     value = icalvalue_new_duration(v);
 890     icalproperty_set_value(prop,value);
 891 }
 892 struct icaldurationtype icalproperty_get_duration(icalproperty* prop){
 893     icalvalue *value;
 894     icalerror_check_arg( (prop!=0),"prop");
 895     value = icalproperty_get_value(prop);
 896     return icalvalue_get_duration(value);
 897 }
 898 /* EXDATE */
 899 icalproperty* icalproperty_new_exdate(struct icaltimetype v) {
 900    struct icalproperty_impl *impl;
 901
 902    impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY);
 903    icalproperty_set_exdate((icalproperty*)impl,v);
 904    return (icalproperty*)impl;
 905 }
 906 icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...){
 907    va_list args;
 908    struct icalproperty_impl *impl;
 909
 910    impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY);
 911    icalproperty_set_exdate((icalproperty*)impl,v);
 912    va_start(args,v);
 913    icalproperty_add_parameters(impl, args);
 914    va_end(args);
 915    return (icalproperty*)impl;
 916 }
 917 void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v){
 918     icalvalue *value;
 919
 920     icalerror_check_arg_rv( (prop!=0),"prop");
 921     value = icalvalue_new_datetime(v);
 922     icalproperty_set_value(prop,value);
 923 }
 924 struct icaltimetype icalproperty_get_exdate(icalproperty* prop){
 925     icalvalue *value;
 926     icalerror_check_arg( (prop!=0),"prop");
 927     value = icalproperty_get_value(prop);
 928     return icalvalue_get_datetime(value);
 929 }
 930 /* EXRULE */
 931 icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v) {
 932    struct icalproperty_impl *impl;
 933
 934    impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY);
 935    icalproperty_set_exrule((icalproperty*)impl,v);
 936    return (icalproperty*)impl;
 937 }
 938 icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...){
 939    va_list args;
 940    struct icalproperty_impl *impl;
 941
 942    impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY);
 943    icalproperty_set_exrule((icalproperty*)impl,v);
 944    va_start(args,v);
 945    icalproperty_add_parameters(impl, args);
 946    va_end(args);
 947    return (icalproperty*)impl;
 948 }
 949 void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v){
 950     icalvalue *value;
 951
 952     icalerror_check_arg_rv( (prop!=0),"prop");
 953     value = icalvalue_new_recur(v);
 954     icalproperty_set_value(prop,value);
 955 }
 956 struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop){
 957     icalvalue *value;
 958     icalerror_check_arg( (prop!=0),"prop");
 959     value = icalproperty_get_value(prop);
 960     return icalvalue_get_recur(value);
 961 }
 962 /* FREEBUSY */
 963 icalproperty* icalproperty_new_freebusy(struct icalperiodtype v) {
 964    struct icalproperty_impl *impl;
 965
 966    impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY);
 967    icalproperty_set_freebusy((icalproperty*)impl,v);
 968    return (icalproperty*)impl;
 969 }
 970 icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...){
 971    va_list args;
 972    struct icalproperty_impl *impl;
 973
 974    impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY);
 975    icalproperty_set_freebusy((icalproperty*)impl,v);
 976    va_start(args,v);
 977    icalproperty_add_parameters(impl, args);
 978    va_end(args);
 979    return (icalproperty*)impl;
 980 }
 981 void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v){
 982     icalvalue *value;
 983
 984     icalerror_check_arg_rv( (prop!=0),"prop");
 985     value = icalvalue_new_period(v);
 986     icalproperty_set_value(prop,value);
 987 }
 988 struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop){
 989     icalvalue *value;
 990     icalerror_check_arg( (prop!=0),"prop");
 991     value = icalproperty_get_value(prop);
 992     return icalvalue_get_period(value);
 993 }
 994 /* GEO */
 995 icalproperty* icalproperty_new_geo(struct icalgeotype v) {
 996    struct icalproperty_impl *impl;
 997
 998    impl = icalproperty_new_impl(ICAL_GEO_PROPERTY);
 999    icalproperty_set_geo((icalproperty*)impl,v);
1000    return (icalproperty*)impl;
1001 }
1002 icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...){
1003    va_list args;
1004    struct icalproperty_impl *impl;
1005
1006    impl = icalproperty_new_impl(ICAL_GEO_PROPERTY);
1007    icalproperty_set_geo((icalproperty*)impl,v);
1008    va_start(args,v);
1009    icalproperty_add_parameters(impl, args);
1010    va_end(args);
1011    return (icalproperty*)impl;
1012 }
1013 void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v){
1014     icalvalue *value;
1015
1016     icalerror_check_arg_rv( (prop!=0),"prop");
1017     value = icalvalue_new_geo(v);
1018     icalproperty_set_value(prop,value);
1019 }
1020 struct icalgeotype icalproperty_get_geo(icalproperty* prop){
1021     icalvalue *value;
1022     icalerror_check_arg( (prop!=0),"prop");
1023     value = icalproperty_get_value(prop);
1024     return icalvalue_get_geo(value);
1025 }
1026 /* LAST-MODIFIED */
1027 icalproperty* icalproperty_new_lastmodified(struct icaltimetype v) {
1028    struct icalproperty_impl *impl;
1029
1030    impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY);
1031    icalproperty_set_lastmodified((icalproperty*)impl,v);
1032    return (icalproperty*)impl;
1033 }
1034 icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...){
1035    va_list args;
1036    struct icalproperty_impl *impl;
1037
1038    impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY);
1039    icalproperty_set_lastmodified((icalproperty*)impl,v);
1040    va_start(args,v);
1041    icalproperty_add_parameters(impl, args);
1042    va_end(args);
1043    return (icalproperty*)impl;
1044 }
1045 void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v){
1046     icalvalue *value;
1047
1048     icalerror_check_arg_rv( (prop!=0),"prop");
1049     value = icalvalue_new_datetime(v);
1050     icalproperty_set_value(prop,value);
1051 }
1052 struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop){
1053     icalvalue *value;
1054     icalerror_check_arg( (prop!=0),"prop");
1055     value = icalproperty_get_value(prop);
1056     return icalvalue_get_datetime(value);
1057 }
1058 /* LOCATION */
1059 icalproperty* icalproperty_new_location(const char* v) {
1060    struct icalproperty_impl *impl;
1061    icalerror_check_arg_rz( (v!=0),"v");
1062
1063    impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY);
1064    icalproperty_set_location((icalproperty*)impl,v);
1065    return (icalproperty*)impl;
1066 }
1067 icalproperty* icalproperty_vanew_location(const char* v, ...){
1068    va_list args;
1069    struct icalproperty_impl *impl;
1070    icalerror_check_arg_rz( (v!=0),"v");
1071
1072    impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY);
1073    icalproperty_set_location((icalproperty*)impl,v);
1074    va_start(args,v);
1075    icalproperty_add_parameters(impl, args);
1076    va_end(args);
1077    return (icalproperty*)impl;
1078 }
1079 void icalproperty_set_location(icalproperty* prop, const char* v){
1080     icalvalue *value;
1081     icalerror_check_arg_rv( (v!=0),"v");
1082
1083     icalerror_check_arg_rv( (prop!=0),"prop");
1084     value = icalvalue_new_text(v);
1085     icalproperty_set_value(prop,value);
1086 }
1087 const char* icalproperty_get_location(icalproperty* prop){
1088     icalvalue *value;
1089     icalerror_check_arg( (prop!=0),"prop");
1090     value = icalproperty_get_value(prop);
1091     return icalvalue_get_text(value);
1092 }
1093 /* MAXRESULTS */
1094 icalproperty* icalproperty_new_maxresults(int v) {
1095    struct icalproperty_impl *impl;
1096
1097    impl = icalproperty_new_impl(ICAL_MAXRESULTS_PROPERTY);
1098    icalproperty_set_maxresults((icalproperty*)impl,v);
1099    return (icalproperty*)impl;
1100 }
1101 icalproperty* icalproperty_vanew_maxresults(int v, ...){
1102    va_list args;
1103    struct icalproperty_impl *impl;
1104
1105    impl = icalproperty_new_impl(ICAL_MAXRESULTS_PROPERTY);
1106    icalproperty_set_maxresults((icalproperty*)impl,v);
1107    va_start(args,v);
1108    icalproperty_add_parameters(impl, args);
1109    va_end(args);
1110    return (icalproperty*)impl;
1111 }
1112 void icalproperty_set_maxresults(icalproperty* prop, int v){
1113     icalvalue *value;
1114
1115     icalerror_check_arg_rv( (prop!=0),"prop");
1116     value = icalvalue_new_integer(v);
1117     icalproperty_set_value(prop,value);
1118 }
1119 int icalproperty_get_maxresults(icalproperty* prop){
1120     icalvalue *value;
1121     icalerror_check_arg( (prop!=0),"prop");
1122     value = icalproperty_get_value(prop);
1123     return icalvalue_get_integer(value);
1124 }
1125 /* MAXRESULTSSIZE */
1126 icalproperty* icalproperty_new_maxresultssize(int v) {
1127    struct icalproperty_impl *impl;
1128
1129    impl = icalproperty_new_impl(ICAL_MAXRESULTSSIZE_PROPERTY);
1130    icalproperty_set_maxresultssize((icalproperty*)impl,v);
1131    return (icalproperty*)impl;
1132 }
1133 icalproperty* icalproperty_vanew_maxresultssize(int v, ...){
1134    va_list args;
1135    struct icalproperty_impl *impl;
1136
1137    impl = icalproperty_new_impl(ICAL_MAXRESULTSSIZE_PROPERTY);
1138    icalproperty_set_maxresultssize((icalproperty*)impl,v);
1139    va_start(args,v);
1140    icalproperty_add_parameters(impl, args);
1141    va_end(args);
1142    return (icalproperty*)impl;
1143 }
1144 void icalproperty_set_maxresultssize(icalproperty* prop, int v){
1145     icalvalue *value;
1146
1147     icalerror_check_arg_rv( (prop!=0),"prop");
1148     value = icalvalue_new_integer(v);
1149     icalproperty_set_value(prop,value);
1150 }
1151 int icalproperty_get_maxresultssize(icalproperty* prop){
1152     icalvalue *value;
1153     icalerror_check_arg( (prop!=0),"prop");
1154     value = icalproperty_get_value(prop);
1155     return icalvalue_get_integer(value);
1156 }
1157 /* METHOD */
1158 icalproperty* icalproperty_new_method(enum icalproperty_method v) {
1159    struct icalproperty_impl *impl;
1160
1161    impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY);
1162    icalproperty_set_method((icalproperty*)impl,v);
1163    return (icalproperty*)impl;
1164 }
1165 icalproperty* icalproperty_vanew_method(enum icalproperty_method v, ...){
1166    va_list args;
1167    struct icalproperty_impl *impl;
1168
1169    impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY);
1170    icalproperty_set_method((icalproperty*)impl,v);
1171    va_start(args,v);
1172    icalproperty_add_parameters(impl, args);
1173    va_end(args);
1174    return (icalproperty*)impl;
1175 }
1176 void icalproperty_set_method(icalproperty* prop, enum icalproperty_method v){
1177     icalvalue *value;
1178
1179     icalerror_check_arg_rv( (prop!=0),"prop");
1180     value = icalvalue_new_method(v);
1181     icalproperty_set_value(prop,value);
1182 }
1183 enum icalproperty_method icalproperty_get_method(icalproperty* prop){
1184     icalvalue *value;
1185     icalerror_check_arg( (prop!=0),"prop");
1186     value = icalproperty_get_value(prop);
1187     return icalvalue_get_method(value);
1188 }
1189 /* ORGANIZER */
1190 icalproperty* icalproperty_new_organizer(const char* v) {
1191    struct icalproperty_impl *impl;
1192    icalerror_check_arg_rz( (v!=0),"v");
1193
1194    impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY);
1195    icalproperty_set_organizer((icalproperty*)impl,v);
1196    return (icalproperty*)impl;
1197 }
1198 icalproperty* icalproperty_vanew_organizer(const char* v, ...){
1199    va_list args;
1200    struct icalproperty_impl *impl;
1201    icalerror_check_arg_rz( (v!=0),"v");
1202
1203    impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY);
1204    icalproperty_set_organizer((icalproperty*)impl,v);
1205    va_start(args,v);
1206    icalproperty_add_parameters(impl, args);
1207    va_end(args);
1208    return (icalproperty*)impl;
1209 }
1210 void icalproperty_set_organizer(icalproperty* prop, const char* v){
1211     icalvalue *value;
1212     icalerror_check_arg_rv( (v!=0),"v");
1213
1214     icalerror_check_arg_rv( (prop!=0),"prop");
1215     value = icalvalue_new_caladdress(v);
1216     icalproperty_set_value(prop,value);
1217 }
1218 const char* icalproperty_get_organizer(icalproperty* prop){
1219     icalvalue *value;
1220     icalerror_check_arg( (prop!=0),"prop");
1221     value = icalproperty_get_value(prop);
1222     return icalvalue_get_caladdress(value);
1223 }
1224 /* PERCENT-COMPLETE */
1225 icalproperty* icalproperty_new_percentcomplete(int v) {
1226    struct icalproperty_impl *impl;
1227
1228    impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY);
1229    icalproperty_set_percentcomplete((icalproperty*)impl,v);
1230    return (icalproperty*)impl;
1231 }
1232 icalproperty* icalproperty_vanew_percentcomplete(int v, ...){
1233    va_list args;
1234    struct icalproperty_impl *impl;
1235
1236    impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY);
1237    icalproperty_set_percentcomplete((icalproperty*)impl,v);
1238    va_start(args,v);
1239    icalproperty_add_parameters(impl, args);
1240    va_end(args);
1241    return (icalproperty*)impl;
1242 }
1243 void icalproperty_set_percentcomplete(icalproperty* prop, int v){
1244     icalvalue *value;
1245
1246     icalerror_check_arg_rv( (prop!=0),"prop");
1247     value = icalvalue_new_integer(v);
1248     icalproperty_set_value(prop,value);
1249 }
1250 int icalproperty_get_percentcomplete(icalproperty* prop){
1251     icalvalue *value;
1252     icalerror_check_arg( (prop!=0),"prop");
1253     value = icalproperty_get_value(prop);
1254     return icalvalue_get_integer(value);
1255 }
1256 /* PRIORITY */
1257 icalproperty* icalproperty_new_priority(int v) {
1258    struct icalproperty_impl *impl;
1259
1260    impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY);
1261    icalproperty_set_priority((icalproperty*)impl,v);
1262    return (icalproperty*)impl;
1263 }
1264 icalproperty* icalproperty_vanew_priority(int v, ...){
1265    va_list args;
1266    struct icalproperty_impl *impl;
1267
1268    impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY);
1269    icalproperty_set_priority((icalproperty*)impl,v);
1270    va_start(args,v);
1271    icalproperty_add_parameters(impl, args);
1272    va_end(args);
1273    return (icalproperty*)impl;
1274 }
1275 void icalproperty_set_priority(icalproperty* prop, int v){
1276     icalvalue *value;
1277
1278     icalerror_check_arg_rv( (prop!=0),"prop");
1279     value = icalvalue_new_integer(v);
1280     icalproperty_set_value(prop,value);
1281 }
1282 int icalproperty_get_priority(icalproperty* prop){
1283     icalvalue *value;
1284     icalerror_check_arg( (prop!=0),"prop");
1285     value = icalproperty_get_value(prop);
1286     return icalvalue_get_integer(value);
1287 }
1288 /* PRODID */
1289 icalproperty* icalproperty_new_prodid(const char* v) {
1290    struct icalproperty_impl *impl;
1291    icalerror_check_arg_rz( (v!=0),"v");
1292
1293    impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY);
1294    icalproperty_set_prodid((icalproperty*)impl,v);
1295    return (icalproperty*)impl;
1296 }
1297 icalproperty* icalproperty_vanew_prodid(const char* v, ...){
1298    va_list args;
1299    struct icalproperty_impl *impl;
1300    icalerror_check_arg_rz( (v!=0),"v");
1301
1302    impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY);
1303    icalproperty_set_prodid((icalproperty*)impl,v);
1304    va_start(args,v);
1305    icalproperty_add_parameters(impl, args);
1306    va_end(args);
1307    return (icalproperty*)impl;
1308 }
1309 void icalproperty_set_prodid(icalproperty* prop, const char* v){
1310     icalvalue *value;
1311     icalerror_check_arg_rv( (v!=0),"v");
1312
1313     icalerror_check_arg_rv( (prop!=0),"prop");
1314     value = icalvalue_new_text(v);
1315     icalproperty_set_value(prop,value);
1316 }
1317 const char* icalproperty_get_prodid(icalproperty* prop){
1318     icalvalue *value;
1319     icalerror_check_arg( (prop!=0),"prop");
1320     value = icalproperty_get_value(prop);
1321     return icalvalue_get_text(value);
1322 }
1323 /* QUERY */
1324 icalproperty* icalproperty_new_query(const char* v) {
1325    struct icalproperty_impl *impl;
1326    icalerror_check_arg_rz( (v!=0),"v");
1327
1328    impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY);
1329    icalproperty_set_query((icalproperty*)impl,v);
1330    return (icalproperty*)impl;
1331 }
1332 icalproperty* icalproperty_vanew_query(const char* v, ...){
1333    va_list args;
1334    struct icalproperty_impl *impl;
1335    icalerror_check_arg_rz( (v!=0),"v");
1336
1337    impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY);
1338    icalproperty_set_query((icalproperty*)impl,v);
1339    va_start(args,v);
1340    icalproperty_add_parameters(impl, args);
1341    va_end(args);
1342    return (icalproperty*)impl;
1343 }
1344 void icalproperty_set_query(icalproperty* prop, const char* v){
1345     icalvalue *value;
1346     icalerror_check_arg_rv( (v!=0),"v");
1347
1348     icalerror_check_arg_rv( (prop!=0),"prop");
1349     value = icalvalue_new_query(v);
1350     icalproperty_set_value(prop,value);
1351 }
1352 const char* icalproperty_get_query(icalproperty* prop){
1353     icalvalue *value;
1354     icalerror_check_arg( (prop!=0),"prop");
1355     value = icalproperty_get_value(prop);
1356     return icalvalue_get_query(value);
1357 }
1358 /* QUERYNAME */
1359 icalproperty* icalproperty_new_queryname(const char* v) {
1360    struct icalproperty_impl *impl;
1361    icalerror_check_arg_rz( (v!=0),"v");
1362
1363    impl = icalproperty_new_impl(ICAL_QUERYNAME_PROPERTY);
1364    icalproperty_set_queryname((icalproperty*)impl,v);
1365    return (icalproperty*)impl;
1366 }
1367 icalproperty* icalproperty_vanew_queryname(const char* v, ...){
1368    va_list args;
1369    struct icalproperty_impl *impl;
1370    icalerror_check_arg_rz( (v!=0),"v");
1371
1372    impl = icalproperty_new_impl(ICAL_QUERYNAME_PROPERTY);
1373    icalproperty_set_queryname((icalproperty*)impl,v);
1374    va_start(args,v);
1375    icalproperty_add_parameters(impl, args);
1376    va_end(args);
1377    return (icalproperty*)impl;
1378 }
1379 void icalproperty_set_queryname(icalproperty* prop, const char* v){
1380     icalvalue *value;
1381     icalerror_check_arg_rv( (v!=0),"v");
1382
1383     icalerror_check_arg_rv( (prop!=0),"prop");
1384     value = icalvalue_new_text(v);
1385     icalproperty_set_value(prop,value);
1386 }
1387 const char* icalproperty_get_queryname(icalproperty* prop){
1388     icalvalue *value;
1389     icalerror_check_arg( (prop!=0),"prop");
1390     value = icalproperty_get_value(prop);
1391     return icalvalue_get_text(value);
1392 }
1393 /* RDATE */
1394 icalproperty* icalproperty_new_rdate(struct icaldatetimeperiodtype v) {
1395    struct icalproperty_impl *impl;
1396
1397    impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY);
1398    icalproperty_set_rdate((icalproperty*)impl,v);
1399    return (icalproperty*)impl;
1400 }
1401 icalproperty* icalproperty_vanew_rdate(struct icaldatetimeperiodtype v, ...){
1402    va_list args;
1403    struct icalproperty_impl *impl;
1404
1405    impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY);
1406    icalproperty_set_rdate((icalproperty*)impl,v);
1407    va_start(args,v);
1408    icalproperty_add_parameters(impl, args);
1409    va_end(args);
1410    return (icalproperty*)impl;
1411 }
1412 void icalproperty_set_rdate(icalproperty* prop, struct icaldatetimeperiodtype v){
1413     icalvalue *value;
1414
1415     icalerror_check_arg_rv( (prop!=0),"prop");
1416     value = icalvalue_new_datetimeperiod(v);
1417     icalproperty_set_value(prop,value);
1418 }
1419 struct icaldatetimeperiodtype icalproperty_get_rdate(icalproperty* prop){
1420     icalvalue *value;
1421     icalerror_check_arg( (prop!=0),"prop");
1422     value = icalproperty_get_value(prop);
1423     return icalvalue_get_datetimeperiod(value);
1424 }
1425 /* RECURRENCE-ID */
1426 icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v) {
1427    struct icalproperty_impl *impl;
1428
1429    impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY);
1430    icalproperty_set_recurrenceid((icalproperty*)impl,v);
1431    return (icalproperty*)impl;
1432 }
1433 icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...){
1434    va_list args;
1435    struct icalproperty_impl *impl;
1436
1437    impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY);
1438    icalproperty_set_recurrenceid((icalproperty*)impl,v);
1439    va_start(args,v);
1440    icalproperty_add_parameters(impl, args);
1441    va_end(args);
1442    return (icalproperty*)impl;
1443 }
1444 void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v){
1445     icalvalue *value;
1446
1447     icalerror_check_arg_rv( (prop!=0),"prop");
1448     value = icalvalue_new_datetime(v);
1449     icalproperty_set_value(prop,value);
1450 }
1451 struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop){
1452     icalvalue *value;
1453     icalerror_check_arg( (prop!=0),"prop");
1454     value = icalproperty_get_value(prop);
1455     return icalvalue_get_datetime(value);
1456 }
1457 /* RELATED-TO */
1458 icalproperty* icalproperty_new_relatedto(const char* v) {
1459    struct icalproperty_impl *impl;
1460    icalerror_check_arg_rz( (v!=0),"v");
1461
1462    impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY);
1463    icalproperty_set_relatedto((icalproperty*)impl,v);
1464    return (icalproperty*)impl;
1465 }
1466 icalproperty* icalproperty_vanew_relatedto(const char* v, ...){
1467    va_list args;
1468    struct icalproperty_impl *impl;
1469    icalerror_check_arg_rz( (v!=0),"v");
1470
1471    impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY);
1472    icalproperty_set_relatedto((icalproperty*)impl,v);
1473    va_start(args,v);
1474    icalproperty_add_parameters(impl, args);
1475    va_end(args);
1476    return (icalproperty*)impl;
1477 }
1478 void icalproperty_set_relatedto(icalproperty* prop, const char* v){
1479     icalvalue *value;
1480     icalerror_check_arg_rv( (v!=0),"v");
1481
1482     icalerror_check_arg_rv( (prop!=0),"prop");
1483     value = icalvalue_new_text(v);
1484     icalproperty_set_value(prop,value);
1485 }
1486 const char* icalproperty_get_relatedto(icalproperty* prop){
1487     icalvalue *value;
1488     icalerror_check_arg( (prop!=0),"prop");
1489     value = icalproperty_get_value(prop);
1490     return icalvalue_get_text(value);
1491 }
1492 /* REPEAT */
1493 icalproperty* icalproperty_new_repeat(int v) {
1494    struct icalproperty_impl *impl;
1495
1496    impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY);
1497    icalproperty_set_repeat((icalproperty*)impl,v);
1498    return (icalproperty*)impl;
1499 }
1500 icalproperty* icalproperty_vanew_repeat(int v, ...){
1501    va_list args;
1502    struct icalproperty_impl *impl;
1503
1504    impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY);
1505    icalproperty_set_repeat((icalproperty*)impl,v);
1506    va_start(args,v);
1507    icalproperty_add_parameters(impl, args);
1508    va_end(args);
1509    return (icalproperty*)impl;
1510 }
1511 void icalproperty_set_repeat(icalproperty* prop, int v){
1512     icalvalue *value;
1513
1514     icalerror_check_arg_rv( (prop!=0),"prop");
1515     value = icalvalue_new_integer(v);
1516     icalproperty_set_value(prop,value);
1517 }
1518 int icalproperty_get_repeat(icalproperty* prop){
1519     icalvalue *value;
1520     icalerror_check_arg( (prop!=0),"prop");
1521     value = icalproperty_get_value(prop);
1522     return icalvalue_get_integer(value);
1523 }
1524 /* REQUEST-STATUS */
1525 icalproperty* icalproperty_new_requeststatus(const char* v) {
1526    struct icalproperty_impl *impl;
1527    icalerror_check_arg_rz( (v!=0),"v");
1528
1529    impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY);
1530    icalproperty_set_requeststatus((icalproperty*)impl,v);
1531    return (icalproperty*)impl;
1532 }
1533 icalproperty* icalproperty_vanew_requeststatus(const char* v, ...){
1534    va_list args;
1535    struct icalproperty_impl *impl;
1536    icalerror_check_arg_rz( (v!=0),"v");
1537
1538    impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY);
1539    icalproperty_set_requeststatus((icalproperty*)impl,v);
1540    va_start(args,v);
1541    icalproperty_add_parameters(impl, args);
1542    va_end(args);
1543    return (icalproperty*)impl;
1544 }
1545 void icalproperty_set_requeststatus(icalproperty* prop, const char* v){
1546     icalvalue *value;
1547     icalerror_check_arg_rv( (v!=0),"v");
1548
1549     icalerror_check_arg_rv( (prop!=0),"prop");
1550     value = icalvalue_new_string(v);
1551     icalproperty_set_value(prop,value);
1552 }
1553 const char* icalproperty_get_requeststatus(icalproperty* prop){
1554     icalvalue *value;
1555     icalerror_check_arg( (prop!=0),"prop");
1556     value = icalproperty_get_value(prop);
1557     return icalvalue_get_string(value);
1558 }
1559 /* RESOURCES */
1560 icalproperty* icalproperty_new_resources(const char* v) {
1561    struct icalproperty_impl *impl;
1562    icalerror_check_arg_rz( (v!=0),"v");
1563
1564    impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY);
1565    icalproperty_set_resources((icalproperty*)impl,v);
1566    return (icalproperty*)impl;
1567 }
1568 icalproperty* icalproperty_vanew_resources(const char* v, ...){
1569    va_list args;
1570    struct icalproperty_impl *impl;
1571    icalerror_check_arg_rz( (v!=0),"v");
1572
1573    impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY);
1574    icalproperty_set_resources((icalproperty*)impl,v);
1575    va_start(args,v);
1576    icalproperty_add_parameters(impl, args);
1577    va_end(args);
1578    return (icalproperty*)impl;
1579 }
1580 void icalproperty_set_resources(icalproperty* prop, const char* v){
1581     icalvalue *value;
1582     icalerror_check_arg_rv( (v!=0),"v");
1583
1584     icalerror_check_arg_rv( (prop!=0),"prop");
1585     value = icalvalue_new_text(v);
1586     icalproperty_set_value(prop,value);
1587 }
1588 const char* icalproperty_get_resources(icalproperty* prop){
1589     icalvalue *value;
1590     icalerror_check_arg( (prop!=0),"prop");
1591     value = icalproperty_get_value(prop);
1592     return icalvalue_get_text(value);
1593 }
1594 /* RRULE */
1595 icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v) {
1596    struct icalproperty_impl *impl;
1597
1598    impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY);
1599    icalproperty_set_rrule((icalproperty*)impl,v);
1600    return (icalproperty*)impl;
1601 }
1602 icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...){
1603    va_list args;
1604    struct icalproperty_impl *impl;
1605
1606    impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY);
1607    icalproperty_set_rrule((icalproperty*)impl,v);
1608    va_start(args,v);
1609    icalproperty_add_parameters(impl, args);
1610    va_end(args);
1611    return (icalproperty*)impl;
1612 }
1613 void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v){
1614     icalvalue *value;
1615
1616     icalerror_check_arg_rv( (prop!=0),"prop");
1617     value = icalvalue_new_recur(v);
1618     icalproperty_set_value(prop,value);
1619 }
1620 struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop){
1621     icalvalue *value;
1622     icalerror_check_arg( (prop!=0),"prop");
1623     value = icalproperty_get_value(prop);
1624     return icalvalue_get_recur(value);
1625 }
1626 /* SCOPE */
1627 icalproperty* icalproperty_new_scope(const char* v) {
1628    struct icalproperty_impl *impl;
1629    icalerror_check_arg_rz( (v!=0),"v");
1630
1631    impl = icalproperty_new_impl(ICAL_SCOPE_PROPERTY);
1632    icalproperty_set_scope((icalproperty*)impl,v);
1633    return (icalproperty*)impl;
1634 }
1635 icalproperty* icalproperty_vanew_scope(const char* v, ...){
1636    va_list args;
1637    struct icalproperty_impl *impl;
1638    icalerror_check_arg_rz( (v!=0),"v");
1639
1640    impl = icalproperty_new_impl(ICAL_SCOPE_PROPERTY);
1641    icalproperty_set_scope((icalproperty*)impl,v);
1642    va_start(args,v);
1643    icalproperty_add_parameters(impl, args);
1644    va_end(args);
1645    return (icalproperty*)impl;
1646 }
1647 void icalproperty_set_scope(icalproperty* prop, const char* v){
1648     icalvalue *value;
1649     icalerror_check_arg_rv( (v!=0),"v");
1650
1651     icalerror_check_arg_rv( (prop!=0),"prop");
1652     value = icalvalue_new_text(v);
1653     icalproperty_set_value(prop,value);
1654 }
1655 const char* icalproperty_get_scope(icalproperty* prop){
1656     icalvalue *value;
1657     icalerror_check_arg( (prop!=0),"prop");
1658     value = icalproperty_get_value(prop);
1659     return icalvalue_get_text(value);
1660 }
1661 /* SEQUENCE */
1662 icalproperty* icalproperty_new_sequence(int v) {
1663    struct icalproperty_impl *impl;
1664
1665    impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY);
1666    icalproperty_set_sequence((icalproperty*)impl,v);
1667    return (icalproperty*)impl;
1668 }
1669 icalproperty* icalproperty_vanew_sequence(int v, ...){
1670    va_list args;
1671    struct icalproperty_impl *impl;
1672
1673    impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY);
1674    icalproperty_set_sequence((icalproperty*)impl,v);
1675    va_start(args,v);
1676    icalproperty_add_parameters(impl, args);
1677    va_end(args);
1678    return (icalproperty*)impl;
1679 }
1680 void icalproperty_set_sequence(icalproperty* prop, int v){
1681     icalvalue *value;
1682
1683     icalerror_check_arg_rv( (prop!=0),"prop");
1684     value = icalvalue_new_integer(v);
1685     icalproperty_set_value(prop,value);
1686 }
1687 int icalproperty_get_sequence(icalproperty* prop){
1688     icalvalue *value;
1689     icalerror_check_arg( (prop!=0),"prop");
1690     value = icalproperty_get_value(prop);
1691     return icalvalue_get_integer(value);
1692 }
1693 /* STATUS */
1694 icalproperty* icalproperty_new_status(enum icalproperty_status v) {
1695    struct icalproperty_impl *impl;
1696
1697    impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY);
1698    icalproperty_set_status((icalproperty*)impl,v);
1699    return (icalproperty*)impl;
1700 }
1701 icalproperty* icalproperty_vanew_status(enum icalproperty_status v, ...){
1702    va_list args;
1703    struct icalproperty_impl *impl;
1704
1705    impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY);
1706    icalproperty_set_status((icalproperty*)impl,v);
1707    va_start(args,v);
1708    icalproperty_add_parameters(impl, args);
1709    va_end(args);
1710    return (icalproperty*)impl;
1711 }
1712 void icalproperty_set_status(icalproperty* prop, enum icalproperty_status v){
1713     icalvalue *value;
1714
1715     icalerror_check_arg_rv( (prop!=0),"prop");
1716     value = icalvalue_new_status(v);
1717     icalproperty_set_value(prop,value);
1718 }
1719 enum icalproperty_status icalproperty_get_status(icalproperty* prop){
1720     icalvalue *value;
1721     icalerror_check_arg( (prop!=0),"prop");
1722     value = icalproperty_get_value(prop);
1723     return icalvalue_get_status(value);
1724 }
1725 /* SUMMARY */
1726 icalproperty* icalproperty_new_summary(const char* v) {
1727    struct icalproperty_impl *impl;
1728    icalerror_check_arg_rz( (v!=0),"v");
1729
1730    impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY);
1731    icalproperty_set_summary((icalproperty*)impl,v);
1732    return (icalproperty*)impl;
1733 }
1734 icalproperty* icalproperty_vanew_summary(const char* v, ...){
1735    va_list args;
1736    struct icalproperty_impl *impl;
1737    icalerror_check_arg_rz( (v!=0),"v");
1738
1739    impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY);
1740    icalproperty_set_summary((icalproperty*)impl,v);
1741    va_start(args,v);
1742    icalproperty_add_parameters(impl, args);
1743    va_end(args);
1744    return (icalproperty*)impl;
1745 }
1746 void icalproperty_set_summary(icalproperty* prop, const char* v){
1747     icalvalue *value;
1748     icalerror_check_arg_rv( (v!=0),"v");
1749
1750     icalerror_check_arg_rv( (prop!=0),"prop");
1751     value = icalvalue_new_text(v);
1752     icalproperty_set_value(prop,value);
1753 }
1754 const char* icalproperty_get_summary(icalproperty* prop){
1755     icalvalue *value;
1756     icalerror_check_arg( (prop!=0),"prop");
1757     value = icalproperty_get_value(prop);
1758     return icalvalue_get_text(value);
1759 }
1760 /* TARGET */
1761 icalproperty* icalproperty_new_target(const char* v) {
1762    struct icalproperty_impl *impl;
1763    icalerror_check_arg_rz( (v!=0),"v");
1764
1765    impl = icalproperty_new_impl(ICAL_TARGET_PROPERTY);
1766    icalproperty_set_target((icalproperty*)impl,v);
1767    return (icalproperty*)impl;
1768 }
1769 icalproperty* icalproperty_vanew_target(const char* v, ...){
1770    va_list args;
1771    struct icalproperty_impl *impl;
1772    icalerror_check_arg_rz( (v!=0),"v");
1773
1774    impl = icalproperty_new_impl(ICAL_TARGET_PROPERTY);
1775    icalproperty_set_target((icalproperty*)impl,v);
1776    va_start(args,v);
1777    icalproperty_add_parameters(impl, args);
1778    va_end(args);
1779    return (icalproperty*)impl;
1780 }
1781 void icalproperty_set_target(icalproperty* prop, const char* v){
1782     icalvalue *value;
1783     icalerror_check_arg_rv( (v!=0),"v");
1784
1785     icalerror_check_arg_rv( (prop!=0),"prop");
1786     value = icalvalue_new_caladdress(v);
1787     icalproperty_set_value(prop,value);
1788 }
1789 const char* icalproperty_get_target(icalproperty* prop){
1790     icalvalue *value;
1791     icalerror_check_arg( (prop!=0),"prop");
1792     value = icalproperty_get_value(prop);
1793     return icalvalue_get_caladdress(value);
1794 }
1795 /* TRANSP */
1796 icalproperty* icalproperty_new_transp(const char* v) {
1797    struct icalproperty_impl *impl;
1798    icalerror_check_arg_rz( (v!=0),"v");
1799
1800    impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY);
1801    icalproperty_set_transp((icalproperty*)impl,v);
1802    return (icalproperty*)impl;
1803 }
1804 icalproperty* icalproperty_vanew_transp(const char* v, ...){
1805    va_list args;
1806    struct icalproperty_impl *impl;
1807    icalerror_check_arg_rz( (v!=0),"v");
1808
1809    impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY);
1810    icalproperty_set_transp((icalproperty*)impl,v);
1811    va_start(args,v);
1812    icalproperty_add_parameters(impl, args);
1813    va_end(args);
1814    return (icalproperty*)impl;
1815 }
1816 void icalproperty_set_transp(icalproperty* prop, const char* v){
1817     icalvalue *value;
1818     icalerror_check_arg_rv( (v!=0),"v");
1819
1820     icalerror_check_arg_rv( (prop!=0),"prop");
1821     value = icalvalue_new_text(v);
1822     icalproperty_set_value(prop,value);
1823 }
1824 const char* icalproperty_get_transp(icalproperty* prop){
1825     icalvalue *value;
1826     icalerror_check_arg( (prop!=0),"prop");
1827     value = icalproperty_get_value(prop);
1828     return icalvalue_get_text(value);
1829 }
1830 /* TRIGGER */
1831 icalproperty* icalproperty_new_trigger(struct icaltriggertype v) {
1832    struct icalproperty_impl *impl;
1833
1834    impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY);
1835    icalproperty_set_trigger((icalproperty*)impl,v);
1836    return (icalproperty*)impl;
1837 }
1838 icalproperty* icalproperty_vanew_trigger(struct icaltriggertype v, ...){
1839    va_list args;
1840    struct icalproperty_impl *impl;
1841
1842    impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY);
1843    icalproperty_set_trigger((icalproperty*)impl,v);
1844    va_start(args,v);
1845    icalproperty_add_parameters(impl, args);
1846    va_end(args);
1847    return (icalproperty*)impl;
1848 }
1849 void icalproperty_set_trigger(icalproperty* prop, struct icaltriggertype v){
1850     icalvalue *value;
1851
1852     icalerror_check_arg_rv( (prop!=0),"prop");
1853     value = icalvalue_new_trigger(v);
1854     icalproperty_set_value(prop,value);
1855 }
1856 struct icaltriggertype icalproperty_get_trigger(icalproperty* prop){
1857     icalvalue *value;
1858     icalerror_check_arg( (prop!=0),"prop");
1859     value = icalproperty_get_value(prop);
1860     return icalvalue_get_trigger(value);
1861 }
1862 /* TZID */
1863 icalproperty* icalproperty_new_tzid(const char* v) {
1864    struct icalproperty_impl *impl;
1865    icalerror_check_arg_rz( (v!=0),"v");
1866
1867    impl = icalproperty_new_impl(ICAL_TZID_PROPERTY);
1868    icalproperty_set_tzid((icalproperty*)impl,v);
1869    return (icalproperty*)impl;
1870 }
1871 icalproperty* icalproperty_vanew_tzid(const char* v, ...){
1872    va_list args;
1873    struct icalproperty_impl *impl;
1874    icalerror_check_arg_rz( (v!=0),"v");
1875
1876    impl = icalproperty_new_impl(ICAL_TZID_PROPERTY);
1877    icalproperty_set_tzid((icalproperty*)impl,v);
1878    va_start(args,v);
1879    icalproperty_add_parameters(impl, args);
1880    va_end(args);
1881    return (icalproperty*)impl;
1882 }
1883 void icalproperty_set_tzid(icalproperty* prop, const char* v){
1884     icalvalue *value;
1885     icalerror_check_arg_rv( (v!=0),"v");
1886
1887     icalerror_check_arg_rv( (prop!=0),"prop");
1888     value = icalvalue_new_text(v);
1889     icalproperty_set_value(prop,value);
1890 }
1891 const char* icalproperty_get_tzid(icalproperty* prop){
1892     icalvalue *value;
1893     icalerror_check_arg( (prop!=0),"prop");
1894     value = icalproperty_get_value(prop);
1895     return icalvalue_get_text(value);
1896 }
1897 /* TZNAME */
1898 icalproperty* icalproperty_new_tzname(const char* v) {
1899    struct icalproperty_impl *impl;
1900    icalerror_check_arg_rz( (v!=0),"v");
1901
1902    impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY);
1903    icalproperty_set_tzname((icalproperty*)impl,v);
1904    return (icalproperty*)impl;
1905 }
1906 icalproperty* icalproperty_vanew_tzname(const char* v, ...){
1907    va_list args;
1908    struct icalproperty_impl *impl;
1909    icalerror_check_arg_rz( (v!=0),"v");
1910
1911    impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY);
1912    icalproperty_set_tzname((icalproperty*)impl,v);
1913    va_start(args,v);
1914    icalproperty_add_parameters(impl, args);
1915    va_end(args);
1916    return (icalproperty*)impl;
1917 }
1918 void icalproperty_set_tzname(icalproperty* prop, const char* v){
1919     icalvalue *value;
1920     icalerror_check_arg_rv( (v!=0),"v");
1921
1922     icalerror_check_arg_rv( (prop!=0),"prop");
1923     value = icalvalue_new_text(v);
1924     icalproperty_set_value(prop,value);
1925 }
1926 const char* icalproperty_get_tzname(icalproperty* prop){
1927     icalvalue *value;
1928     icalerror_check_arg( (prop!=0),"prop");
1929     value = icalproperty_get_value(prop);
1930     return icalvalue_get_text(value);
1931 }
1932 /* TZOFFSETFROM */
1933 icalproperty* icalproperty_new_tzoffsetfrom(int v) {
1934    struct icalproperty_impl *impl;
1935
1936    impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY);
1937    icalproperty_set_tzoffsetfrom((icalproperty*)impl,v);
1938    return (icalproperty*)impl;
1939 }
1940 icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...){
1941    va_list args;
1942    struct icalproperty_impl *impl;
1943
1944    impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY);
1945    icalproperty_set_tzoffsetfrom((icalproperty*)impl,v);
1946    va_start(args,v);
1947    icalproperty_add_parameters(impl, args);
1948    va_end(args);
1949    return (icalproperty*)impl;
1950 }
1951 void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v){
1952     icalvalue *value;
1953
1954     icalerror_check_arg_rv( (prop!=0),"prop");
1955     value = icalvalue_new_utcoffset(v);
1956     icalproperty_set_value(prop,value);
1957 }
1958 int icalproperty_get_tzoffsetfrom(icalproperty* prop){
1959     icalvalue *value;
1960     icalerror_check_arg( (prop!=0),"prop");
1961     value = icalproperty_get_value(prop);
1962     return icalvalue_get_utcoffset(value);
1963 }
1964 /* TZOFFSETTO */
1965 icalproperty* icalproperty_new_tzoffsetto(int v) {
1966    struct icalproperty_impl *impl;
1967
1968    impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY);
1969    icalproperty_set_tzoffsetto((icalproperty*)impl,v);
1970    return (icalproperty*)impl;
1971 }
1972 icalproperty* icalproperty_vanew_tzoffsetto(int v, ...){
1973    va_list args;
1974    struct icalproperty_impl *impl;
1975
1976    impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY);
1977    icalproperty_set_tzoffsetto((icalproperty*)impl,v);
1978    va_start(args,v);
1979    icalproperty_add_parameters(impl, args);
1980    va_end(args);
1981    return (icalproperty*)impl;
1982 }
1983 void icalproperty_set_tzoffsetto(icalproperty* prop, int v){
1984     icalvalue *value;
1985
1986     icalerror_check_arg_rv( (prop!=0),"prop");
1987     value = icalvalue_new_utcoffset(v);
1988     icalproperty_set_value(prop,value);
1989 }
1990 int icalproperty_get_tzoffsetto(icalproperty* prop){
1991     icalvalue *value;
1992     icalerror_check_arg( (prop!=0),"prop");
1993     value = icalproperty_get_value(prop);
1994     return icalvalue_get_utcoffset(value);
1995 }
1996 /* TZURL */
1997 icalproperty* icalproperty_new_tzurl(const char* v) {
1998    struct icalproperty_impl *impl;
1999    icalerror_check_arg_rz( (v!=0),"v");
2000
2001    impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY);
2002    icalproperty_set_tzurl((icalproperty*)impl,v);
2003    return (icalproperty*)impl;
2004 }
2005 icalproperty* icalproperty_vanew_tzurl(const char* v, ...){
2006    va_list args;
2007    struct icalproperty_impl *impl;
2008    icalerror_check_arg_rz( (v!=0),"v");
2009
2010    impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY);
2011    icalproperty_set_tzurl((icalproperty*)impl,v);
2012    va_start(args,v);
2013    icalproperty_add_parameters(impl, args);
2014    va_end(args);
2015    return (icalproperty*)impl;
2016 }
2017 void icalproperty_set_tzurl(icalproperty* prop, const char* v){
2018     icalvalue *value;
2019     icalerror_check_arg_rv( (v!=0),"v");
2020
2021     icalerror_check_arg_rv( (prop!=0),"prop");
2022     value = icalvalue_new_uri(v);
2023     icalproperty_set_value(prop,value);
2024 }
2025 const char* icalproperty_get_tzurl(icalproperty* prop){
2026     icalvalue *value;
2027     icalerror_check_arg( (prop!=0),"prop");
2028     value = icalproperty_get_value(prop);
2029     return icalvalue_get_uri(value);
2030 }
2031 /* UID */
2032 icalproperty* icalproperty_new_uid(const char* v) {
2033    struct icalproperty_impl *impl;
2034    icalerror_check_arg_rz( (v!=0),"v");
2035
2036    impl = icalproperty_new_impl(ICAL_UID_PROPERTY);
2037    icalproperty_set_uid((icalproperty*)impl,v);
2038    return (icalproperty*)impl;
2039 }
2040 icalproperty* icalproperty_vanew_uid(const char* v, ...){
2041    va_list args;
2042    struct icalproperty_impl *impl;
2043    icalerror_check_arg_rz( (v!=0),"v");
2044
2045    impl = icalproperty_new_impl(ICAL_UID_PROPERTY);
2046    icalproperty_set_uid((icalproperty*)impl,v);
2047    va_start(args,v);
2048    icalproperty_add_parameters(impl, args);
2049    va_end(args);
2050    return (icalproperty*)impl;
2051 }
2052 void icalproperty_set_uid(icalproperty* prop, const char* v){
2053     icalvalue *value;
2054     icalerror_check_arg_rv( (v!=0),"v");
2055
2056     icalerror_check_arg_rv( (prop!=0),"prop");
2057     value = icalvalue_new_text(v);
2058     icalproperty_set_value(prop,value);
2059 }
2060 const char* icalproperty_get_uid(icalproperty* prop){
2061     icalvalue *value;
2062     icalerror_check_arg( (prop!=0),"prop");
2063     value = icalproperty_get_value(prop);
2064     return icalvalue_get_text(value);
2065 }
2066 /* URL */
2067 icalproperty* icalproperty_new_url(const char* v) {
2068    struct icalproperty_impl *impl;
2069    icalerror_check_arg_rz( (v!=0),"v");
2070
2071    impl = icalproperty_new_impl(ICAL_URL_PROPERTY);
2072    icalproperty_set_url((icalproperty*)impl,v);
2073    return (icalproperty*)impl;
2074 }
2075 icalproperty* icalproperty_vanew_url(const char* v, ...){
2076    va_list args;
2077    struct icalproperty_impl *impl;
2078    icalerror_check_arg_rz( (v!=0),"v");
2079
2080    impl = icalproperty_new_impl(ICAL_URL_PROPERTY);
2081    icalproperty_set_url((icalproperty*)impl,v);
2082    va_start(args,v);
2083    icalproperty_add_parameters(impl, args);
2084    va_end(args);
2085    return (icalproperty*)impl;
2086 }
2087 void icalproperty_set_url(icalproperty* prop, const char* v){
2088     icalvalue *value;
2089     icalerror_check_arg_rv( (v!=0),"v");
2090
2091     icalerror_check_arg_rv( (prop!=0),"prop");
2092     value = icalvalue_new_uri(v);
2093     icalproperty_set_value(prop,value);
2094 }
2095 const char* icalproperty_get_url(icalproperty* prop){
2096     icalvalue *value;
2097     icalerror_check_arg( (prop!=0),"prop");
2098     value = icalproperty_get_value(prop);
2099     return icalvalue_get_uri(value);
2100 }
2101 /* VERSION */
2102 icalproperty* icalproperty_new_version(const char* v) {
2103    struct icalproperty_impl *impl;
2104    icalerror_check_arg_rz( (v!=0),"v");
2105
2106    impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY);
2107    icalproperty_set_version((icalproperty*)impl,v);
2108    return (icalproperty*)impl;
2109 }
2110 icalproperty* icalproperty_vanew_version(const char* v, ...){
2111    va_list args;
2112    struct icalproperty_impl *impl;
2113    icalerror_check_arg_rz( (v!=0),"v");
2114
2115    impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY);
2116    icalproperty_set_version((icalproperty*)impl,v);
2117    va_start(args,v);
2118    icalproperty_add_parameters(impl, args);
2119    va_end(args);
2120    return (icalproperty*)impl;
2121 }
2122 void icalproperty_set_version(icalproperty* prop, const char* v){
2123     icalvalue *value;
2124     icalerror_check_arg_rv( (v!=0),"v");
2125
2126     icalerror_check_arg_rv( (prop!=0),"prop");
2127     value = icalvalue_new_text(v);
2128     icalproperty_set_value(prop,value);
2129 }
2130 const char* icalproperty_get_version(icalproperty* prop){
2131     icalvalue *value;
2132     icalerror_check_arg( (prop!=0),"prop");
2133     value = icalproperty_get_value(prop);
2134     return icalvalue_get_text(value);
2135 }
2136 /* X */
2137 icalproperty* icalproperty_new_x(const char* v) {
2138    struct icalproperty_impl *impl;
2139    icalerror_check_arg_rz( (v!=0),"v");
2140
2141    impl = icalproperty_new_impl(ICAL_X_PROPERTY);
2142    icalproperty_set_x((icalproperty*)impl,v);
2143    return (icalproperty*)impl;
2144 }
2145 icalproperty* icalproperty_vanew_x(const char* v, ...){
2146    va_list args;
2147    struct icalproperty_impl *impl;
2148    icalerror_check_arg_rz( (v!=0),"v");
2149
2150    impl = icalproperty_new_impl(ICAL_X_PROPERTY);
2151    icalproperty_set_x((icalproperty*)impl,v);
2152    va_start(args,v);
2153    icalproperty_add_parameters(impl, args);
2154    va_end(args);
2155    return (icalproperty*)impl;
2156 }
2157 void icalproperty_set_x(icalproperty* prop, const char* v){
2158     icalvalue *value;
2159     icalerror_check_arg_rv( (v!=0),"v");
2160
2161     icalerror_check_arg_rv( (prop!=0),"prop");
2162     value = icalvalue_new_text(v);
2163     icalproperty_set_value(prop,value);
2164 }
2165 const char* icalproperty_get_x(icalproperty* prop){
2166     icalvalue *value;
2167     icalerror_check_arg( (prop!=0),"prop");
2168     value = icalproperty_get_value(prop);
2169     return icalvalue_get_text(value);
2170 }
2171 /* X-LIC-CLUSTERCOUNT */
2172 icalproperty* icalproperty_new_xlicclustercount(const char* v) {
2173    struct icalproperty_impl *impl;
2174    icalerror_check_arg_rz( (v!=0),"v");
2175
2176    impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY);
2177    icalproperty_set_xlicclustercount((icalproperty*)impl,v);
2178    return (icalproperty*)impl;
2179 }
2180 icalproperty* icalproperty_vanew_xlicclustercount(const char* v, ...){
2181    va_list args;
2182    struct icalproperty_impl *impl;
2183    icalerror_check_arg_rz( (v!=0),"v");
2184
2185    impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY);
2186    icalproperty_set_xlicclustercount((icalproperty*)impl,v);
2187    va_start(args,v);
2188    icalproperty_add_parameters(impl, args);
2189    va_end(args);
2190    return (icalproperty*)impl;
2191 }
2192 void icalproperty_set_xlicclustercount(icalproperty* prop, const char* v){
2193     icalvalue *value;
2194     icalerror_check_arg_rv( (v!=0),"v");
2195
2196     icalerror_check_arg_rv( (prop!=0),"prop");
2197     value = icalvalue_new_string(v);
2198     icalproperty_set_value(prop,value);
2199 }
2200 const char* icalproperty_get_xlicclustercount(icalproperty* prop){
2201     icalvalue *value;
2202     icalerror_check_arg( (prop!=0),"prop");
2203     value = icalproperty_get_value(prop);
2204     return icalvalue_get_string(value);
2205 }
2206 /* X-LIC-ERROR */
2207 icalproperty* icalproperty_new_xlicerror(const char* v) {
2208    struct icalproperty_impl *impl;
2209    icalerror_check_arg_rz( (v!=0),"v");
2210
2211    impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY);
2212    icalproperty_set_xlicerror((icalproperty*)impl,v);
2213    return (icalproperty*)impl;
2214 }
2215 icalproperty* icalproperty_vanew_xlicerror(const char* v, ...){
2216    va_list args;
2217    struct icalproperty_impl *impl;
2218    icalerror_check_arg_rz( (v!=0),"v");
2219
2220    impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY);
2221    icalproperty_set_xlicerror((icalproperty*)impl,v);
2222    va_start(args,v);
2223    icalproperty_add_parameters(impl, args);
2224    va_end(args);
2225    return (icalproperty*)impl;
2226 }
2227 void icalproperty_set_xlicerror(icalproperty* prop, const char* v){
2228     icalvalue *value;
2229     icalerror_check_arg_rv( (v!=0),"v");
2230
2231     icalerror_check_arg_rv( (prop!=0),"prop");
2232     value = icalvalue_new_text(v);
2233     icalproperty_set_value(prop,value);
2234 }
2235 const char* icalproperty_get_xlicerror(icalproperty* prop){
2236     icalvalue *value;
2237     icalerror_check_arg( (prop!=0),"prop");
2238     value = icalproperty_get_value(prop);
2239     return icalvalue_get_text(value);
2240 }
2241 /* X-LIC-MIMECHARSET */
2242 icalproperty* icalproperty_new_xlicmimecharset(const char* v) {
2243    struct icalproperty_impl *impl;
2244    icalerror_check_arg_rz( (v!=0),"v");
2245
2246    impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY);
2247    icalproperty_set_xlicmimecharset((icalproperty*)impl,v);
2248    return (icalproperty*)impl;
2249 }
2250 icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...){
2251    va_list args;
2252    struct icalproperty_impl *impl;
2253    icalerror_check_arg_rz( (v!=0),"v");
2254
2255    impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY);
2256    icalproperty_set_xlicmimecharset((icalproperty*)impl,v);
2257    va_start(args,v);
2258    icalproperty_add_parameters(impl, args);
2259    va_end(args);
2260    return (icalproperty*)impl;
2261 }
2262 void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v){
2263     icalvalue *value;
2264     icalerror_check_arg_rv( (v!=0),"v");
2265
2266     icalerror_check_arg_rv( (prop!=0),"prop");
2267     value = icalvalue_new_string(v);
2268     icalproperty_set_value(prop,value);
2269 }
2270 const char* icalproperty_get_xlicmimecharset(icalproperty* prop){
2271     icalvalue *value;
2272     icalerror_check_arg( (prop!=0),"prop");
2273     value = icalproperty_get_value(prop);
2274     return icalvalue_get_string(value);
2275 }
2276 /* X-LIC-MIMECID */
2277 icalproperty* icalproperty_new_xlicmimecid(const char* v) {
2278    struct icalproperty_impl *impl;
2279    icalerror_check_arg_rz( (v!=0),"v");
2280
2281    impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY);
2282    icalproperty_set_xlicmimecid((icalproperty*)impl,v);
2283    return (icalproperty*)impl;
2284 }
2285 icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...){
2286    va_list args;
2287    struct icalproperty_impl *impl;
2288    icalerror_check_arg_rz( (v!=0),"v");
2289
2290    impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY);
2291    icalproperty_set_xlicmimecid((icalproperty*)impl,v);
2292    va_start(args,v);
2293    icalproperty_add_parameters(impl, args);
2294    va_end(args);
2295    return (icalproperty*)impl;
2296 }
2297 void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v){
2298     icalvalue *value;
2299     icalerror_check_arg_rv( (v!=0),"v");
2300
2301     icalerror_check_arg_rv( (prop!=0),"prop");
2302     value = icalvalue_new_string(v);
2303     icalproperty_set_value(prop,value);
2304 }
2305 const char* icalproperty_get_xlicmimecid(icalproperty* prop){
2306     icalvalue *value;
2307     icalerror_check_arg( (prop!=0),"prop");
2308     value = icalproperty_get_value(prop);
2309     return icalvalue_get_string(value);
2310 }
2311 /* X-LIC-MIMECONTENTTYPE */
2312 icalproperty* icalproperty_new_xlicmimecontenttype(const char* v) {
2313    struct icalproperty_impl *impl;
2314    icalerror_check_arg_rz( (v!=0),"v");
2315
2316    impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY);
2317    icalproperty_set_xlicmimecontenttype((icalproperty*)impl,v);
2318    return (icalproperty*)impl;
2319 }
2320 icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...){
2321    va_list args;
2322    struct icalproperty_impl *impl;
2323    icalerror_check_arg_rz( (v!=0),"v");
2324
2325    impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY);
2326    icalproperty_set_xlicmimecontenttype((icalproperty*)impl,v);
2327    va_start(args,v);
2328    icalproperty_add_parameters(impl, args);
2329    va_end(args);
2330    return (icalproperty*)impl;
2331 }
2332 void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v){
2333     icalvalue *value;
2334     icalerror_check_arg_rv( (v!=0),"v");
2335
2336     icalerror_check_arg_rv( (prop!=0),"prop");
2337     value = icalvalue_new_string(v);
2338     icalproperty_set_value(prop,value);
2339 }
2340 const char* icalproperty_get_xlicmimecontenttype(icalproperty* prop){
2341     icalvalue *value;
2342     icalerror_check_arg( (prop!=0),"prop");
2343     value = icalproperty_get_value(prop);
2344     return icalvalue_get_string(value);
2345 }
2346 /* X-LIC-MIMEENCODING */
2347 icalproperty* icalproperty_new_xlicmimeencoding(const char* v) {
2348    struct icalproperty_impl *impl;
2349    icalerror_check_arg_rz( (v!=0),"v");
2350
2351    impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY);
2352    icalproperty_set_xlicmimeencoding((icalproperty*)impl,v);
2353    return (icalproperty*)impl;
2354 }
2355 icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...){
2356    va_list args;
2357    struct icalproperty_impl *impl;
2358    icalerror_check_arg_rz( (v!=0),"v");
2359
2360    impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY);
2361    icalproperty_set_xlicmimeencoding((icalproperty*)impl,v);
2362    va_start(args,v);
2363    icalproperty_add_parameters(impl, args);
2364    va_end(args);
2365    return (icalproperty*)impl;
2366 }
2367 void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v){
2368     icalvalue *value;
2369     icalerror_check_arg_rv( (v!=0),"v");
2370
2371     icalerror_check_arg_rv( (prop!=0),"prop");
2372     value = icalvalue_new_string(v);
2373     icalproperty_set_value(prop,value);
2374 }
2375 const char* icalproperty_get_xlicmimeencoding(icalproperty* prop){
2376     icalvalue *value;
2377     icalerror_check_arg( (prop!=0),"prop");
2378     value = icalproperty_get_value(prop);
2379     return icalvalue_get_string(value);
2380 }
2381 /* X-LIC-MIMEFILENAME */
2382 icalproperty* icalproperty_new_xlicmimefilename(const char* v) {
2383    struct icalproperty_impl *impl;
2384    icalerror_check_arg_rz( (v!=0),"v");
2385
2386    impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY);
2387    icalproperty_set_xlicmimefilename((icalproperty*)impl,v);
2388    return (icalproperty*)impl;
2389 }
2390 icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...){
2391    va_list args;
2392    struct icalproperty_impl *impl;
2393    icalerror_check_arg_rz( (v!=0),"v");
2394
2395    impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY);
2396    icalproperty_set_xlicmimefilename((icalproperty*)impl,v);
2397    va_start(args,v);
2398    icalproperty_add_parameters(impl, args);
2399    va_end(args);
2400    return (icalproperty*)impl;
2401 }
2402 void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v){
2403     icalvalue *value;
2404     icalerror_check_arg_rv( (v!=0),"v");
2405
2406     icalerror_check_arg_rv( (prop!=0),"prop");
2407     value = icalvalue_new_string(v);
2408     icalproperty_set_value(prop,value);
2409 }
2410 const char* icalproperty_get_xlicmimefilename(icalproperty* prop){
2411     icalvalue *value;
2412     icalerror_check_arg( (prop!=0),"prop");
2413     value = icalproperty_get_value(prop);
2414     return icalvalue_get_string(value);
2415 }
2416 /* X-LIC-MIMEOPTINFO */
2417 icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v) {
2418    struct icalproperty_impl *impl;
2419    icalerror_check_arg_rz( (v!=0),"v");
2420
2421    impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY);
2422    icalproperty_set_xlicmimeoptinfo((icalproperty*)impl,v);
2423    return (icalproperty*)impl;
2424 }
2425 icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...){
2426    va_list args;
2427    struct icalproperty_impl *impl;
2428    icalerror_check_arg_rz( (v!=0),"v");
2429
2430    impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY);
2431    icalproperty_set_xlicmimeoptinfo((icalproperty*)impl,v);
2432    va_start(args,v);
2433    icalproperty_add_parameters(impl, args);
2434    va_end(args);
2435    return (icalproperty*)impl;
2436 }
2437 void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v){
2438     icalvalue *value;
2439     icalerror_check_arg_rv( (v!=0),"v");
2440
2441     icalerror_check_arg_rv( (prop!=0),"prop");
2442     value = icalvalue_new_string(v);
2443     icalproperty_set_value(prop,value);
2444 }
2445 const char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop){
2446     icalvalue *value;
2447     icalerror_check_arg( (prop!=0),"prop");
2448     value = icalproperty_get_value(prop);
2449     return icalvalue_get_string(value);
2450 }