| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include <axutil_duration.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <axutil_error.h> |
| #include <axutil_utils.h> |
| |
| struct axutil_duration |
| { |
| axis2_bool_t is_negative; |
| int years; |
| int months; |
| int days; |
| int hours; |
| int mins; |
| double secs; |
| }; |
| |
| AXIS2_EXTERN axutil_duration_t *AXIS2_CALL |
| axutil_duration_create( |
| axutil_env_t *env) |
| { |
| return axutil_duration_create_from_values(env, 0, 0, 0, 0, 0, 0, 0.0); |
| } |
| |
| AXIS2_EXTERN axutil_duration_t *AXIS2_CALL |
| axutil_duration_create_from_values( |
| const axutil_env_t *env, |
| axis2_bool_t negative, |
| int years, |
| int months, |
| int days, |
| int hours, |
| int minutes, |
| double seconds) |
| { |
| axutil_duration_t *duration = NULL; |
| |
| AXIS2_ENV_CHECK(env, NULL); |
| |
| duration = (axutil_duration_t *)AXIS2_MALLOC(env->allocator, sizeof(axutil_duration_t)); |
| if(!duration) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory"); |
| return NULL; |
| } |
| |
| duration->is_negative = negative; |
| if(years > -1) |
| { |
| duration->years = years; |
| } |
| else |
| { |
| duration->years = 0; |
| } |
| if(months > -1) |
| { |
| duration->months = months; |
| } |
| else |
| { |
| duration->months = 0; |
| } |
| if(days > -1) |
| { |
| duration->days = days; |
| } |
| else |
| { |
| duration->days = 0; |
| } |
| if(hours > -1) |
| { |
| duration->hours = hours; |
| } |
| else |
| { |
| duration->hours = 0; |
| } |
| if(minutes > -1) |
| { |
| duration->mins = minutes; |
| } |
| else |
| { |
| duration->mins = 0; |
| } |
| if(seconds >= 0) |
| { |
| duration->secs = seconds; |
| } |
| else |
| { |
| duration->secs = 0.0; |
| } |
| return duration; |
| } |
| |
| AXIS2_EXTERN axutil_duration_t *AXIS2_CALL |
| axutil_duration_create_from_string( |
| const axutil_env_t *env, |
| const axis2_char_t *duration_str) |
| { |
| axutil_duration_t *duration = NULL; |
| |
| duration = (axutil_duration_t *)AXIS2_MALLOC(env->allocator, sizeof(axutil_duration_t)); |
| if(!duration) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); |
| AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Out of memory"); |
| return NULL; |
| } |
| |
| axutil_duration_deserialize_duration(duration, env, duration_str); |
| return duration; |
| } |
| |
| /***************************Function implementation****************************/ |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_free( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| if(duration) |
| { |
| AXIS2_FREE(env->allocator, duration); |
| duration = NULL; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_deserialize_duration( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| const axis2_char_t *duration_str) |
| { |
| const axis2_char_t *cur = duration_str; |
| double num; |
| int num_type = 0; |
| unsigned int seq = 0; |
| const char desig[] = { 'Y', 'M', 'D', 'H', 'M', 'S' }; |
| |
| AXIS2_PARAM_CHECK(env->error, duration, AXIS2_FAILURE); |
| |
| duration->is_negative = AXIS2_FALSE; |
| duration->years = duration->months = duration->days = duration->hours = duration->mins = 0; |
| duration->secs = 0; |
| |
| if(!duration_str) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| |
| if(*cur == '-') |
| { |
| duration->is_negative = 1; |
| cur++; |
| } |
| |
| if(*cur++ != 'P') |
| { |
| duration->is_negative = AXIS2_FALSE; |
| duration->years = duration->months = duration->days = duration->hours = duration->mins = 0; |
| duration->secs = 0; |
| |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NONE, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| |
| if(!*cur) |
| { |
| duration->is_negative = AXIS2_FALSE; |
| duration->years = duration->months = duration->days = duration->hours = duration->mins = 0; |
| duration->secs = 0; |
| |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NONE, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| |
| while(*cur) |
| { |
| if(seq >= sizeof(desig)) |
| { |
| duration->is_negative = AXIS2_FALSE; |
| duration->years = duration->months = duration->days = duration->hours = duration->mins |
| = 0; |
| duration->secs = 0; |
| |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NONE, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| |
| if(*cur == 'T') |
| { |
| if(!(seq > 3)) |
| { |
| seq = 3; |
| cur++; |
| } |
| else |
| { |
| duration->is_negative = AXIS2_FALSE; |
| duration->years = duration->months = duration->days = duration->hours |
| = duration->mins = 0; |
| duration->secs = 0; |
| |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NONE, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| } |
| num = 0; |
| |
| if((*cur < '0') || (*cur > '9')) |
| num_type = -1; |
| else |
| { |
| num_type = 0; |
| while((*cur >= '0') && (*cur <= '9')) |
| { |
| num = num * 10 + (*cur - '0'); |
| cur++; |
| } |
| } |
| |
| if(!num_type && (*cur == '.')) |
| { |
| double mult = 1; |
| cur++; |
| if((*cur < '0') || (*cur > '9')) |
| num_type = -1; |
| else |
| num_type = 1; |
| while((*cur >= '0') && (*cur <= '9')) |
| { |
| mult /= 10; |
| num += (*cur - '0') * mult; |
| cur++; |
| } |
| } |
| |
| if((num_type == -1) || (*cur == 0)) |
| { |
| duration->is_negative = AXIS2_FALSE; |
| duration->years = duration->months = duration->days = duration->hours = duration->mins |
| = 0; |
| duration->secs = 0; |
| |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NONE, AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| } |
| |
| while(seq < sizeof(desig)) |
| { |
| if(*cur == desig[seq]) |
| { |
| num_type = 0; |
| /*if (seq < (sizeof(desig) - 1)) |
| { |
| duration->is_negative = AXIS2_FALSE; |
| duration->years = duration->months = duration->days = duration->hours = duration->mins = 0; |
| duration->secs = 0; |
| |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NONE, |
| AXIS2_FAILURE); |
| return AXIS2_FAILURE; |
| }*/ |
| |
| switch(seq) |
| { |
| case 0: |
| duration->years = (int)num; |
| seq++; |
| break; |
| case 1: |
| duration->months = (int)num; |
| seq++; |
| break; |
| case 2: |
| duration->days = (int)num; |
| seq++; |
| break; |
| case 3: |
| duration->hours = (int)num; |
| seq++; |
| break; |
| case 4: |
| duration->mins = (int)num; |
| seq++; |
| break; |
| case 5: |
| duration->secs = num; |
| seq++; |
| break; |
| } |
| break; |
| } |
| if((++seq == 3) || (seq == 6)) |
| return AXIS2_SUCCESS; |
| } |
| cur++; |
| } |
| return AXIS2_SUCCESS; |
| |
| } |
| |
| AXIS2_EXTERN char *AXIS2_CALL |
| axutil_duration_serialize_duration( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| axis2_char_t *duration_str = NULL; |
| |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| duration_str = (axis2_char_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) * 64); |
| |
| if(duration->is_negative == 0) |
| sprintf(duration_str, "P%dY%dM%dDT%dH%dM%fS", duration->years, duration->months, |
| duration->days, duration->hours, duration->mins, duration->secs); |
| else |
| sprintf(duration_str, "-P%dY%dM%dDT%dH%dM%fS", duration->years, duration->months, |
| duration->days, duration->hours, duration->mins, duration->secs); |
| |
| return duration_str; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_duration( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| axis2_bool_t negative, |
| int years, |
| int months, |
| int days, |
| int hours, |
| int mins, |
| double seconds) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| |
| if(years > -1) |
| duration->years = years; |
| if(months > -1) |
| duration->months = months; |
| if(days > -1) |
| duration->days = days; |
| if(hours > -1) |
| duration->hours = hours; |
| if(mins > -1) |
| duration->mins = mins; |
| if(seconds >= 0) |
| duration->secs = seconds; |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| axutil_duration_get_years( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return duration->years; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_years( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| int years) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| if(years > -1) |
| { |
| duration->years = years; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| axutil_duration_get_months( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return duration->months; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_months( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| int months) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| if(months > -1) |
| { |
| duration->months = months; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| axutil_duration_get_days( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return duration->days; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_days( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| int days) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| if(days > -1) |
| { |
| duration->days = days; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| axutil_duration_get_hours( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return duration->hours; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_hours( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| int hours) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| if(hours > -1) |
| { |
| duration->hours = hours; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN int AXIS2_CALL |
| axutil_duration_get_mins( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return duration->mins; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_mins( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| int mins) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| if(mins > -1) |
| { |
| duration->mins = mins; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN double AXIS2_CALL |
| axutil_duration_get_seconds( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return duration->secs; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_seconds( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| double seconds) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| if(seconds >= 0) |
| { |
| duration->secs = seconds; |
| } |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axutil_duration_get_is_negative( |
| axutil_duration_t *duration, |
| const axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| return duration->is_negative; |
| } |
| |
| AXIS2_EXTERN axis2_status_t AXIS2_CALL |
| axutil_duration_set_is_negative( |
| axutil_duration_t *duration, |
| const axutil_env_t *env, |
| axis2_bool_t is_negative) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FAILURE); |
| duration->is_negative = is_negative; |
| |
| return AXIS2_SUCCESS; |
| } |
| |
| AXIS2_EXTERN axis2_bool_t AXIS2_CALL |
| axutil_duration_compare( |
| axutil_duration_t *duration_one, |
| axutil_duration_t *duration_two, |
| axutil_env_t *env) |
| { |
| AXIS2_ENV_CHECK(env, AXIS2_FALSE); |
| |
| if(!duration_one || !duration_two) |
| { |
| AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE); |
| return AXIS2_FALSE; |
| } |
| |
| if(duration_one->is_negative != duration_two->is_negative) |
| return AXIS2_FALSE; |
| if(duration_one->years != duration_two->years) |
| return AXIS2_FALSE; |
| if(duration_one->months != duration_two->months) |
| return AXIS2_FALSE; |
| if(duration_one->days != duration_two->days) |
| return AXIS2_FALSE; |
| if(duration_one->hours != duration_two->hours) |
| return AXIS2_FALSE; |
| if(duration_one->mins != duration_two->mins) |
| return AXIS2_FALSE; |
| if(duration_one->secs != duration_two->secs) |
| return AXIS2_FALSE; |
| return AXIS2_SUCCESS; |
| } |
| |