diff options
Diffstat (limited to 'libical/src/libical/icalproperty.c')
| -rw-r--r-- | libical/src/libical/icalproperty.c | 3083 |
1 files changed, 3083 insertions, 0 deletions
diff --git a/libical/src/libical/icalproperty.c b/libical/src/libical/icalproperty.c new file mode 100644 index 0000000000..7eb7c81111 --- /dev/null +++ b/libical/src/libical/icalproperty.c @@ -0,0 +1,3083 @@ +/* -*- Mode: C -*- */ +/*====================================================================== + FILE: icalproperty.c + CREATOR: eric 28 April 1999 + + $Id$ + + + (C) COPYRIGHT 1999 Eric Busboom + http://www.softwarestudio.org + + The contents of this file are subject to the Mozilla Public License + Version 1.0 (the "License"); you may not use this file except in + compliance with the License. You may obtain a copy of the License at + http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS IS" + basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + the License for the specific language governing rights and + limitations under the License. + + The original author is Eric Busboom + The original code is icalproperty.c + +======================================================================*/ + +#include <string.h> /* For strdup, rindex */ +#include <assert.h> +#include <stdlib.h> +#include <errno.h> +#include <stdio.h> /* for printf */ +#include <stdarg.h> /* for va_list, va_start, etc. */ + +#include "ical.h" +#include "pvl.h" +#include "icalenums.h" +#include "icalerror.h" +#include "icalmemory.h" + +/* Private routines for icalproperty */ +void icalvalue_set_parent(icalvalue* value, + icalproperty* property); +icalproperty* icalvalue_get_parent(icalvalue* value); + +void icalparameter_set_parent(icalparameter* param, + icalproperty* property); +icalproperty* icalparameter_get_parent(icalparameter* value); + + +void icalproperty_set_x_name(icalproperty* prop, char* name); + +struct icalproperty_impl +{ + char id[5]; + icalproperty_kind kind; + char* x_name; + pvl_list parameters; + pvl_elem parameter_iterator; + icalvalue* value; + icalcomponent *parent; +}; + +void icalproperty_add_parameters(struct icalproperty_impl *impl,va_list args) +{ + + void* vp; + + while((vp = va_arg(args, void*)) != 0) { + + if (icalvalue_isa_value(vp) != 0 ){ + } else if (icalparameter_isa_parameter(vp) != 0 ){ + + icalproperty_add_parameter((icalproperty*)impl, + (icalparameter*)vp); + } else { + abort(); + } + + } + + +} + +struct icalproperty_impl* +icalproperty_new_impl (icalproperty_kind kind) +{ + struct icalproperty_impl* prop; + + if ( ( prop = (struct icalproperty_impl*) + malloc(sizeof(struct icalproperty_impl))) == 0) { + errno = ENOMEM; + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + + strcpy(prop->id,"prop"); + + prop->kind = kind; + prop->parameters = pvl_newlist(); + prop->parameter_iterator = 0; + prop->value = 0; + prop->x_name = 0; + prop->parent = 0; + + return prop; +} + + +icalproperty* +icalproperty_new (icalproperty_kind kind) +{ + icalproperty *prop = (icalproperty*)icalproperty_new_impl(kind); + + return prop; +} + + +icalproperty* +icalproperty_new_clone(icalproperty* prop) +{ + struct icalproperty_impl *old = (struct icalproperty_impl*)prop; + struct icalproperty_impl *new = icalproperty_new_impl(old->kind); + pvl_elem p; + + icalerror_check_arg_rz((prop!=0),"Prop"); + icalerror_check_arg_rz((old!=0),"old"); + icalerror_check_arg_rz((new!=0),"new"); + + if (old->value !=0) { + new->value = icalvalue_new_clone(old->value); + } + + if (old->x_name != 0) { + + new->x_name = strdup(old->x_name); + + if (new->x_name == 0) { + icalproperty_free(new); + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + } + + for(p=pvl_head(old->parameters);p != 0; p = pvl_next(p)){ + icalparameter *param = icalparameter_new_clone(pvl_data(p)); + + if (param == 0){ + icalproperty_free(new); + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } + + pvl_push(new->parameters,param); + + } + + return new; + +} + +/* This one works a little differently from the other *_from_string + routines; the string input is the name of the property, not the + data associated with the property, as it is in + icalvalue_from_string. All of the parsing associated with + properties is driven by routines in icalparse.c */ + +icalproperty* icalproperty_new_from_string(char* str) +{ + icalproperty_kind kind; + + icalerror_check_arg_rz( (str!=0),"str"); + + kind = icalenum_string_to_property_kind(str); + + if (kind == ICAL_NO_PROPERTY){ + + if( str[0] == 'X' && str[1] == '-'){ + icalproperty *p = icalproperty_new(ICAL_X_PROPERTY); + icalproperty_set_x_name(p,str); + return p; + } else { + icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR); + return 0; + } + + } else { + return icalproperty_new(kind); + } +} + +void +icalproperty_free (icalproperty* prop) +{ + struct icalproperty_impl *p; + + icalparameter* param; + + icalerror_check_arg_re((prop!=0),"prop",ICAL_BADARG_ERROR); + + p = (struct icalproperty_impl*)prop; + +#ifdef ICAL_FREE_ON_LIST_IS_ERROR + icalerror_assert( (p->parent ==0),"Tried to free a property that is still attached to a component. "); + +#else + if(p->parent !=0){ + return; + } +#endif + + if (p->value != 0){ + icalvalue_set_parent(p->value,0); + icalvalue_free(p->value); + } + + while( (param = pvl_pop(p->parameters)) != 0){ + icalparameter_free(param); + } + + pvl_free(p->parameters); + + if (p->x_name != 0) { + free(p->x_name); + } + + p->kind = ICAL_NO_PROPERTY; + p->parameters = 0; + p->parameter_iterator = 0; + p->value = 0; + p->x_name = 0; + p->id[0] = 'X'; + + free(p); + +} + + +char* +icalproperty_as_ical_string (icalproperty* prop) +{ + icalparameter *param; + + /* Create new buffer that we can append names, parameters and a + value to, and reallocate as needed. Later, this buffer will be + copied to a icalmemory_tmp_buffer, which is managed internally + by libical, so it can be given to the caller without fear of + the caller forgetting to free it */ + + char* property_name = 0; + size_t buf_size = 1024; + char* buf = icalmemory_new_buffer(buf_size); + char* buf_ptr = buf; + icalvalue* value; + char *out_buf; + + struct icalproperty_impl *impl = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rz( (prop!=0),"prop"); + + /* Append property name */ + + if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){ + property_name = impl->x_name; + } else { + property_name = icalenum_property_kind_to_string(impl->kind); + } + + if (property_name == 0 ) { + icalerror_warn("Got a property of an unknown kind."); + icalmemory_free_buffer(buf); + return 0; + + } + + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, property_name); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n"); + + /* Append parameters */ + for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER); + param != 0; + param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) { + + char* kind_string = icalparameter_as_ical_string(param); + + if (kind_string == 0 ) { + char temp[1024]; + sprintf(temp, "Got a parameter of unknown kind in %s property",property_name); + icalerror_warn(temp); + continue; + } + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;"); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string); + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n"); + + } + + /* Append value */ + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, " :"); + + value = icalproperty_get_value(prop); + + if (value != 0){ + icalmemory_append_string(&buf, &buf_ptr, &buf_size, + icalvalue_as_ical_string(icalproperty_get_value(prop))); + } else { + icalmemory_append_string(&buf, &buf_ptr, &buf_size,"ERROR: No Value"); + + } + + icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n"); + + /* Now, copy the buffer to a tmp_buffer, which is safe to give to + the caller without worring about de-allocating it. */ + + + out_buf = icalmemory_tmp_buffer(strlen(buf)+1); + strcpy(out_buf, buf); + + icalmemory_free_buffer(buf); + + return out_buf; +} + + + +icalproperty_kind +icalproperty_isa (icalproperty* property) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)property; + + if(property != 0){ + return p->kind; + } + + return ICAL_NO_PROPERTY; +} + +int +icalproperty_isa_property (void* property) +{ + struct icalproperty_impl *impl = (struct icalproperty_impl*)property; + + icalerror_check_arg_rz( (property!=0), "property"); + + if (strcmp(impl->id,"prop") == 0) { + return 1; + } else { + return 0; + } +} + + +void +icalproperty_add_parameter (icalproperty* prop,icalparameter* parameter) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rv( (prop!=0),"prop"); + icalerror_check_arg_rv( (parameter!=0),"parameter"); + + pvl_push(p->parameters, parameter); + +} + + +void +icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind) +{ + icalerror_check_arg_rv((prop!=0),"prop"); + + assert(0); /* This routine is not implemented */ +} + + +int +icalproperty_count_parameters (icalproperty* prop) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + + if(prop != 0){ + return pvl_count(p->parameters); + } + + icalerror_set_errno(ICAL_USAGE_ERROR); + return -1; +} + + +icalparameter* +icalproperty_get_first_parameter (icalproperty* prop, icalparameter_kind kind) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rz( (prop!=0),"prop"); + + p->parameter_iterator = pvl_head(p->parameters); + + if (p->parameter_iterator == 0) { + return 0; + } + + return (icalparameter*) pvl_data(p->parameter_iterator); +} + + +icalparameter* +icalproperty_get_next_parameter (icalproperty* prop, icalparameter_kind kind) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + icalerror_check_arg_rz( (prop!=0),"prop"); + + if (p->parameter_iterator == 0 ) { + return 0; + } + + p->parameter_iterator = pvl_next(p->parameter_iterator); + + if (p->parameter_iterator == 0 ) { + return 0; + } + + return (icalparameter*) pvl_data(p->parameter_iterator); +} + +void +icalproperty_set_value (icalproperty* prop, icalvalue* value) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rv((prop !=0),"prop"); + icalerror_check_arg_rv((value !=0),"value"); + + if (p->value != 0){ + icalvalue_set_parent(p->value,0); + icalvalue_free(p->value); + p->value = 0; + } + + p->value = value; + + icalvalue_set_parent(value,prop); +} + + +icalvalue* +icalproperty_get_value (icalproperty* prop) +{ + struct icalproperty_impl *p = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rz( (prop!=0),"prop"); + + return p->value; +} + + +void icalproperty_set_x_name(icalproperty* prop, char* name) +{ + struct icalproperty_impl *impl = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rv( (name!=0),"name"); + icalerror_check_arg_rv( (prop!=0),"prop"); + + if (impl->x_name != 0) { + free(impl->x_name); + } + + impl->x_name = strdup(name); + + if(impl->x_name == 0){ + icalerror_set_errno(ICAL_ALLOCATION_ERROR); + } + +} + +char* icalproperty_get_x_name(icalproperty* prop){ + + struct icalproperty_impl *impl = (struct icalproperty_impl*)prop; + + icalerror_check_arg_rz( (prop!=0),"prop"); + + return impl->x_name; +} + + +void icalproperty_set_parent(icalproperty* property, + icalcomponent* component) +{ + struct icalproperty_impl *impl = (struct icalproperty_impl*)property; + + icalerror_check_arg_rv( (property!=0),"property"); + + impl->parent = component; +} + +icalcomponent* icalproperty_get_parent(icalproperty* property) +{ + struct icalproperty_impl *impl = (struct icalproperty_impl*)property; + + icalerror_check_arg_rv( (property!=0),"property"); + + return impl->parent; +} + + +/* Everything below this line is machine generated. Do not edit. */ + +/* METHOD */ + +icalproperty* icalproperty_new_method(icalproperty_method v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY); + + + icalproperty_set_method((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_method(icalproperty_method v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY); + + + icalproperty_set_method((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_method(icalproperty* prop, icalproperty_method v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_method(v); + + icalproperty_set_value(prop,value); + +} + +icalproperty_method icalproperty_get_method(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_method(value); +} + +/* LAST-MODIFIED */ + +icalproperty* icalproperty_new_lastmodified(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY); + + + icalproperty_set_lastmodified((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY); + + + icalproperty_set_lastmodified((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* UID */ + +icalproperty* icalproperty_new_uid(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_uid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_uid(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_uid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_uid(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_uid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* PRODID */ + +icalproperty* icalproperty_new_prodid(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_prodid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_prodid(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_prodid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_prodid(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_prodid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* STATUS */ + +icalproperty* icalproperty_new_status(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_status((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_status(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_status((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_status(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_status(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* DESCRIPTION */ + +icalproperty* icalproperty_new_description(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_description((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_description(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_description((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_description(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_description(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* DURATION */ + +icalproperty* icalproperty_new_duration(struct icaldurationtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY); + + + icalproperty_set_duration((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY); + + + icalproperty_set_duration((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_duration(v); + + icalproperty_set_value(prop,value); + +} + +struct icaldurationtype icalproperty_get_duration(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_duration(value); +} + +/* CATEGORIES */ + +icalproperty* icalproperty_new_categories(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_categories((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_categories(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_categories((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_categories(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_categories(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* VERSION */ + +icalproperty* icalproperty_new_version(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_version((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_version(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_version((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_version(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_version(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TZOFFSETFROM */ + +icalproperty* icalproperty_new_tzoffsetfrom(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY); + + + icalproperty_set_tzoffsetfrom((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY); + + + icalproperty_set_tzoffsetfrom((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_utcoffset(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_tzoffsetfrom(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_utcoffset(value); +} + +/* RRULE */ + +icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY); + + + icalproperty_set_rrule((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY); + + + icalproperty_set_rrule((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_recur(v); + + icalproperty_set_value(prop,value); + +} + +struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_recur(value); +} + +/* ATTENDEE */ + +icalproperty* icalproperty_new_attendee(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_attendee((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_attendee(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_attendee((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_attendee(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_caladdress(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_attendee(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_caladdress(value); +} + +/* CONTACT */ + +icalproperty* icalproperty_new_contact(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_contact((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_contact(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_contact((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_contact(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_contact(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* RELATED-TO */ + +icalproperty* icalproperty_new_relatedto(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_relatedto((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_relatedto(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_relatedto((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_relatedto(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_relatedto(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* ORGANIZER */ + +icalproperty* icalproperty_new_organizer(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_organizer((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_organizer(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_organizer((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_organizer(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_caladdress(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_organizer(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_caladdress(value); +} + +/* COMMENT */ + +icalproperty* icalproperty_new_comment(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_comment((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_comment(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_comment((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_comment(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_comment(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TRIGGER */ + +icalproperty* icalproperty_new_trigger(union icaltriggertype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY); + + + icalproperty_set_trigger((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_trigger(union icaltriggertype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY); + + + icalproperty_set_trigger((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_trigger(icalproperty* prop, union icaltriggertype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_trigger(v); + + icalproperty_set_value(prop,value); + +} + +union icaltriggertype icalproperty_get_trigger(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_trigger(value); +} + +/* X-LIC-ERROR */ + +icalproperty* icalproperty_new_xlicerror(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicerror((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicerror(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_xlicerror((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicerror(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_xlicerror(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* CLASS */ + +icalproperty* icalproperty_new_class(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_class((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_class(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_class((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_class(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_class(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TZOFFSETTO */ + +icalproperty* icalproperty_new_tzoffsetto(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY); + + + icalproperty_set_tzoffsetto((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzoffsetto(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY); + + + icalproperty_set_tzoffsetto((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzoffsetto(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_utcoffset(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_tzoffsetto(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_utcoffset(value); +} + +/* TRANSP */ + +icalproperty* icalproperty_new_transp(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_transp((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_transp(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_transp((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_transp(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_transp(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* SEQUENCE */ + +icalproperty* icalproperty_new_sequence(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY); + + + icalproperty_set_sequence((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_sequence(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY); + + + icalproperty_set_sequence((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_sequence(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_sequence(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* LOCATION */ + +icalproperty* icalproperty_new_location(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_location((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_location(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_location((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_location(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_location(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* REQUEST-STATUS */ + +icalproperty* icalproperty_new_requeststatus(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_requeststatus((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_requeststatus(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_requeststatus((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_requeststatus(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_requeststatus(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* EXDATE */ + +icalproperty* icalproperty_new_exdate(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY); + + + icalproperty_set_exdate((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY); + + + icalproperty_set_exdate((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_exdate(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* TZID */ + +icalproperty* icalproperty_new_tzid(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzid(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzid(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_tzid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* RESOURCES */ + +icalproperty* icalproperty_new_resources(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_resources((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_resources(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_resources((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_resources(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_resources(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* TZURL */ + +icalproperty* icalproperty_new_tzurl(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzurl((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzurl(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzurl((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzurl(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_uri(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_tzurl(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_uri(value); +} + +/* REPEAT */ + +icalproperty* icalproperty_new_repeat(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY); + + + icalproperty_set_repeat((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_repeat(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY); + + + icalproperty_set_repeat((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_repeat(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_repeat(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* PRIORITY */ + +icalproperty* icalproperty_new_priority(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY); + + + icalproperty_set_priority((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_priority(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY); + + + icalproperty_set_priority((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_priority(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_priority(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* FREEBUSY */ + +icalproperty* icalproperty_new_freebusy(struct icalperiodtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY); + + + icalproperty_set_freebusy((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY); + + + icalproperty_set_freebusy((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_period(v); + + icalproperty_set_value(prop,value); + +} + +struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_period(value); +} + +/* DTSTART */ + +icalproperty* icalproperty_new_dtstart(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY); + + + icalproperty_set_dtstart((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY); + + + icalproperty_set_dtstart((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_dtstart(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* RECURRENCE-ID */ + +icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY); + + + icalproperty_set_recurrenceid((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY); + + + icalproperty_set_recurrenceid((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* SUMMARY */ + +icalproperty* icalproperty_new_summary(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_summary((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_summary(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_summary((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_summary(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_summary(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* DTEND */ + +icalproperty* icalproperty_new_dtend(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY); + + + icalproperty_set_dtend((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY); + + + icalproperty_set_dtend((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_dtend(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* TZNAME */ + +icalproperty* icalproperty_new_tzname(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzname((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_tzname(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_tzname((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_tzname(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_tzname(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* RDATE */ + +icalproperty* icalproperty_new_rdate(struct icalperiodtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY); + + + icalproperty_set_rdate((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_rdate(struct icalperiodtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY); + + + icalproperty_set_rdate((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_rdate(icalproperty* prop, struct icalperiodtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimeperiod(v); + + icalproperty_set_value(prop,value); + +} + +struct icalperiodtype icalproperty_get_rdate(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimeperiod(value); +} + +/* URL */ + +icalproperty* icalproperty_new_url(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_url((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_url(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_url((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_url(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_uri(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_url(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_uri(value); +} + +/* ATTACH */ + +icalproperty* icalproperty_new_attach(struct icalattachtype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); + + + icalproperty_set_attach((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY); + + + icalproperty_set_attach((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_attach(v); + + icalproperty_set_value(prop,value); + +} + +struct icalattachtype icalproperty_get_attach(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_attach(value); +} + +/* X-LIC-CLUSTERCOUNT */ + +icalproperty* icalproperty_new_xlicclustercount(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); + + + icalproperty_set_xlicclustercount((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_xlicclustercount(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY); + + + icalproperty_set_xlicclustercount((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_xlicclustercount(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_xlicclustercount(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* EXRULE */ + +icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY); + + + icalproperty_set_exrule((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY); + + + icalproperty_set_exrule((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_recur(v); + + icalproperty_set_value(prop,value); + +} + +struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_recur(value); +} + +/* QUERY */ + +icalproperty* icalproperty_new_query(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_query((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_query(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_query((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_query(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_query(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_query(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_query(value); +} + +/* PERCENT-COMPLETE */ + +icalproperty* icalproperty_new_percentcomplete(int v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY); + + + icalproperty_set_percentcomplete((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_percentcomplete(int v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY); + + + icalproperty_set_percentcomplete((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_percentcomplete(icalproperty* prop, int v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_integer(v); + + icalproperty_set_value(prop,value); + +} + +int icalproperty_get_percentcomplete(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_integer(value); +} + +/* CALSCALE */ + +icalproperty* icalproperty_new_calscale(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_calscale((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_calscale(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_calscale((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_calscale(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_calscale(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} + +/* CREATED */ + +icalproperty* icalproperty_new_created(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY); + + + icalproperty_set_created((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY); + + + icalproperty_set_created((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_created(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_created(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* GEO */ + +icalproperty* icalproperty_new_geo(struct icalgeotype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_GEO_PROPERTY); + + + icalproperty_set_geo((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_GEO_PROPERTY); + + + icalproperty_set_geo((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_geo(v); + + icalproperty_set_value(prop,value); + +} + +struct icalgeotype icalproperty_get_geo(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_geo(value); +} + +/* COMPLETED */ + +icalproperty* icalproperty_new_completed(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY); + + + icalproperty_set_completed((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY); + + + icalproperty_set_completed((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_completed(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* DTSTAMP */ + +icalproperty* icalproperty_new_dtstamp(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY); + + + icalproperty_set_dtstamp((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY); + + + icalproperty_set_dtstamp((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetime(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetime(value); +} + +/* DUE */ + +icalproperty* icalproperty_new_due(struct icaltimetype v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DUE_PROPERTY); + + + icalproperty_set_due((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DUE_PROPERTY); + + + icalproperty_set_due((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_due(icalproperty* prop, struct icaltimetype v) +{ + icalvalue *value; + + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_datetimedate(v); + + icalproperty_set_value(prop,value); + +} + +struct icaltimetype icalproperty_get_due(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_datetimedate(value); +} + +/* ACTION */ + +icalproperty* icalproperty_new_action(char* v) +{ + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_action((icalproperty*)impl,v); + + return (icalproperty*)impl; +} + +icalproperty* icalproperty_vanew_action(char* v, ...) +{ + va_list args; + struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY); + icalerror_check_arg_rz( (v!=0),"v"); + + + icalproperty_set_action((icalproperty*)impl,v); + + va_start(args,v); + icalproperty_add_parameters(impl, args); + va_end(args); + + return (icalproperty*)impl; +} + +void icalproperty_set_action(icalproperty* prop, char* v) +{ + icalvalue *value; + + icalerror_check_arg_rv( (v!=0),"v"); + + icalerror_check_arg_rv( (prop!=0),"prop"); + + value = icalvalue_new_text(v); + + icalproperty_set_value(prop,value); + +} + +char* icalproperty_get_action(icalproperty* prop) +{ + icalvalue *value; + icalerror_check_arg( (prop!=0),"prop"); + + value = icalproperty_get_value(prop); + + return icalvalue_get_text(value); +} |