Diffstat (limited to 'libical/src/libical/icalvalue.c') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | libical/src/libical/icalvalue.c | 518 |
1 files changed, 306 insertions, 212 deletions
diff --git a/libical/src/libical/icalvalue.c b/libical/src/libical/icalvalue.c index eb5476e..4c67136 100644 --- a/libical/src/libical/icalvalue.c +++ b/libical/src/libical/icalvalue.c @@ -1,2 +1,3 @@ -/* -*- Mode: C -*- */ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vi:set ts=4 sts=4 sw=4 expandtab : */ /*====================================================================== @@ -48,3 +49,6 @@ -int snprintf(char *str, size_t n, char const *fmt, ...); +#ifdef WIN32 +#define snprintf _snprintf +#define strcasecmp stricmp +#endif @@ -56,6 +60,5 @@ int snprintf(char *str, size_t n, char const *fmt, ...); -void print_datetime_to_string(char* str, struct icaltimetype *data); -void print_date_to_string(char* str, struct icaltimetype *data); -void print_time_to_string(char* str, struct icaltimetype *data); -void print_recur_to_string(char* str, struct icaltimetype *data); +void print_datetime_to_string(char* str, const struct icaltimetype *data); +void print_date_to_string(char* str, const struct icaltimetype *data); +void print_time_to_string(char* str, const struct icaltimetype *data); @@ -66,2 +69,5 @@ struct icalvalue_impl* icalvalue_new_impl(icalvalue_kind kind){ + if (!icalvalue_kind_is_valid(kind)) + return NULL; + if ( ( v = (struct icalvalue_impl*) @@ -92,6 +98,4 @@ icalvalue_new (icalvalue_kind kind) -icalvalue* icalvalue_new_clone(icalvalue* value){ - +icalvalue* icalvalue_new_clone(const icalvalue* old) { struct icalvalue_impl* new; - struct icalvalue_impl* old = (struct icalvalue_impl*)value; @@ -103,3 +107,2 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ - strcpy(new->id, old->id); @@ -109,5 +112,2 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ switch (new->kind){ - - /* The contents of the attach value may or may not be owned by the - * library. */ case ICAL_ATTACH_VALUE: @@ -115,5 +115,13 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ { - /* HACK ugh. I don't feel like impleenting this */ - } + /* Hmm. We just ref the attach value, which may not be the right + * thing to do. We cannot quite copy the data, anyways, since we + * don't know how long it is. + */ + new->data.v_attach = old->data.v_attach; + if (new->data.v_attach) + icalattach_ref (new->data.v_attach); + break; + } + case ICAL_QUERY_VALUE: case ICAL_STRING_VALUE: @@ -148,2 +156,15 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ + case ICAL_X_VALUE: + { + if (old->x_value != 0) { + new->x_value=icalmemory_strdup(old->x_value); + + if (new->x_value == 0) { + return 0; + } + } + + break; + } + default: @@ -160,3 +181,3 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ -char* icalmemory_strdup_and_dequote(const char* str) +static char* icalmemory_strdup_and_dequote(const char* str) { @@ -185,2 +206,3 @@ char* icalmemory_strdup_and_dequote(const char* str) case 'n': + case 'N': { @@ -189,10 +211,30 @@ char* icalmemory_strdup_and_dequote(const char* str) } - case 'N': + case 't': + case 'T': { - *pout = '\n'; + *pout = '\t'; + break; + } + case 'r': + case 'R': + { + *pout = '\r'; + break; + } + case 'b': + case 'B': + { + *pout = '\b'; + break; + } + case 'f': + case 'F': + { + *pout = '\f'; break; } - case '\\': - case ',': case ';': + case ',': + case '"': + case '\\': { @@ -219,5 +261,12 @@ char* icalmemory_strdup_and_dequote(const char* str) +/* + * FIXME + * + * This is a bad API, as it forces callers to specify their own X type. + * This function should take care of this by itself. + */ +static icalvalue* icalvalue_new_enum(icalvalue_kind kind, int x_type, const char* str) { - int e = icalproperty_string_to_enum(str); + int e = icalproperty_kind_and_string_to_enum(kind, str); struct icalvalue_impl *value; @@ -244,3 +293,2 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* struct icalvalue_impl *value = 0; - struct icalattachtype *attach = 0; @@ -255,8 +303,15 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* case ICAL_ATTACH_VALUE: - attach = icalattachtype_new(); - value = icalvalue_new_attach( attach ); - icalattachtype_free( attach ); - icalattachtype_set_url( value->data.v_attach, str ); - break; - case ICAL_BINARY_VALUE: + { + icalattach *attach; + + attach = icalattach_new_from_url (str); + if (!attach) + break; + + value = icalvalue_new_attach (attach); + icalattach_unref (attach); + break; + } + + case ICAL_BINARY_VALUE: case ICAL_BOOLEAN_VALUE: @@ -269,3 +324,3 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* sprintf(temp,"%s Values are not implemented", - icalparameter_kind_to_string(kind)); + icalvalue_kind_to_string(kind)); *error = icalproperty_vanew_xlicerror( @@ -281,15 +336,20 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* case ICAL_TRANSP_VALUE: - value = icalvalue_new_enum(kind, ICAL_TRANSP_X,str); + value = icalvalue_new_enum(kind, (int)ICAL_TRANSP_X,str); break; case ICAL_METHOD_VALUE: - value = icalvalue_new_enum(kind, ICAL_METHOD_X,str); + value = icalvalue_new_enum(kind, (int)ICAL_METHOD_X,str); break; case ICAL_STATUS_VALUE: - value = icalvalue_new_enum(kind, ICAL_STATUS_X,str); + value = icalvalue_new_enum(kind, (int)ICAL_STATUS_X,str); break; case ICAL_ACTION_VALUE: - value = icalvalue_new_enum(kind, ICAL_ACTION_X,str); + value = icalvalue_new_enum(kind, (int)ICAL_ACTION_X,str); break; + + case ICAL_QUERY_VALUE: + value = icalvalue_new_query(str); + break; + case ICAL_CLASS_VALUE: - value = icalvalue_new_enum(kind, ICAL_CLASS_X,str); + value = icalvalue_new_enum(kind, (int)ICAL_CLASS_X,str); break; @@ -298,16 +358,24 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* case ICAL_INTEGER_VALUE: - { value = icalvalue_new_integer(atoi(str)); break; - } case ICAL_FLOAT_VALUE: - { - value = icalvalue_new_float((float )atof(str)); + value = icalvalue_new_float((float)atof(str)); break; - } - + case ICAL_UTCOFFSET_VALUE: { - value = icalparser_parse_value(kind,str,(icalcomponent*)0); + int t,utcoffset, hours, minutes, seconds; + /* treat the UTCOFSET string a a decimal number, disassemble its digits + and reconstruct it as sections */ + t = strtol(str,0,10); + /* add phantom seconds field */ + if(abs(t)<9999){t *= 100; } + hours = (t/10000); + minutes = (t-hours*10000)/100; + seconds = (t-hours*10000-minutes*100); + utcoffset = hours*3600+minutes*60+seconds; + + value = icalvalue_new_utcoffset(utcoffset); + break; @@ -323,24 +391,15 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* - case ICAL_STRING_VALUE: - { value = icalvalue_new_string(str); break; - } case ICAL_CALADDRESS_VALUE: - { value = icalvalue_new_caladdress(str); break; - } case ICAL_URI_VALUE: - { value = icalvalue_new_uri(str); break; - } - case ICAL_GEO_VALUE: - { value = 0; @@ -352,12 +411,11 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* *error = icalproperty_vanew_xlicerror( - temp, - icalparameter_new_xlicerrortype( - ICAL_XLICERRORTYPE_VALUEPARSEERROR), - 0); + temp, + icalparameter_new_xlicerrortype( + ICAL_XLICERRORTYPE_VALUEPARSEERROR), + 0); } - + /*icalerror_warn("Parsing GEO properties is unimplmeneted");*/ - + break; - } @@ -393,10 +451,13 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* tt = icaltime_from_string(str); - p = icalperiodtype_from_string(str); - + if(!icaltime_is_null_time(tt)){ - value = icalvalue_new_datetime(tt); - } else if (!icalperiodtype_is_null_period(p)){ + value = icalvalue_new_datetime(tt); + break; + } + + p = icalperiodtype_from_string(str); + if (!icalperiodtype_is_null_period(p)){ value = icalvalue_new_period(p); } - + break; @@ -408,5 +469,3 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* - if(icaldurationtype_is_null_duration(dur)){ - value = 0; - } else { + if (!icaldurationtype_is_bad_duration(dur)) { /* failed to parse */ value = icalvalue_new_duration(dur); @@ -431,3 +490,3 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* struct icaltriggertype tr = icaltriggertype_from_string(str); - if (!icaltriggertype_is_null_trigger(tr)){ + if (!icaltriggertype_is_bad_trigger(tr)) { value = icalvalue_new_trigger(tr); @@ -446,5 +505,13 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* } + + case ICAL_X_VALUE: + { + char* dequoted_str = icalmemory_strdup_and_dequote(str); + value = icalvalue_new_x(dequoted_str); + free(dequoted_str); + } + break; + default: { - if (error != 0 ){ @@ -486,3 +553,3 @@ icalvalue* icalvalue_new_from_string(icalvalue_kind kind,const char* str) { - return icalvalue_new_from_string_with_error(kind,str,(icalproperty*)0); + return icalvalue_new_from_string_with_error(kind,str,(icalproperty**)0); } @@ -492,7 +559,5 @@ icalvalue* icalvalue_new_from_string(icalvalue_kind kind,const char* str) void -icalvalue_free (icalvalue* value) +icalvalue_free (icalvalue* v) { - struct icalvalue_impl* v = (struct icalvalue_impl*)value; - - icalerror_check_arg_rv((value != 0),"value"); + icalerror_check_arg_rv((v != 0),"value"); @@ -512,7 +577,10 @@ icalvalue_free (icalvalue* value) switch (v->kind){ - case ICAL_ATTACH_VALUE: - icalattachtype_free( v->data.v_attach ); + case ICAL_BINARY_VALUE: + case ICAL_ATTACH_VALUE: { + if (v->data.v_attach) { + icalattach_unref (v->data.v_attach); + v->data.v_attach = NULL; + } + break; - case ICAL_BINARY_VALUE: { - /* HACK ugh. This will be tough to implement */ } @@ -521,2 +589,3 @@ icalvalue_free (icalvalue* value) case ICAL_URI_VALUE: + case ICAL_QUERY_VALUE: { @@ -552,6 +621,4 @@ icalvalue_free (icalvalue* value) int -icalvalue_is_valid (icalvalue* value) +icalvalue_is_valid (const icalvalue* value) { - /*struct icalvalue_impl* v = (struct icalvalue_impl*)value;*/ - if(value == 0){ @@ -563,3 +630,3 @@ icalvalue_is_valid (icalvalue* value) -char* icalvalue_binary_as_ical_string(icalvalue* value) { +static char* icalvalue_binary_as_ical_string(const icalvalue* value) { @@ -577,6 +644,6 @@ char* icalvalue_binary_as_ical_string(icalvalue* value) { -#ifndef _WIN32 + #define MAX_INT_DIGITS 12 /* Enough for 2^32 + sign*/ -char* icalvalue_int_as_ical_string(icalvalue* value) { +static char* icalvalue_int_as_ical_string(const icalvalue* value) { int data; @@ -592,22 +659,4 @@ char* icalvalue_int_as_ical_string(icalvalue* value) { } -#else -// snprintf not working on wintendo -#define MAX_INT_DIGITS 32 /* Enough for 2^32 + sign*/ -char* icalvalue_int_as_ical_string(icalvalue* value) { - - int data; - char* str = (char*)icalmemory_tmp_buffer(MAX_INT_DIGITS); - - icalerror_check_arg_rz( (value!=0),"value"); - - data = icalvalue_get_integer(value); - - sprintf(str,"%d",data); - - return str; -} - -#endif -char* icalvalue_utcoffset_as_ical_string(icalvalue* value) +static char* icalvalue_utcoffset_as_ical_string(const icalvalue* value) { @@ -631,3 +680,6 @@ char* icalvalue_utcoffset_as_ical_string(icalvalue* value) - sprintf(str,"%c%02d%02d%02d",sign,abs(h),abs(m),abs(s)); + if (s > 0) + sprintf(str,"%c%02d%02d%02d",sign,abs(h),abs(m),abs(s)); + else + sprintf(str,"%c%02d%02d",sign,abs(h),abs(m)); @@ -636,3 +688,3 @@ char* icalvalue_utcoffset_as_ical_string(icalvalue* value) -char* icalvalue_string_as_ical_string(icalvalue* value) { +static char* icalvalue_string_as_ical_string(const icalvalue* value) { @@ -641,4 +693,3 @@ char* icalvalue_string_as_ical_string(icalvalue* value) { icalerror_check_arg_rz( (value!=0),"value"); - - data = ((struct icalvalue_impl*)value)->data.v_string; + data = value->data.v_string; @@ -652,6 +703,5 @@ char* icalvalue_string_as_ical_string(icalvalue* value) { -char* icalvalue_recur_as_ical_string(icalvalue* value) +static char* icalvalue_recur_as_ical_string(const icalvalue* value) { - struct icalvalue_impl *impl = (struct icalvalue_impl*)value; - struct icalrecurrencetype *recur = impl->data.v_recur; + struct icalrecurrencetype *recur = value->data.v_recur; @@ -660,4 +710,9 @@ char* icalvalue_recur_as_ical_string(icalvalue* value) -char* icalvalue_text_as_ical_string(icalvalue* value) { + /* @todo This is not RFC2445 compliant. + * The RFC only allows: + * TSAFE-CHAR = %x20-21 / %x23-2B / %x2D-39 / %x3C-5B / %x5D-7E / NON-US-ASCII + * As such, \t\r\b\f are not allowed, not even escaped + */ +static char* icalvalue_text_as_ical_string(const icalvalue* value) { char *str; @@ -667,7 +722,4 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { size_t buf_sz; - int line_length; - - line_length = 0; - buf_sz = strlen(((struct icalvalue_impl*)value)->data.v_string)+1; + buf_sz = strlen(value->data.v_string)+1; @@ -679,3 +731,3 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { - for(p=((struct icalvalue_impl*)value)->data.v_string; *p!=0; p++){ + for(p=value->data.v_string; *p!=0; p++){ @@ -684,3 +736,2 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { icalmemory_append_string(&str,&str_p,&buf_sz,"\\n"); - line_length+=3; break; @@ -690,3 +741,2 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { icalmemory_append_string(&str,&str_p,&buf_sz,"\\t"); - line_length+=3; break; @@ -695,3 +745,2 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { icalmemory_append_string(&str,&str_p,&buf_sz,"\\r"); - line_length+=3; break; @@ -700,3 +749,2 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { icalmemory_append_string(&str,&str_p,&buf_sz,"\\b"); - line_length+=3; break; @@ -705,3 +753,2 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { icalmemory_append_string(&str,&str_p,&buf_sz,"\\f"); - line_length+=3; break; @@ -710,6 +757,7 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { case ';': - case ',':{ + case ',': + case '"': + case '\\':{ icalmemory_append_char(&str,&str_p,&buf_sz,'\\'); icalmemory_append_char(&str,&str_p,&buf_sz,*p); - line_length+=3; break; @@ -719,17 +767,4 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { icalmemory_append_char(&str,&str_p,&buf_sz,*p); - line_length++; } } - - if (line_length > 65 && *p == ' '){ - icalmemory_append_string(&str,&str_p,&buf_sz,"\n "); - line_length=0; - } - - - if (line_length > 75){ - icalmemory_append_string(&str,&str_p,&buf_sz,"\n "); - line_length=0; - } - } @@ -751,5 +786,6 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { -char* icalvalue_attach_as_ical_string(icalvalue* value) { - - struct icalattachtype *a; +static char* +icalvalue_attach_as_ical_string(const icalvalue* value) +{ + icalattach *a; char * str; @@ -760,17 +796,11 @@ char* icalvalue_attach_as_ical_string(icalvalue* value) { - if (a->binary != 0) { - return icalvalue_binary_as_ical_string(value); - } else if (a->base64 != 0) { - str = (char*)icalmemory_tmp_buffer(strlen(a->base64)+1); - strcpy(str,a->base64); + if (icalattach_get_is_url (a)) { + const char *url; + + url = icalattach_get_url (a); + str = icalmemory_tmp_buffer (strlen (url) + 1); + strcpy (str, url); return str; - } else if (a->url != 0){ - icalvalue *v = icalvalue_new_text( a->url ); - char *icalstring = icalvalue_string_as_ical_string(v); - icalvalue_free( v ); - return icalstring; - } else { - icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR); - return 0; - } + } else + return icalvalue_binary_as_ical_string (value); } @@ -778,3 +808,3 @@ char* icalvalue_attach_as_ical_string(icalvalue* value) { -char* icalvalue_duration_as_ical_string(icalvalue* value) { +static char* icalvalue_duration_as_ical_string(const icalvalue* value) { @@ -788,3 +818,3 @@ char* icalvalue_duration_as_ical_string(icalvalue* value) { -void print_time_to_string(char* str, struct icaltimetype *data) +void print_time_to_string(char* str, const struct icaltimetype *data) { @@ -792,3 +822,3 @@ void print_time_to_string(char* str, struct icaltimetype *data) - if (data->is_utc == 1){ + if (icaltime_is_utc(*data)){ sprintf(temp,"%02d%02d%02dZ",data->hour,data->minute,data->second); @@ -802,3 +832,3 @@ void print_time_to_string(char* str, struct icaltimetype *data) -void print_date_to_string(char* str, struct icaltimetype *data) +void print_date_to_string(char* str, const struct icaltimetype *data) { @@ -811,3 +841,3 @@ void print_date_to_string(char* str, struct icaltimetype *data) -char* icalvalue_date_as_ical_string(icalvalue* value) { +static char* icalvalue_date_as_ical_string(const icalvalue* value) { @@ -826,3 +856,3 @@ char* icalvalue_date_as_ical_string(icalvalue* value) { -void print_datetime_to_string(char* str, struct icaltimetype *data) +void print_datetime_to_string(char* str, const struct icaltimetype *data) { @@ -831,6 +861,5 @@ void print_datetime_to_string(char* str, struct icaltimetype *data) print_time_to_string(str,data); - } -const char* icalvalue_datetime_as_ical_string(icalvalue* value) { +static const char* icalvalue_datetime_as_ical_string(const icalvalue* value) { @@ -861,3 +890,3 @@ const char* icalvalue_datetime_as_ical_string(icalvalue* value) { -char* icalvalue_float_as_ical_string(icalvalue* value) { +static char* icalvalue_float_as_ical_string(const icalvalue* value) { @@ -875,3 +904,3 @@ char* icalvalue_float_as_ical_string(icalvalue* value) { -char* icalvalue_geo_as_ical_string(icalvalue* value) { +static char* icalvalue_geo_as_ical_string(const icalvalue* value) { @@ -890,3 +919,3 @@ char* icalvalue_geo_as_ical_string(icalvalue* value) { -const char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) { +static const char* icalvalue_datetimeperiod_as_ical_string(const icalvalue* value) { struct icaldatetimeperiodtype dtp = icalvalue_get_datetimeperiod(value); @@ -902,3 +931,3 @@ const char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) { -const char* icalvalue_period_as_ical_string(icalvalue* value) { +static const char* icalvalue_period_as_ical_string(const icalvalue* value) { struct icalperiodtype data; @@ -911,3 +940,3 @@ const char* icalvalue_period_as_ical_string(icalvalue* value) { -char* icalvalue_trigger_as_ical_string(icalvalue* value) { +static const char* icalvalue_trigger_as_ical_string(const icalvalue* value) { @@ -927,8 +956,4 @@ char* icalvalue_trigger_as_ical_string(icalvalue* value) { const char* -icalvalue_as_ical_string (icalvalue* value) +icalvalue_as_ical_string(const icalvalue* value) { - struct icalvalue_impl* v = (struct icalvalue_impl*)value; - - v=v; - if(value == 0){ @@ -937,3 +962,3 @@ icalvalue_as_ical_string (icalvalue* value) - switch (v->kind){ + switch (value->kind){ @@ -955,2 +980,5 @@ icalvalue_as_ical_string (icalvalue* value) + case ICAL_QUERY_VALUE: + return icalvalue_string_as_ical_string(value); + case ICAL_STRING_VALUE: @@ -985,3 +1013,3 @@ icalvalue_as_ical_string (icalvalue* value) case ICAL_REQUESTSTATUS_VALUE: - return icalreqstattype_as_string(v->data.v_requeststatus); + return icalreqstattype_as_string(value->data.v_requeststatus); @@ -992,10 +1020,13 @@ icalvalue_as_ical_string (icalvalue* value) case ICAL_CLASS_VALUE: - if(v->x_value !=0){ - return icalmemory_tmp_copy(v->x_value); + if(value->x_value !=0){ + return icalmemory_tmp_copy(value->x_value); } - return icalproperty_enum_to_string(v->data.v_enum); + return icalproperty_enum_to_string(value->data.v_enum); case ICAL_X_VALUE: - return icalmemory_tmp_copy(v->x_value); + if (value->x_value != 0) + return icalmemory_tmp_copy(value->x_value); + + /* FALLTHRU */ @@ -1011,6 +1042,4 @@ icalvalue_as_ical_string (icalvalue* value) icalvalue_kind -icalvalue_isa (icalvalue* value) +icalvalue_isa (const icalvalue* value) { - struct icalvalue_impl* v = (struct icalvalue_impl*)value; - if(value == 0){ @@ -1019,3 +1048,3 @@ icalvalue_isa (icalvalue* value) - return v->kind; + return value->kind; } @@ -1038,3 +1067,3 @@ icalvalue_isa_value (void* value) -int icalvalue_is_time(icalvalue* a) { +static int icalvalue_is_time(const icalvalue* a) { icalvalue_kind kind = icalvalue_isa(a); @@ -1050,7 +1079,10 @@ int icalvalue_is_time(icalvalue* a) { +/* + * In case of error, this function returns 0. This is partly bogus, as 0 is + * not part of the returned enum. + * FIXME We should probably add an error value to the enum. + */ icalparameter_xliccomparetype -icalvalue_compare(icalvalue* a, icalvalue *b) +icalvalue_compare(const icalvalue* a, const icalvalue *b) { - struct icalvalue_impl *impla = (struct icalvalue_impl *)a; - struct icalvalue_impl *implb = (struct icalvalue_impl *)b; @@ -1068,3 +1100,25 @@ icalvalue_compare(icalvalue* a, icalvalue *b) case ICAL_ATTACH_VALUE: - case ICAL_BINARY_VALUE: + { + if (icalattach_get_is_url(a->data.v_attach) && + icalattach_get_is_url(b->data.v_attach)) { + if (strcasecmp(icalattach_get_url(a->data.v_attach), + icalattach_get_url(b->data.v_attach)) == 0) + return ICAL_XLICCOMPARETYPE_EQUAL; + else + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } + else { + if (a->data.v_attach == b->data.v_attach) + return ICAL_XLICCOMPARETYPE_EQUAL; + else + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } + } + case ICAL_BINARY_VALUE: + { + if (a->data.v_attach == b->data.v_attach) + return ICAL_XLICCOMPARETYPE_EQUAL; + else + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } @@ -1081,5 +1135,5 @@ icalvalue_compare(icalvalue* a, icalvalue *b) { - if (impla->data.v_float > implb->data.v_float){ + if (a->data.v_float > b->data.v_float){ return ICAL_XLICCOMPARETYPE_GREATER; - } else if (impla->data.v_float < implb->data.v_float){ + } else if (a->data.v_float < b->data.v_float){ return ICAL_XLICCOMPARETYPE_LESS; @@ -1093,5 +1147,5 @@ icalvalue_compare(icalvalue* a, icalvalue *b) { - if (impla->data.v_int > implb->data.v_int){ + if (a->data.v_int > b->data.v_int){ return ICAL_XLICCOMPARETYPE_GREATER; - } else if (impla->data.v_int < implb->data.v_int){ + } else if (a->data.v_int < b->data.v_int){ return ICAL_XLICCOMPARETYPE_LESS; @@ -1104,8 +1158,8 @@ icalvalue_compare(icalvalue* a, icalvalue *b) { - int a = icaldurationtype_as_int(impla->data.v_duration); - int b = icaldurationtype_as_int(implb->data.v_duration); + int dur_a = icaldurationtype_as_int(a->data.v_duration); + int dur_b = icaldurationtype_as_int(b->data.v_duration); - if (a > b){ + if (dur_a > dur_b){ return ICAL_XLICCOMPARETYPE_GREATER; - } else if (a < b){ + } else if (dur_a < dur_b){ return ICAL_XLICCOMPARETYPE_LESS; @@ -1124,2 +1178,4 @@ icalvalue_compare(icalvalue* a, icalvalue *b) case ICAL_DATETIMEPERIOD_VALUE: + case ICAL_QUERY_VALUE: + case ICAL_RECUR_VALUE: { @@ -1161,5 +1217,22 @@ icalvalue_compare(icalvalue* a, icalvalue *b) + case ICAL_TRANSP_VALUE: + { + if (icalvalue_get_transp(a) == icalvalue_get_transp(b)){ + return ICAL_XLICCOMPARETYPE_EQUAL; + } else { + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } + } + + case ICAL_ACTION_VALUE: + { + if (icalvalue_get_action(a) == icalvalue_get_action(b)){ + return ICAL_XLICCOMPARETYPE_EQUAL; + } else { + return ICAL_XLICCOMPARETYPE_NOTEQUAL; + } + } + case ICAL_PERIOD_VALUE: case ICAL_GEO_VALUE: - case ICAL_RECUR_VALUE: case ICAL_NO_VALUE: @@ -1168,3 +1241,3 @@ icalvalue_compare(icalvalue* a, icalvalue *b) icalerror_warn("Comparison not implemented for value type"); - return ICAL_XLICCOMPARETYPE_REGEX+1; /* HACK */ + return 0; } @@ -1174,14 +1247,15 @@ icalvalue_compare(icalvalue* a, icalvalue *b) -/* Examine the value and possiby chage the kind to agree with the value */ +/** Examine the value and possibly change the kind to agree with the + * value + */ + void icalvalue_reset_kind(icalvalue* value) { - struct icalvalue_impl* impl = (struct icalvalue_impl*)value; - - if( (impl->kind==ICAL_DATETIME_VALUE || impl->kind==ICAL_DATE_VALUE )&& - !icaltime_is_null_time(impl->data.v_time) ) { + if( (value->kind==ICAL_DATETIME_VALUE || value->kind==ICAL_DATE_VALUE )&& + !icaltime_is_null_time(value->data.v_time) ) { - if( impl->data.v_time.is_date == 1){ - impl->kind = ICAL_DATE_VALUE; + if(icaltime_is_date(value->data.v_time)){ + value->kind = ICAL_DATE_VALUE; } else { - impl->kind = ICAL_DATETIME_VALUE; + value->kind = ICAL_DATETIME_VALUE; } @@ -1194,6 +1268,3 @@ void icalvalue_set_parent(icalvalue* value, { - struct icalvalue_impl* v = (struct icalvalue_impl*)value; - - v->parent = property; - + value->parent = property; } @@ -1202,9 +1273,35 @@ icalproperty* icalvalue_get_parent(icalvalue* value) { - struct icalvalue_impl* v = (struct icalvalue_impl*)value; + return value->parent; +} - return v->parent; -} +int icalvalue_encode_ical_string(const char *szText, char *szEncText, int nMaxBufferLen) +{ + char *ptr; + icalvalue *value = 0; + + if ((szText == 0) || (szEncText == 0)) + return 0; + + value = icalvalue_new_from_string(ICAL_STRING_VALUE, szText); + + if (value == 0) + return 0; + + ptr = icalvalue_text_as_ical_string(value); + if (ptr == 0) + return 0; + + if ((int)strlen(ptr) >= nMaxBufferLen) + { + icalvalue_free (value); + return 0; + } + strcpy(szEncText, ptr); + icalvalue_free ((icalvalue*)value); + + return 1; +} @@ -1212,4 +1309 @@ icalproperty* icalvalue_get_parent(icalvalue* value) types */ - - -/* Everything below this line is machine generated. Do not edit. */ |