/*
 * Contacts Service
 *
 * Copyright (c) 2010 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: Youngjae Shin <yj99.shin@samsung.com>
 *
 * Licensed 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 <unistd.h>
#include <errno.h>

#include "cts-internal.h"
#include "cts-list.h"
#include "cts-utils.h"

static contact_list *contact_list_mempool=NULL;
static plog_list *plog_list_mempool=NULL;
static change_list *change_list_mempool=NULL;
static numtype_list *numtype_list_mempool=NULL;
static shortcut_list *favorite_list_mempool=NULL;
static cts_group *group_list_mempool=NULL;
static cts_addrbook *addrbook_list_mempool=NULL;
static sdn_list *sdn_list_mempool=NULL;

API CTSstruct* contacts_svc_struct_new(cts_struct_type type)
{
	CTSstruct* ret_val;
	switch (type)
	{
	case CTS_STRUCT_CONTACT:
		ret_val = (CTSstruct*)calloc(1, sizeof(contact_t));
		if (ret_val) ret_val->s_type = CTS_STRUCT_CONTACT;
		return ret_val;
	default:
		ERR("your type is Not supported");
		return NULL;
	}
}

static void cts_number_free(gpointer data, gpointer user_data)
{
	if (NULL == data || !((cts_number*)data)->embedded)
		return;

	free(((cts_number*)data)->number);
	free(((cts_number*)data)->added_type);
	free(data);
}
static void cts_email_free(gpointer data, gpointer user_data)
{
	if (NULL == data || !((cts_email*)data)->embedded)
		return;

	free(((cts_email*)data)->email_addr);
	free(data);
}
static void cts_group_free(gpointer data, gpointer user_data)
{
	cts_group* data0 = (cts_group*)data;

	if (NULL == data || !data0->embedded)
		return;

	free(data0->name);
	free(data0->ringtone_path);
	free(data0->vcard_group);
	free(data);
}
static void cts_event_free(gpointer data, gpointer user_data)
{
	if (NULL == data || !((cts_event*)data)->embedded)
		return;

	free(data);
}
static void cts_messenger_free(gpointer data, gpointer user_data)
{
	if (NULL == data || !((cts_messenger*)data)->embedded)
		return;

	free(((cts_messenger*)data)->im_id);
	free(data);
}
static void cts_postal_free(gpointer data, gpointer user_data)
{
	cts_postal *data0 = (cts_postal *)data;

	if (NULL == data0 || !data0->embedded)
		return;

	free(data0->pobox);
	free(data0->postalcode);
	free(data0->region);
	free(data0->locality);
	free(data0->street);
	free(data0->extended);
	free(data0->country);
	free(data);
}
static void cts_web_free(gpointer data, gpointer user_data)
{
	if (NULL == data || !((cts_web*)data)->embedded)
		return;

	free(((cts_web*)data)->url);
	free(data);
}
static void cts_nickname_free(gpointer data, gpointer user_data)
{
	if (NULL == data || !((cts_nickname*)data)->embedded)
		return;

	free(((cts_nickname*)data)->nick);
	free(data);
}

static void cts_extend_free(gpointer data, gpointer user_data)
{
	cts_extend *data0 = (cts_extend *)data;
	if (NULL == data0 || !data0->embedded)
		return;

	free(data0->data2);
	free(data0->data3);
	free(data0->data4);
	free(data0->data5);
	free(data0->data6);
	free(data0->data7);
	free(data0->data8);
	free(data0->data9);
	free(data0->data10);
	free(data);
}

static inline void cts_name_free(cts_name *name)
{
	if (!name->embedded)
		return;

	free(name->first);
	free(name->last);
	free(name->addition);
	free(name->display);
	free(name->prefix);
	free(name->suffix);
	free(name);
}

static inline void cts_company_free(cts_company *company)
{
	if (!company->embedded)
		return;

	free(company->name);
	free(company->department);
	free(company->jot_title);
	free(company->role);
	free(company->assistant_name);
	free(company);
}

static inline void cts_contact_free(contact_t *contact)
{
	if (contact->base && contact->base->embedded) {
		free(contact->base->uid);
		free(contact->base->img_path);
		free(contact->base->full_img_path);
		free(contact->base->ringtone_path);
		free(contact->base->note);

		if (contact->base->vcard_img_path) {
			unlink(contact->base->vcard_img_path);
			free(contact->base->vcard_img_path);
		}

		free(contact->base);
	}

	if (contact->name)
		cts_name_free(contact->name);

	if (contact->company)
		cts_company_free(contact->company);

	if (contact->numbers) {
		g_slist_foreach(contact->numbers, cts_number_free, NULL);
		g_slist_free(contact->numbers);
	}

	if (contact->emails) {
		g_slist_foreach(contact->emails, cts_email_free, NULL);
		g_slist_free(contact->emails);
	}

	if (contact->grouprelations) {
		g_slist_foreach(contact->grouprelations, cts_group_free, NULL);
		g_slist_free(contact->grouprelations);
	}

	if (contact->events) {
		g_slist_foreach(contact->events, cts_event_free, NULL);
		g_slist_free(contact->events);
	}

	if (contact->messengers) {
		g_slist_foreach(contact->messengers, cts_messenger_free, NULL);
		g_slist_free(contact->messengers);
	}

	if (contact->postal_addrs) {
		g_slist_foreach(contact->postal_addrs, cts_postal_free, NULL);
		g_slist_free(contact->postal_addrs);
	}

	if (contact->web_addrs) {
		g_slist_foreach(contact->web_addrs, cts_web_free, NULL);
		g_slist_free(contact->web_addrs);
	}

	if (contact->nicknames) {
		g_slist_foreach(contact->nicknames, cts_nickname_free, NULL);
		g_slist_free(contact->nicknames);
	}

	if (contact->extended_values) {
		g_slist_foreach(contact->extended_values, cts_extend_free, NULL);
		g_slist_free(contact->extended_values);
	}
}

API int contacts_svc_struct_free(CTSstruct* structure)
{
	retv_if(NULL == structure, CTS_ERR_ARG_NULL);

	switch (structure->s_type)
	{
	case CTS_STRUCT_CONTACT:
		cts_contact_free((contact_t *)structure);
		free(structure);
		break;
	default:
		ERR("The structure type(%d) is Not valid", structure->s_type);
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

API int contacts_svc_struct_get_list(CTSstruct *contact,
		cts_struct_field field, GSList** retlist)
{
	contact_t *record = (contact_t *)contact;

	retv_if(NULL == contact, CTS_ERR_ARG_NULL);
	retv_if(NULL == retlist, CTS_ERR_ARG_NULL);
	retvm_if(CTS_STRUCT_CONTACT != contact->s_type, CTS_ERR_ARG_INVALID,
			"The contact(%d) must be type of CTS_STRUCT_CONTACT.", contact->s_type);

	switch (field)
	{
	case CTS_CF_NUMBER_LIST:
		*retlist = record->numbers;
		break;
	case CTS_CF_EMAIL_LIST:
		*retlist = record->emails;
		break;
	case CTS_CF_GROUPREL_LIST:
		*retlist = record->grouprelations;
		break;
	case CTS_CF_EVENT_LIST:
		*retlist = record->events;
		break;
	case CTS_CF_MESSENGER_LIST:
		*retlist = record->messengers;
		break;
	case CTS_CF_POSTAL_ADDR_LIST:
		*retlist = record->postal_addrs;
		break;
	case CTS_CF_WEB_ADDR_LIST:
		*retlist = record->web_addrs;
		break;
	case CTS_CF_NICKNAME_LIST:
		*retlist = record->nicknames;
		break;
	default:
		ERR("The parameter(field) is invalid"
				"You MUST be (CTS_CF_VALUE_MAX < field < CTS_CF_FIELD_MAX).");
		return CTS_ERR_ARG_INVALID;
	}

	if (NULL == *retlist) return CTS_ERR_NO_DATA;

	return CTS_SUCCESS;
}

static cts_extend* cts_extend_slist_search(int type, GSList *list)
{
	cts_extend *tmp_extend;
	GSList *tmp_gslist=list;
	while (tmp_gslist)
	{
		tmp_extend = tmp_gslist->data;
		retvm_if(CTS_VALUE_EXTEND != tmp_extend->v_type, NULL,
				"List has other type");
		if (tmp_extend->type == type) return tmp_extend;

		tmp_gslist = tmp_gslist->next;
	}
	return NULL;
}

static inline int cts_contact_get_value(contact_t *contact,
		cts_struct_field field, CTSvalue** retval)
{

	switch (field)
	{
	case CTS_CF_NAME_VALUE:
		*retval = (CTSvalue *)contact->name;
		break;
	case CTS_CF_BASE_INFO_VALUE:
		*retval = (CTSvalue *)contact->base;
		break;
	case CTS_CF_COMPANY_VALUE:
		*retval = (CTSvalue *)contact->company;
		break;
	default:
		if ((int)CTS_DATA_EXTEND_START <= field) {
			*retval = (CTSvalue *)cts_extend_slist_search(field,
					contact->extended_values);
			return CTS_SUCCESS;
		}
		ERR("The parameter(field:%d) is not interpreted", field);
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

API int contacts_svc_struct_get_value(CTSstruct *structure,
		cts_struct_field field, CTSvalue **retval)
{
	int ret;

	retv_if(NULL == structure, CTS_ERR_ARG_NULL);
	retv_if(NULL == retval, CTS_ERR_ARG_NULL);

	switch (structure->s_type)
	{
	case CTS_STRUCT_CONTACT:
		ret = cts_contact_get_value((contact_t *)structure, field, retval);
		if (CTS_SUCCESS != ret)
			return ret;
		break;
	default:
		ERR("The structure type(%d) is Not valid", structure->s_type);
		return CTS_ERR_ARG_INVALID;
	}

	if (NULL == *retval) return CTS_ERR_NO_DATA;
	return CTS_SUCCESS;
}

#define CTS_REMOVE_GSLIST_ITEM(type, loc) \
	do { \
		cts_##type##_free(tmp_##type, NULL); \
		if (prev) { \
			prev->next = tmp_gslist->next; \
			g_slist_free_1(tmp_gslist); \
			tmp_gslist = prev->next; \
		} \
		else { \
			contact->loc = tmp_gslist->next; \
			g_slist_free_1(tmp_gslist); \
			tmp_gslist = contact->loc; \
		} \
	}while(false)

static inline int cts_struct_store_num_list(contact_t *contact, GSList* list)
{
	cts_number *tmp_number;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->numbers && tmp_gslist == contact->numbers)
	{
		while (tmp_gslist)
		{
			tmp_number = tmp_gslist->data;
			if (tmp_number)
			{
				retvm_if(CTS_VALUE_NUMBER != tmp_number->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_number->id && tmp_number->deleted)
				{
					CTS_REMOVE_GSLIST_ITEM(number, numbers);
					continue;
				}

				if (!tmp_number->embedded)
				{
					tmp_number->embedded = true;
					tmp_number->number = SAFE_STRDUP(tmp_number->number);
				}
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		while (tmp_gslist)
		{
			tmp_number = tmp_gslist->data;
			if (tmp_number)
			{
				retvm_if(tmp_number && CTS_VALUE_NUMBER != tmp_number->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_number->embedded)
				{
					tmp_number->embedded = true;
					tmp_number->number = SAFE_STRDUP(tmp_number->number);
					new_gslist = g_slist_append(new_gslist, tmp_number);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->numbers = g_slist_concat(contact->numbers, new_gslist);
	}
	return CTS_SUCCESS;
}

static inline int cts_struct_store_email_list(contact_t *contact, GSList* list)
{
	cts_email *tmp_email;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->emails && tmp_gslist == contact->emails)
	{
		while (tmp_gslist)
		{
			tmp_email = tmp_gslist->data;
			if (tmp_email)
			{
				retvm_if(CTS_VALUE_EMAIL != tmp_email->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_email->id && tmp_email->deleted) {
					CTS_REMOVE_GSLIST_ITEM(email, emails);
					continue;
				}

				if (!tmp_email->embedded)
				{
					tmp_email->embedded = true;
					tmp_email->email_addr = SAFE_STRDUP(tmp_email->email_addr);
				}
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		while (tmp_gslist)
		{
			tmp_email = tmp_gslist->data;
			if (tmp_email)
			{
				retvm_if(CTS_VALUE_EMAIL != tmp_email->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_email->embedded)
				{
					tmp_email->embedded = true;
					tmp_email->email_addr = SAFE_STRDUP(tmp_email->email_addr);
					new_gslist = g_slist_append(new_gslist, tmp_email);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->emails = g_slist_concat(contact->emails, new_gslist);
	}
	return CTS_SUCCESS;
}

static inline int cts_struct_store_grouprel_list(contact_t *contact, GSList* list)
{
	cts_group *tmp_group;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->grouprelations && tmp_gslist == contact->grouprelations)
	{
		while (tmp_gslist)
		{
			tmp_group = tmp_gslist->data;
			if (tmp_group)
			{
				retvm_if(CTS_VALUE_GROUP_RELATION != tmp_group->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_group->name && tmp_group->deleted) {
					CTS_REMOVE_GSLIST_ITEM(group, grouprelations);
					continue;
				}

				tmp_group->embedded = true;
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		while (tmp_gslist)
		{
			tmp_group = tmp_gslist->data;
			if (tmp_group)
			{
				retvm_if(CTS_VALUE_GROUP_RELATION != tmp_group->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_group->embedded)
				{
					tmp_group->embedded = true;
					new_gslist = g_slist_append(new_gslist, tmp_group);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->grouprelations = g_slist_concat(contact->grouprelations, new_gslist);
	}
	return CTS_SUCCESS;
}

static inline int cts_struct_store_event_list(contact_t *contact, GSList* list)
{
	cts_event *tmp_event;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->events && tmp_gslist == contact->events)
	{
		while (tmp_gslist)
		{
			tmp_event = tmp_gslist->data;
			if (tmp_event)
			{
				retvm_if(CTS_VALUE_EVENT != tmp_event->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_event->id && tmp_event->deleted) {
					CTS_REMOVE_GSLIST_ITEM(event, events);
					continue;
				}

				tmp_event->embedded = true;
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		while (tmp_gslist)
		{
			tmp_event = tmp_gslist->data;
			if (tmp_event)
			{
				retvm_if(CTS_VALUE_EVENT != tmp_event->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_event->embedded)
				{
					tmp_event->embedded = true;
					new_gslist = g_slist_append(new_gslist, tmp_event);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->events = g_slist_concat(contact->events, new_gslist);
	}
	return CTS_SUCCESS;
}

static inline int cts_struct_store_messenger_list(contact_t *contact, GSList* list)
{
	cts_messenger *tmp_messenger;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->messengers && tmp_gslist == contact->messengers)
	{
		while (tmp_gslist)
		{
			tmp_messenger = tmp_gslist->data;
			if (tmp_messenger)
			{
				retvm_if(CTS_VALUE_MESSENGER != tmp_messenger->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_messenger->id && tmp_messenger->deleted) {
					CTS_REMOVE_GSLIST_ITEM(messenger, messengers);
					continue;
				}

				if (!tmp_messenger->embedded)
				{
					tmp_messenger->embedded = true;
					tmp_messenger->im_id = SAFE_STRDUP(tmp_messenger->im_id);
				}
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		while (tmp_gslist)
		{
			tmp_messenger = tmp_gslist->data;
			if (tmp_messenger)
			{
				retvm_if(CTS_VALUE_MESSENGER != tmp_messenger->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_messenger->embedded)
				{
					tmp_messenger->embedded = true;
					tmp_messenger->im_id = SAFE_STRDUP(tmp_messenger->im_id);
					new_gslist = g_slist_append(new_gslist, tmp_messenger);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->messengers = g_slist_concat(contact->messengers, new_gslist);
	}
	return CTS_SUCCESS;
}

static inline int cts_struct_store_postal_list(contact_t *contact, GSList* list)
{
	cts_postal *tmp_postal;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->postal_addrs && tmp_gslist == contact->postal_addrs)
	{
		while (tmp_gslist)
		{
			tmp_postal = tmp_gslist->data;
			if (tmp_postal)
			{
				retvm_if(CTS_VALUE_POSTAL != tmp_postal->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_postal->id && tmp_postal->deleted) {
					CTS_REMOVE_GSLIST_ITEM(postal, postal_addrs);
					continue;
				}

				if (!tmp_postal->embedded) {
					tmp_postal->embedded = true;
					tmp_postal->pobox = SAFE_STRDUP(tmp_postal->pobox);
					tmp_postal->postalcode = SAFE_STRDUP(tmp_postal->postalcode);
					tmp_postal->region = SAFE_STRDUP(tmp_postal->region);
					tmp_postal->locality = SAFE_STRDUP(tmp_postal->locality);
					tmp_postal->street = SAFE_STRDUP(tmp_postal->street);
					tmp_postal->extended = SAFE_STRDUP(tmp_postal->extended);
					tmp_postal->country = SAFE_STRDUP(tmp_postal->country);
				}
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		//retvm_if(NULL != contact->postal_addrs, CTS_ERR_ARG_INVALID, "New list can be stored when struct has no list");
		while (tmp_gslist)
		{
			tmp_postal = tmp_gslist->data;
			if (tmp_postal) {
				retvm_if(tmp_postal && CTS_VALUE_POSTAL != tmp_postal->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_postal->embedded) {
					tmp_postal->embedded = true;
					tmp_postal->pobox = SAFE_STRDUP(tmp_postal->pobox);
					tmp_postal->postalcode = SAFE_STRDUP(tmp_postal->postalcode);
					tmp_postal->region = SAFE_STRDUP(tmp_postal->region);
					tmp_postal->locality = SAFE_STRDUP(tmp_postal->locality);
					tmp_postal->street = SAFE_STRDUP(tmp_postal->street);
					tmp_postal->extended = SAFE_STRDUP(tmp_postal->extended);
					tmp_postal->country = SAFE_STRDUP(tmp_postal->country);
					new_gslist = g_slist_append(new_gslist, tmp_postal);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->postal_addrs = g_slist_concat(contact->postal_addrs, new_gslist);
	}
	return CTS_SUCCESS;
}

static inline int cts_struct_store_web_list(contact_t *contact, GSList* list)
{
	cts_web *tmp_web;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->web_addrs && tmp_gslist == contact->web_addrs)
	{
		while (tmp_gslist)
		{
			tmp_web = tmp_gslist->data;
			if (tmp_web)
			{
				retvm_if(CTS_VALUE_WEB != tmp_web->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_web->id && tmp_web->deleted) {
					CTS_REMOVE_GSLIST_ITEM(web, web_addrs);
					continue;
				}

				if (!tmp_web->embedded) {
					tmp_web->embedded = true;
					tmp_web->url = SAFE_STRDUP(tmp_web->url);
				}
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		while (tmp_gslist)
		{
			tmp_web = tmp_gslist->data;
			if (tmp_web)
			{
				retvm_if(tmp_web && CTS_VALUE_WEB != tmp_web->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_web->embedded) {
					tmp_web->embedded = true;
					tmp_web->url = SAFE_STRDUP(tmp_web->url);
					new_gslist = g_slist_append(new_gslist, tmp_web);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->web_addrs = g_slist_concat(contact->web_addrs, new_gslist);
	}
	return CTS_SUCCESS;
}

static inline int cts_struct_store_nickname_list(contact_t *contact, GSList* list)
{
	cts_nickname *tmp_nickname;

	GSList *new_gslist=NULL, *tmp_gslist=list, *prev=NULL;
	if (contact->nicknames && tmp_gslist == contact->nicknames)
	{
		while (tmp_gslist)
		{
			tmp_nickname = tmp_gslist->data;
			if (tmp_nickname)
			{
				retvm_if(CTS_VALUE_NICKNAME != tmp_nickname->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");

				if (!tmp_nickname->id && tmp_nickname->deleted) {
					CTS_REMOVE_GSLIST_ITEM(nickname, nicknames);
					continue;
				}

				if (!tmp_nickname->embedded) {
					tmp_nickname->embedded = true;
					tmp_nickname->nick = SAFE_STRDUP(tmp_nickname->nick);
				}
			}
			prev = tmp_gslist;
			tmp_gslist = tmp_gslist->next;
		}
	}
	else
	{
		//retvm_if(NULL != contact->web_addrs, CTS_ERR_ARG_INVALID, "New list can be stored when struct has no list");
		while (tmp_gslist)
		{
			tmp_nickname = tmp_gslist->data;
			if (tmp_nickname) {
				retvm_if(tmp_nickname && CTS_VALUE_NICKNAME != tmp_nickname->v_type, CTS_ERR_ARG_INVALID,
						"List has other type");
				if (!tmp_nickname->embedded)
				{
					tmp_nickname->embedded = true;
					tmp_nickname->nick = SAFE_STRDUP(tmp_nickname->nick);
					new_gslist = g_slist_append(new_gslist, tmp_nickname);
				}
			}
			tmp_gslist = tmp_gslist->next;
		}
		contact->nicknames = g_slist_concat(contact->nicknames, new_gslist);
	}
	return CTS_SUCCESS;
}

API int contacts_svc_struct_store_list(CTSstruct *contact,
		cts_struct_field field, GSList *list)
{
	int ret;

	retv_if(NULL == contact, CTS_ERR_ARG_NULL);
	retv_if(NULL == list, CTS_ERR_ARG_NULL);
	retvm_if(CTS_STRUCT_CONTACT != contact->s_type, CTS_ERR_ARG_INVALID,
			"The contact(%d) must be type of CTS_STRUCT_CONTACT.", contact->s_type);

	switch (field)
	{
	case CTS_CF_NUMBER_LIST:
		ret = cts_struct_store_num_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_num_list() Failed(%d)",ret);
		break;
	case CTS_CF_EMAIL_LIST:
		ret = cts_struct_store_email_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_email_list() Failed(%d)",ret);
		break;
	case CTS_CF_GROUPREL_LIST:
		ret = cts_struct_store_grouprel_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_grouprel_list() Failed(%d)",ret);
		break;
	case CTS_CF_EVENT_LIST:
		ret = cts_struct_store_event_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_event_list() Failed(%d)",ret);
		break;
	case CTS_CF_MESSENGER_LIST:
		ret = cts_struct_store_messenger_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_messenger_list() Failed(%d)",ret);
		break;
	case CTS_CF_POSTAL_ADDR_LIST:
		ret = cts_struct_store_postal_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_postal_list() Failed(%d)",ret);
		break;
	case CTS_CF_WEB_ADDR_LIST:
		ret = cts_struct_store_web_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_web_list() Failed(%d)",ret);
		break;
	case CTS_CF_NICKNAME_LIST:
		ret = cts_struct_store_nickname_list((contact_t *)contact, list);
		retvm_if(CTS_SUCCESS != ret, ret, "cts_struct_store_nickname_list() Failed(%d)",ret);
		break;
	default:
		ERR("The parameter(field) is invalid"
				"You MUST be (CTS_CF_VALUE_MAX < field < CTS_CF_FIELD_MAX).");
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

static inline void cts_contact_store_name(contact_t *contact, cts_name *value)
{
	if (contact->name)
	{
		if (value->is_changed) {
			FREEandSTRDUP(contact->name->first, value->first);
			FREEandSTRDUP(contact->name->last, value->last);
			FREEandSTRDUP(contact->name->addition, value->addition);
			FREEandSTRDUP(contact->name->display, value->display);
			FREEandSTRDUP(contact->name->prefix, value->prefix);
			FREEandSTRDUP(contact->name->suffix, value->suffix);
			contact->name->is_changed = true;
		}
	}
	else
	{
		//contact->name = (cts_name *)contacts_svc_value_new(CTS_VALUE_NAME);
		contact->name = value;
		contact->name->embedded = true;
		contact->name->first = SAFE_STRDUP(value->first);
		contact->name->last = SAFE_STRDUP(value->last);
		contact->name->addition = SAFE_STRDUP(value->addition);
		contact->name->display = SAFE_STRDUP(value->display);
		contact->name->prefix = SAFE_STRDUP(value->prefix);
		contact->name->suffix = SAFE_STRDUP(value->suffix);
	}
}

static inline void cts_contact_store_base(contact_t *contact, cts_ct_base *value)
{
	if (contact->base)
	{
		if (value->uid_changed) {
			FREEandSTRDUP(contact->base->uid, value->uid);
			contact->base->uid_changed = true;
		}
		if (value->img_changed) {
			FREEandSTRDUP(contact->base->img_path, value->img_path);
			contact->base->img_changed = true;
		}
		if (value->full_img_changed) {
			FREEandSTRDUP(contact->base->full_img_path, value->full_img_path);
			contact->base->full_img_changed = true;
		}
		if (value->ringtone_changed) {
			FREEandSTRDUP(contact->base->ringtone_path, value->ringtone_path);
			contact->base->ringtone_changed = true;
		}
		if (value->note_changed) {
			FREEandSTRDUP(contact->base->note, value->note);
			contact->base->note_changed = true;
		}
	}
	else
	{
		contact->base = value;
		contact->base->embedded = true;
		contact->base->uid = SAFE_STRDUP(value->uid);
		contact->base->img_path = SAFE_STRDUP(value->img_path);
		contact->base->full_img_path = SAFE_STRDUP(value->full_img_path);
		contact->base->ringtone_path = SAFE_STRDUP(value->ringtone_path);
		contact->base->note = SAFE_STRDUP(value->note);
	}
}

static inline void cts_contact_store_company(contact_t *contact, cts_company *value)
{
	if (contact->company)
	{
		FREEandSTRDUP(contact->company->name, value->name);
		FREEandSTRDUP(contact->company->department, value->department);
		FREEandSTRDUP(contact->company->jot_title, value->jot_title);
		FREEandSTRDUP(contact->company->role, value->role);
		FREEandSTRDUP(contact->company->assistant_name, value->assistant_name);
	}
	else
	{
		//contact->company = (cts_company *)contacts_svc_value_new(CTS_VALUE_COMPANY);
		contact->company = value;
		contact->company->embedded = true;
		contact->company->name = SAFE_STRDUP(value->name);
		contact->company->department = SAFE_STRDUP(value->department);
		contact->company->jot_title = SAFE_STRDUP(value->jot_title);
		contact->company->role = SAFE_STRDUP(value->role);
		contact->company->assistant_name = SAFE_STRDUP(value->assistant_name);
	}
}

static inline int cts_contact_store_extend(contact_t *contact,
		int type, cts_extend *value)
{
	cts_extend *stored_extend;

	stored_extend = cts_extend_slist_search(type, contact->extended_values);
	if (NULL == stored_extend)
	{
		retvm_if(value->embedded, CTS_ERR_ARG_INVALID, "This Value is already stored");
		value->embedded = true;
		value->type = type;
		contact->extended_values = g_slist_append(contact->extended_values, value);
		value->data2 = SAFE_STRDUP(value->data2);
		value->data3 = SAFE_STRDUP(value->data3);
		value->data4 = SAFE_STRDUP(value->data4);
		value->data5 = SAFE_STRDUP(value->data5);
		value->data6 = SAFE_STRDUP(value->data6);
		value->data7 = SAFE_STRDUP(value->data7);
		value->data8 = SAFE_STRDUP(value->data8);
		value->data9 = SAFE_STRDUP(value->data9);
		value->data10 = SAFE_STRDUP(value->data10);
	}
	else
	{
		retvm_if(stored_extend == value, CTS_SUCCESS, "This value is already stored");

		FREEandSTRDUP(stored_extend->data2, value->data2);
		FREEandSTRDUP(stored_extend->data3, value->data3);
		FREEandSTRDUP(stored_extend->data4, value->data4);
		FREEandSTRDUP(stored_extend->data5, value->data5);
		FREEandSTRDUP(stored_extend->data6, value->data6);
		FREEandSTRDUP(stored_extend->data7, value->data7);
		FREEandSTRDUP(stored_extend->data8, value->data8);
		FREEandSTRDUP(stored_extend->data9, value->data9);
		FREEandSTRDUP(stored_extend->data10, value->data10);
	}

	return CTS_SUCCESS;
}

API int contacts_svc_struct_store_value(CTSstruct *contact,
		cts_struct_field field, CTSvalue *value)
{
	contact_t *record = (contact_t *)contact;

	retv_if(NULL == contact, CTS_ERR_ARG_NULL);
	retv_if(NULL == value, CTS_ERR_ARG_NULL);
	retvm_if(CTS_STRUCT_CONTACT != contact->s_type, CTS_ERR_ARG_INVALID,
			"The contact(%d) must be type of CTS_STRUCT_CONTACT.", contact->s_type);
	CTS_DBG("contact type = %d, field = %d, value type = %d",
			contact->s_type, field, value->v_type);

	switch (field)
	{
	case CTS_CF_NAME_VALUE:
		retvm_if(CTS_VALUE_NAME != value->v_type, CTS_ERR_ARG_INVALID,
				"The value must be a CTS_VALUE_NAME for field(CTS_CF_NAME_VALUE).");
		if (record->name != (cts_name *)value)
			cts_contact_store_name(record, (cts_name *)value);
		break;
	case CTS_CF_BASE_INFO_VALUE:
		retvm_if(CTS_VALUE_CONTACT_BASE_INFO != value->v_type, CTS_ERR_ARG_INVALID,
				"The value must be a CTS_VALUE_CONTACT_BASE_INFO for field(CTS_CF_IMAGE_PATH_STR).");
		if (record->base != (cts_ct_base *)value)
			cts_contact_store_base(record, (cts_ct_base*)value);
		break;
	case CTS_CF_COMPANY_VALUE:
		retvm_if(CTS_VALUE_COMPANY != value->v_type, CTS_ERR_ARG_INVALID,
				"The value must be a CTS_VALUE_COMPANY for field(CTS_CF_COMPANY_VALUE).");
		if (record->company != (cts_company *)value)
			cts_contact_store_company(record, (cts_company*)value);
		break;
	default:
		if (CTS_VALUE_EXTEND == value->v_type && (int)CTS_DATA_EXTEND_START <= field)
			return cts_contact_store_extend(record, field, (cts_extend*)value);
		ERR("The parameter(field:%d) is invalid"
				"You MUST be (CTS_CF_NONE < field < CTS_CF_VALUE_MAX).", field);
		return CTS_ERR_ARG_INVALID;
	}

	return CTS_SUCCESS;
}

API CTSvalue* contacts_svc_value_new(cts_value_type type)
{
	CTSvalue* ret_val;
	switch ((int)type)
	{
	case CTS_VALUE_BASIC:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_basic));
		break;
	case CTS_VALUE_CONTACT_BASE_INFO:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_ct_base));
		break;
	case CTS_VALUE_NAME:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_name));
		break;
	case CTS_VALUE_EMAIL:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_email));
		break;
	case CTS_VALUE_NUMBER:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_number));
		break;
	case CTS_VALUE_WEB:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_web));
		break;
	case CTS_VALUE_POSTAL:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_postal));
		break;
	case CTS_VALUE_EVENT:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_event));
		break;
	case CTS_VALUE_MESSENGER:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_messenger));
		if (ret_val) ret_val->v_type = CTS_VALUE_MESSENGER;
		break;
	case CTS_VALUE_NICKNAME:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_nickname));
		break;
	case CTS_VALUE_GROUP_RELATION:
	case CTS_VALUE_GROUP:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_group));
		break;
	case CTS_VALUE_COMPANY:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_company));
		break;
	case CTS_VALUE_PHONELOG:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_plog));
		break;
	case CTS_VALUE_EXTEND:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_extend));
		break;
	case CTS_VALUE_ADDRESSBOOK:
		ret_val = (CTSvalue*)calloc(1, sizeof(cts_addrbook));
		break;
	case CTS_VALUE_LIST_CONTACT:
		if (contact_list_mempool) {
			memset(contact_list_mempool, 0x00, sizeof(contact_list));
			ret_val = (CTSvalue*)contact_list_mempool;
			contact_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(contact_list));
		break;
	case CTS_VALUE_LIST_PLOG:
		if (plog_list_mempool) {
			memset(plog_list_mempool, 0x00, sizeof(plog_list));
			ret_val = (CTSvalue*)plog_list_mempool;
			plog_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(plog_list));
		break;
	case CTS_VALUE_LIST_CUSTOM_NUM_TYPE:
		if (numtype_list_mempool) {
			memset(numtype_list_mempool, 0x00, sizeof(numtype_list));
			ret_val = (CTSvalue*)numtype_list_mempool;
			numtype_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(numtype_list));
		break;
	case CTS_VALUE_LIST_CHANGE:
		if (change_list_mempool) {
			memset(change_list_mempool, 0x00, sizeof(change_list));
			ret_val = (CTSvalue*)change_list_mempool;
			change_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(change_list));
		break;
	case CTS_VALUE_LIST_ADDRBOOK:
		if (addrbook_list_mempool) {
			memset(addrbook_list_mempool, 0x00, sizeof(cts_addrbook));
			ret_val = (CTSvalue*)addrbook_list_mempool;
			addrbook_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(cts_addrbook));
		break;
	case CTS_VALUE_LIST_GROUP:
		if (group_list_mempool) {
			memset(group_list_mempool, 0x00, sizeof(cts_group));
			ret_val = (CTSvalue*)group_list_mempool;
			group_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(cts_group));
		break;
	case CTS_VALUE_LIST_SHORTCUT:
		if (favorite_list_mempool) {
			memset(favorite_list_mempool, 0x00, sizeof(shortcut_list));
			ret_val = (CTSvalue*)favorite_list_mempool;
			favorite_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(shortcut_list));
		break;
	case CTS_VALUE_LIST_SDN:
		if (sdn_list_mempool) {
			memset(sdn_list_mempool, 0x00, sizeof(sdn_list));
			ret_val = (CTSvalue*)sdn_list_mempool;
			sdn_list_mempool = NULL;
		}
		else
			ret_val = (CTSvalue*)calloc(1, sizeof(sdn_list));
		break;
	default:
		ERR("your type is Not supported");
		return NULL;
	}

	if (ret_val)
		ret_val->v_type = type;
	else
		ERR("calloc() Failed(%d)", errno);

	return ret_val;
}

static inline void cts_internal_value_info_free(CTSvalue *value)
{
	plog_list *plog;
	cts_plog *log;
	numtype_list *numtype;
	contact_list *contact;
	change_list *change;
	shortcut_list *favorite;
	cts_group *group;
	cts_addrbook *ab;
	sdn_list *sdn;

	switch (value->v_type)
	{
	case CTS_VALUE_LIST_CONTACT:
	case CTS_VALUE_LIST_NUMBERINFO:
	case CTS_VALUE_LIST_EMAILINFO:
		contact = (contact_list *)value;
		free(contact->img_path);
		free(contact->first);
		free(contact->last);
		free(contact->display);
		free(contact->connect);
		free(contact->normalize);

		if (!contact_list_mempool) {
			contact_list_mempool = contact;
		}
		else
			if (contact_list_mempool != contact)
				free(contact);
		break;
	case CTS_VALUE_LIST_PLOG:
		plog = (plog_list *)value;
		free(plog->first);
		free(plog->last);
		free(plog->display);
		free(plog->img_path);

		if (!plog_list_mempool) {
			plog_list_mempool = plog;
		}
		else
			if (plog_list_mempool != plog)
				free(plog);
		break;
	case CTS_VALUE_LIST_CUSTOM_NUM_TYPE:
		numtype = (numtype_list *)value;
		free(numtype->name);
		if (!numtype_list_mempool) {
			numtype_list_mempool = numtype;
		}
		else
			if (numtype_list_mempool != numtype)
				free(numtype);
		break;
	case CTS_VALUE_LIST_CHANGE:
		change = (change_list *)value;
		if (!change_list_mempool) {
			change_list_mempool = change;
		}
		else
			if (change_list_mempool != change)
				free(change);
		break;
	case CTS_VALUE_LIST_GROUP:
		group = (cts_group *)value;
		free(group->name);

		if (!group_list_mempool) {
			group_list_mempool = group;
		}
		else
			if (group_list_mempool != group)
				free(group);
		break;
	case CTS_VALUE_LIST_ADDRBOOK:
		ab = (cts_addrbook *)value;
		free(ab->name);

		if (!addrbook_list_mempool) {
			addrbook_list_mempool = ab;
		}
		else
			if (addrbook_list_mempool != ab)
				free(ab);
		break;
	case CTS_VALUE_LIST_SHORTCUT:
		favorite = (shortcut_list *)value;
		free(favorite->first);
		free(favorite->last);
		free(favorite->display);
		free(favorite->number);
		free(favorite->img_path);

		if (!favorite_list_mempool) {
			favorite_list_mempool = favorite;
		}
		else
			if (favorite_list_mempool != favorite)
				free(favorite);
		break;
	case CTS_VALUE_LIST_SDN:
		sdn = (sdn_list *)value;
		free(sdn->name);
		free(sdn->number);

		if (!sdn_list_mempool) {
			sdn_list_mempool = sdn;
		}
		else
			if (sdn_list_mempool != sdn)
				free(sdn);
		break;
	case CTS_VALUE_RDONLY_NAME:
		cts_name_free((cts_name *)value);
		break;
	case CTS_VALUE_RDONLY_NUMBER:
		cts_number_free(value, NULL);
		break;
	case CTS_VALUE_RDONLY_EMAIL:
		cts_email_free(value, NULL);
		break;
	case CTS_VALUE_RDONLY_COMPANY:
		cts_company_free((cts_company *)value);
		break;
	case CTS_VALUE_RDONLY_PLOG:
		log = (cts_plog *)value;
		free(log->number);
		free(log->extra_data2);
		free(log);
		break;
	default:
		ERR("The type of value is unknown type(%d)", value->v_type);
		return;
	}
}

API int contacts_svc_value_free(CTSvalue *value)
{
	retv_if(NULL == value, CTS_ERR_ARG_NULL);

	if (CTS_VALUE_LIST_CONTACT <= value->v_type)
		cts_internal_value_info_free(value);
	else {
		switch (value->v_type) {
		case CTS_VALUE_GROUP:
			if (value->embedded) {
				free(((cts_group *)value)->name);
				free(((cts_group *)value)->ringtone_path);
			}
			break;
		case CTS_VALUE_ADDRESSBOOK:
			if (value->embedded) {
				free(((cts_addrbook *)value)->name);
			}
			break;
		default:
			if (value->embedded) {
				DBG("This is the value of struct. It is really freed with the struct.");
				return CTS_SUCCESS;
			}
			break;
		}
		free(value);
	}

	return CTS_SUCCESS;
}

API int contacts_svc_value_get_type(CTSvalue *value)
{
	retv_if(NULL == value, CTS_ERR_ARG_NULL);

	return value->v_type;
}

static inline int cts_value_get_int_base(cts_ct_base *value, int field)
{
	int ret = 0;

	switch (field)
	{
	case CTS_BASE_VAL_ID_INT:
		ret = value->id;
		break;
	case CTS_BASE_VAL_CHANGED_TIME_INT:
		ret = value->changed_time;
		break;
	case CTS_BASE_VAL_ADDRESSBOOK_ID_INT:
		ret = value->addrbook_id;
		break;
	default:
		ERR("The field(%d) is not supported in value(Base_info)", field);
		break;
	}
	return ret;
}

static inline int cts_value_get_int_plog_list(plog_list *value, int field)
{
	int ret = 0;

	switch (field)
	{
	case CTS_LIST_PLOG_ID_INT:
		ret = value->id;
		break;
	case CTS_LIST_PLOG_RELATED_ID_INT:
		ret = value->related_id;
		break;
	case CTS_LIST_PLOG_NUM_TYPE_INT:
		ret = value->num_type;
		break;
	case CTS_LIST_PLOG_LOG_TIME_INT:
		ret = value->log_time;
		break;
	case CTS_LIST_PLOG_LOG_TYPE_INT:
		ret = value->log_type;
		break;
	case CTS_LIST_PLOG_DURATION_INT:
	case CTS_LIST_PLOG_MSGID_INT:
		ret = value->extra_data1;
		break;
	default:
		ERR("The field(%d) is not supported in value(plog list)", field);
		break;
	}
	return ret;
}

static inline int cts_value_get_int_plog(cts_plog *value, int field)
{
	int ret = 0;

	switch (field)
	{
	case CTS_PLOG_VAL_ID_INT:
		ret = value->id;
		break;
	case CTS_PLOG_VAL_RELATED_ID_INT:
		ret = value->related_id;
		break;
	case CTS_PLOG_VAL_LOG_TIME_INT:
		ret = value->log_time;
		break;
	case CTS_PLOG_VAL_LOG_TYPE_INT:
		ret = value->log_type;
		break;
	case CTS_PLOG_VAL_DURATION_INT:
	case CTS_PLOG_VAL_MSGID_INT:
		ret = value->extra_data1;
		break;
	default:
		ERR("The field(%d) is not supported in value(plog)", field);
		break;
	}
	return ret;
}

static inline int cts_value_get_int_change_list(change_list *value, int field)
{
	int ret = 0;

	switch (field)
	{
	case CTS_LIST_CHANGE_ID_INT:
		ret = value->id;
		break;
	case CTS_LIST_CHANGE_TYPE_INT:
		ret = value->changed_type;
		break;
	case CTS_LIST_CHANGE_VER_INT:
		ret = value->changed_ver;
		break;
	default:
		ERR("The field(%d) is not supported in value(change list)", field);
		break;
	}
	return ret;
}

static inline int cts_value_get_int_shortcut_list(shortcut_list *value, int field)
{
	int ret = 0;

	switch (field)
	{
	case CTS_LIST_SHORTCUT_ID_INT:
		ret = value->id;
		break;
	case CTS_LIST_SHORTCUT_CONTACT_ID_INT:
		ret = value->contact_id;
		break;
	case CTS_LIST_SHORTCUT_NUMBER_TYPE_INT:
		ret = value->num_type;
		break;
	case CTS_LIST_SHORTCUT_SPEEDDIAL_INT:
		ret = value->speeddial;
		break;
	default:
		ERR("The field(%d) is not supported in value(shorcut list)", field);
		break;
	}
	return ret;
}

static inline int cts_value_get_int_addrbook(cts_addrbook *value, int field)
{
	int ret = 0;

	switch (field)
	{
	case CTS_ADDRESSBOOK_VAL_ID_INT:
		ret = value->id;
		break;
	case CTS_ADDRESSBOOK_VAL_ACC_ID_INT:
		ret = value->acc_id;
		break;
	case CTS_ADDRESSBOOK_VAL_ACC_TYPE_INT:
		ret = value->acc_type;
		break;
	case CTS_ADDRESSBOOK_VAL_MODE_INT:
		ret = value->mode;
		break;
	default:
		ERR("The field(%d) is not supported in value(addressbook)", field);
		break;
	}
	return ret;
}

API int contacts_svc_value_get_int(CTSvalue *value, int field)
{
	int ret = 0;
	retvm_if(NULL == value, 0, "The Parameter(value) is NULL");

	switch (value->v_type)
	{
	case CTS_VALUE_BASIC:
		retvm_if(CTS_BASIC_VAL_INT != ((cts_basic*)value)->type, 0,
				"The type of Basic_value is not integer");
		ret = ((cts_basic*)value)->val.i;
		break;
	case CTS_VALUE_CONTACT_BASE_INFO:
		ret = cts_value_get_int_base((cts_ct_base *)value, field);
		break;
	case CTS_VALUE_EXTEND:
		if (CTS_EXTEND_VAL_DATA1_INT == field)
			ret = ((cts_extend*)value)->data1;
		else
			ERR("The field(%d) is not supported in value(Extend)", field);
		break;
	case CTS_VALUE_RDONLY_NUMBER:
	case CTS_VALUE_NUMBER:
		if (CTS_NUM_VAL_ID_INT == field)
			ret = ((cts_number*)value)->id;
		else if (CTS_NUM_VAL_TYPE_INT == field)
			ret = ((cts_number*)value)->type;
		else
			ERR("The field(%d) is not supported in value(Number)", field);
		break;
	case CTS_VALUE_RDONLY_EMAIL:
	case CTS_VALUE_EMAIL:
		retvm_if(CTS_EMAIL_VAL_TYPE_INT != field, 0,
				"The field(%d) is not supported in value(Email)", field);
		ret = ((cts_email*)value)->type;
		break;
	case CTS_VALUE_LIST_PLOG:
		ret = cts_value_get_int_plog_list((plog_list *)value, field);
		break;
	case CTS_VALUE_RDONLY_PLOG:
		ret = cts_value_get_int_plog((cts_plog *)value, field);
		break;
	case CTS_VALUE_LIST_CONTACT:
	case CTS_VALUE_LIST_NUMS_EMAILS:
		if (CTS_LIST_CONTACT_ID_INT == field)
			ret = ((contact_list *)value)->id;
		else if (CTS_LIST_CONTACT_ADDRESSBOOK_ID_INT == field)
			ret = ((contact_list *)value)->acc_id;
		else
			ERR("The field(%d) is not supported in value(contact_list)", field);
		break;
	case CTS_VALUE_ADDRESSBOOK:
	case CTS_VALUE_LIST_ADDRBOOK:
		ret = cts_value_get_int_addrbook((cts_addrbook *)value, field);
		break;
	case CTS_VALUE_LIST_NUMBERINFO:
	case CTS_VALUE_LIST_EMAILINFO: // CTS_LIST_EMAIL_CONTACT_ID_INT is same to CTS_LIST_NUM_CONTACT_ID_INT
		retvm_if(CTS_LIST_NUM_CONTACT_ID_INT != field, 0,
				"The field(%d) is not supported in value(Number list)", field);
		ret = ((contact_list*)value)->id;
		break;
	case CTS_VALUE_LIST_GROUP:
		if (CTS_LIST_GROUP_ID_INT == field)
			ret = ((cts_group *)value)->id;
		else if (CTS_LIST_GROUP_ADDRESSBOOK_ID_INT == field)
			ret = ((cts_group *)value)->addrbook_id;
		else
			ERR("Not supported field(%d)", field);
		break;
	case CTS_VALUE_LIST_CHANGE:
		ret = cts_value_get_int_change_list((change_list *)value, field);
		break;
	case CTS_VALUE_LIST_SHORTCUT:
		ret = cts_value_get_int_shortcut_list((shortcut_list *)value, field);
		break;
	case CTS_VALUE_MESSENGER:
		if (CTS_MESSENGER_VAL_TYPE_INT == field)
			ret = ((cts_messenger*)value)->type;
		else
			ERR("Not supported field(%d)", field);
		break;
	case CTS_VALUE_GROUP_RELATION:
		if (CTS_GROUPREL_VAL_ID_INT == field)
			ret = ((cts_group*)value)->id;
		else
			ERR("Not supported field(%d)", field);
		break;
	case CTS_VALUE_GROUP:
		if (CTS_GROUP_VAL_ID_INT == field)
			ret = ((cts_group*)value)->id;
		if (CTS_GROUP_VAL_ADDRESSBOOK_ID_INT == field)
			ret = ((cts_group*)value)->addrbook_id;
		else
			ERR("Not supported field(%d)", field);
		break;
	case CTS_VALUE_WEB:
		if (CTS_WEB_VAL_TYPE_INT == field)
			ret = ((cts_web*)value)->type;
		else
			ERR("Not supported field(%d)", field);
		break;
	case CTS_VALUE_POSTAL:
		if (CTS_POSTAL_VAL_TYPE_INT == field)
			ret = ((cts_postal*)value)->type;
		else
			ERR("Not supported field(%d)", field);
		break;
	case CTS_VALUE_EVENT:
		if (CTS_EVENT_VAL_TYPE_INT == field)
			ret = ((cts_event *)value)->type;
		else if (CTS_EVENT_VAL_DATE_INT == field)
			ret = ((cts_event *)value)->date;
		else
			ERR("Not supported field(%d)", field);
		break;
	case CTS_VALUE_PHONELOG:
		/* phonelog value is write only */
	case CTS_VALUE_COMPANY:
		/* company value doesn't have interger value */
	case CTS_VALUE_NAME:
		/* name value doesn't have interger value */
	default:
		ERR("The value has unsupported type");
		break;
	}
	return ret;
}

double contacts_svc_value_get_dbl(CTSvalue *value, int field)
{
	retv_if(NULL == value, CTS_ERR_ARG_NULL);

	switch (value->v_type)
	{
	case CTS_VALUE_BASIC:
		retvm_if(CTS_BASIC_VAL_DBL != ((cts_basic*)value)->type, 0.0,
				"The type of value is not double");
		return ((cts_basic*)value)->val.d;
	case CTS_VALUE_NAME:
	case CTS_VALUE_EMAIL:
	case CTS_VALUE_NUMBER:
	case CTS_VALUE_WEB:
	case CTS_VALUE_POSTAL:
	case CTS_VALUE_EVENT:
	case CTS_VALUE_MESSENGER:
	case CTS_VALUE_GROUP_RELATION:
	case CTS_VALUE_COMPANY:
	default:
		ERR("The value has unsupported type");
		return CTS_ERR_ARG_INVALID;
	}

}

API bool contacts_svc_value_get_bool(CTSvalue *value, int field)
{
	retvm_if(NULL == value, false, "The Parameter(value) is NULL");

	switch (value->v_type)
	{
	case CTS_VALUE_CONTACT_BASE_INFO:
		if (CTS_BASE_VAL_FAVORITE_BOOL == field) {
			return ((cts_ct_base*)value)->is_favorite;
		}
		else {
			ERR("The field(%d) is not supported in value(BASE_INFO)", field);
			return false;
		}
	case CTS_VALUE_RDONLY_NUMBER:
	case CTS_VALUE_NUMBER:
		if (CTS_NUM_VAL_DEFAULT_BOOL == field) {
			return ((cts_number*)value)->is_default;
		}
		else if (CTS_NUM_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else if (CTS_NUM_VAL_FAVORITE_BOOL == field) {
			return ((cts_number*)value)->is_favorite;
		}
		else {
			ERR("The field(%d) is not supported in value(Number)", field);
			return false;
		}
	case CTS_VALUE_RDONLY_EMAIL:
	case CTS_VALUE_EMAIL:
		if (CTS_EMAIL_VAL_DEFAULT_BOOL == field) {
			return ((cts_email*)value)->is_default;
		}
		else if (CTS_EMAIL_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else {
			ERR("The field(%d) is not supported in value(Email)", field);
			return false;
		}
	case CTS_VALUE_GROUP_RELATION:
		if (CTS_GROUPREL_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else {
			ERR("The field(%d) is not supported in value(Group)", field);
			return false;
		}
	case CTS_VALUE_EVENT:
		if (CTS_EVENT_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else {
			ERR("The field(%d) is not supported in value(Event)", field);
			return false;
		}
	case CTS_VALUE_MESSENGER:
		if (CTS_MESSENGER_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else {
			ERR("The field(%d) is not supported in value(Messenger)", field);
			return false;
		}
	case CTS_VALUE_POSTAL:
		if (CTS_POSTAL_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else if (CTS_POSTAL_VAL_DEFAULT_BOOL == field) {
			return ((cts_postal*)value)->is_default;;
		}
		else {
			ERR("The field(%d) is not supported in value(Postal)", field);
			return false;
		}
	case CTS_VALUE_WEB:
		if (CTS_WEB_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else {
			ERR("The field(%d) is not supported in value(Web)", field);
			return false;
		}
	case CTS_VALUE_NICKNAME:
		if (CTS_NICKNAME_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else {
			ERR("The field(%d) is not supported in value(Web)", field);
			return false;
		}
	case CTS_VALUE_EXTEND:
		if (CTS_EXTEND_VAL_DELETE_BOOL == field) {
			return value->deleted;
		}
		else {
			ERR("The field(%d) is not supported in value(Extend)", field);
			return false;
		}
	case CTS_VALUE_BASIC:
		retvm_if(CTS_BASIC_VAL_BOOL != ((cts_basic*)value)->type, false,
				"The type of value is not boolean");
		return ((cts_basic*)value)->val.b;
	case CTS_VALUE_PHONELOG:
		/* phonelog value is write only */
	case CTS_VALUE_LIST_CONTACT:
		/* contact list value doesn't have boolean value */
	case CTS_VALUE_LIST_PLOG:
		/* plog list value doesn't have boolean value */
	case CTS_VALUE_LIST_CUSTOM_NUM_TYPE:
		/* custom number type list value doesn't have boolean value */
	case CTS_VALUE_LIST_CHANGE:
		/* Change list value doesn't have boolean value */
	case CTS_VALUE_NAME:
		/* name value doesn't have boolean value */
	case CTS_VALUE_COMPANY:
		/* company value doesn't have boolean value */
	default:
		ERR("The value has unsupported type");
		return false;
	}
}

static inline char* cts_value_get_str_name(int op_code,
		cts_name *value, int field)
{
	char *ret_val;

	switch (field)
	{
	case CTS_NAME_VAL_FIRST_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->first);
		break;
	case CTS_NAME_VAL_LAST_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->last);
		break;
	case CTS_NAME_VAL_DISPLAY_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->display);
		break;
	case CTS_NAME_VAL_ADDITION_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->addition);
		break;
	case CTS_NAME_VAL_PREFIX_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->prefix);
		break;
	case CTS_NAME_VAL_SUFFIX_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->suffix);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_extend(int op_code,
		cts_extend *value, int field)
{
	char *ret_val;

	switch (field)
	{
	case CTS_EXTEND_VAL_DATA2_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data2);
		break;
	case CTS_EXTEND_VAL_DATA3_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data3);
		break;
	case CTS_EXTEND_VAL_DATA4_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data4);
		break;
	case CTS_EXTEND_VAL_DATA5_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data5);
		break;
	case CTS_EXTEND_VAL_DATA6_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data6);
		break;
	case CTS_EXTEND_VAL_DATA7_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data7);
		break;
	case CTS_EXTEND_VAL_DATA8_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data8);
		break;
	case CTS_EXTEND_VAL_DATA9_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data9);
		break;
	case CTS_EXTEND_VAL_DATA10_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->data10);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_base(int op_code,
		cts_ct_base *value, int field)
{
	char *ret_val;

	switch (field)
	{
	case CTS_BASE_VAL_IMG_PATH_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->img_path);
		if (NULL == ret_val && value->vcard_img_path) {
			if (CTS_HANDLE_STR_STEAL == op_code)
				ret_val = strdup(value->vcard_img_path);
			else
				ret_val = value->vcard_img_path;
		}
		break;
	case CTS_BASE_VAL_RINGTONE_PATH_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->ringtone_path);
		break;
	case CTS_BASE_VAL_NOTE_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->note);
		break;
	case CTS_BASE_VAL_UID_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->uid);
		break;
	case CTS_BASE_VAL_FULL_IMG_PATH_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->full_img_path);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_contact_list(int op_code,
		contact_list *value, int field)
{
	char *ret_val;
	switch (field)
	{
	case CTS_LIST_CONTACT_FIRST_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->first);
		break;
	case CTS_LIST_CONTACT_LAST_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->last);
		break;
	case CTS_LIST_CONTACT_DISPLAY_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->display);
		break;
	case CTS_LIST_CONTACT_IMG_PATH_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->img_path);
		break;
	case CTS_LIST_CONTACT_NUM_OR_EMAIL_STR:
		if (CTS_VALUE_LIST_NUMS_EMAILS == value->v_type) {
			HANDLE_STEAL_STRING(op_code, ret_val, value->connect);
		} else {
			ERR("The parameter(field:%d, value type = %d) is not interpreted",
				field, value->v_type);
			ret_val = NULL;
		}
		break;
	case CTS_LIST_CONTACT_NORMALIZED_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->normalize);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_num_email_list(int op_code,
		contact_list *value, int field, int type)
{
	char *ret_val;
	switch (field)
	{
	case CTS_LIST_NUM_CONTACT_FIRST_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->first);
		break;
	case CTS_LIST_NUM_CONTACT_LAST_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->last);
		break;
	case CTS_LIST_NUM_CONTACT_DISPLAY_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->display);
		break;
	case CTS_LIST_NUM_CONTACT_IMG_PATH_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->img_path);
		break;
	case CTS_LIST_NUM_NUMBER_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->connect);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_favorite_list(int op_code,
		shortcut_list *value, int field)
{
	char *ret_val;
	switch (field)
	{
	case CTS_LIST_SHORTCUT_FIRST_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->first);
		break;
	case CTS_LIST_SHORTCUT_LAST_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->last);
		break;
	case CTS_LIST_SHORTCUT_DISPLAY_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->display);
		break;
	case CTS_LIST_SHORTCUT_IMG_PATH_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->img_path);
		break;
	case CTS_LIST_SHORTCUT_NUMBER_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->number);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_plog_list(int op_code,
		plog_list *value, int field)
{
	char *ret_val;
	switch (field)
	{
	case CTS_LIST_PLOG_FIRST_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->first);
		break;
	case CTS_LIST_PLOG_LAST_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->last);
		break;
	case CTS_LIST_PLOG_DISPLAY_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->display);
		break;
	case CTS_LIST_PLOG_NUMBER_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->number);
		break;
	case CTS_LIST_PLOG_IMG_PATH_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->img_path);
		break;
	case CTS_LIST_PLOG_SHORTMSG_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->extra_data2);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_postal(int op_code,
		cts_postal *value, int field)
{
	char *ret_val;
	switch (field)
	{
	case CTS_POSTAL_VAL_POBOX_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->pobox);
		break;
	case CTS_POSTAL_VAL_POSTALCODE_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->postalcode);
		break;
	case CTS_POSTAL_VAL_REGION_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->region);
		break;
	case CTS_POSTAL_VAL_LOCALITY_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->locality);
		break;
	case CTS_POSTAL_VAL_STREET_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->street);
		break;
	case CTS_POSTAL_VAL_EXTENDED_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->extended);
		break;
	case CTS_POSTAL_VAL_COUNTRY_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->country);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static inline char* cts_value_get_str_company(int op_code,
		cts_company *value, int field)
{
	char *ret_val;
	switch (field)
	{
	case CTS_COMPANY_VAL_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->name);
		break;
	case CTS_COMPANY_VAL_DEPARTMENT_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->department);
		break;
	case CTS_COMPANY_VAL_JOB_TITLE_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->jot_title);
		break;
	case CTS_COMPANY_VAL_ROLE_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->role);
		break;
	case CTS_COMPANY_VAL_ASSISTANT_NAME_STR:
		HANDLE_STEAL_STRING(op_code, ret_val, value->assistant_name);
		break;
	default:
		ERR("The parameter(field:%d) is not interpreted", field);
		ret_val = NULL;
		break;
	}
	return ret_val;
}

static char* cts_value_handle_str(int op_code, CTSvalue *value, int field)
{
	char *ret_val;
	retvm_if(NULL == value, NULL, "The Parameter(value) is NULL");

	switch (value->v_type)
	{
	case CTS_VALUE_BASIC:
		retvm_if(CTS_BASIC_VAL_STR != ((cts_basic *)value)->type, NULL,
				"The type of value is not string");
		HANDLE_STEAL_STRING(op_code, ret_val, ((cts_basic *)value)->val.s);
		break;
	case CTS_VALUE_CONTACT_BASE_INFO:
		ret_val = cts_value_get_str_base(op_code, (cts_ct_base *)value, field);
		break;
	case CTS_VALUE_POSTAL:
		ret_val = cts_value_get_str_postal(op_code, (cts_postal *)value, field);
		break;
	case CTS_VALUE_COMPANY:
	case CTS_VALUE_RDONLY_COMPANY:
		ret_val = cts_value_get_str_company(op_code, (cts_company *)value, field);
		break;
	case CTS_VALUE_NAME:
	case CTS_VALUE_RDONLY_NAME:
		ret_val = cts_value_get_str_name(op_code, (cts_name *)value, field);
		break;
	case CTS_VALUE_EXTEND:
		ret_val = cts_value_get_str_extend(op_code, (cts_extend *)value, field);
		break;
	case CTS_VALUE_LIST_CONTACT:
	case CTS_VALUE_LIST_NUMS_EMAILS:
		ret_val = cts_value_get_str_contact_list(op_code, (contact_list *)value, field);
		break;
	case CTS_VALUE_LIST_NUMBERINFO:
	case CTS_VALUE_LIST_EMAILINFO:
		ret_val = cts_value_get_str_num_email_list(op_code, (contact_list *)value, field, value->v_type);
		break;
	case CTS_VALUE_LIST_SHORTCUT:
		ret_val = cts_value_get_str_favorite_list(op_code, (shortcut_list *)value, field);
		break;
	case CTS_VALUE_LIST_PLOG:
		ret_val = cts_value_get_str_plog_list(op_code, (plog_list *)value, field);
		break;
	case CTS_VALUE_RDONLY_PLOG:
		if (CTS_PLOG_VAL_NUMBER_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_plog *)value)->number);
		} else if (CTS_PLOG_VAL_SHORTMSG_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_plog *)value)->extra_data2);
		} else {
			ERR("Not supported field");
			return NULL;
		}
		break;
	case CTS_VALUE_NUMBER:
	case CTS_VALUE_RDONLY_NUMBER:
		retvm_if(CTS_NUM_VAL_NUMBER_STR != field, NULL,
				"This field(%d) is not supported in value(Number)", field);
		HANDLE_STEAL_STRING(op_code, ret_val, ((cts_number *)value)->number);
		break;
	case CTS_VALUE_EMAIL:
	case CTS_VALUE_RDONLY_EMAIL:
		retvm_if(CTS_EMAIL_VAL_ADDR_STR != field, NULL,
				"This field(%d) is not supported in value(Email)", field);
		HANDLE_STEAL_STRING(op_code, ret_val, ((cts_email *)value)->email_addr);
		break;
	case CTS_VALUE_ADDRESSBOOK:
	case CTS_VALUE_LIST_ADDRBOOK:
		retvm_if(CTS_ADDRESSBOOK_VAL_NAME_STR != field, NULL,
				"This field(%d) is not supported in value(addressbook)", field);
		HANDLE_STEAL_STRING(op_code, ret_val, ((cts_addrbook *)value)->name);
		break;
	case CTS_VALUE_GROUP_RELATION:
		if (CTS_GROUPREL_VAL_NAME_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_group *)value)->name);
		}
		else if (CTS_GROUPREL_VAL_RINGTONE_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_group *)value)->ringtone_path);
		}
		else {
			ERR("Not supported field(%d)", field);
			ret_val = NULL;
		}
		break;
	case CTS_VALUE_MESSENGER:
		if (CTS_MESSENGER_VAL_IM_ID_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_messenger *)value)->im_id);
		}
		else {
			ERR("Not supported field(%d)", field);
			ret_val = NULL;
		}
		break;
	case CTS_VALUE_WEB:
		if (CTS_WEB_VAL_ADDR_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_web *)value)->url);
		}
		else {
			ERR("Not supported field(%d)", field);
			ret_val = NULL;
		}
		break;
	case CTS_VALUE_NICKNAME:
		if (CTS_NICKNAME_VAL_NAME_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_nickname *)value)->nick);
		}
		else {
			ERR("Not supported field(%d)", field);
			ret_val = NULL;
		}
		break;
	case CTS_VALUE_GROUP:
		if (CTS_GROUP_VAL_NAME_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_group *)value)->name);
		}
		else if (CTS_GROUP_VAL_RINGTONE_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_group *)value)->ringtone_path);
		}
		else {
			ERR("Not supported field(%d)", field);
			ret_val = NULL;
		}
		break;
	case CTS_VALUE_LIST_GROUP:
		if (CTS_LIST_GROUP_NAME_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((cts_group *)value)->name);
		}
		else {
			ERR("Not supported field(%d)", field);
			ret_val = NULL;
		}
		break;
	case CTS_VALUE_LIST_SDN:
		if (CTS_LIST_SDN_NAME_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((sdn_list *)value)->name);
		}
		else if (CTS_LIST_SDN_NUMBER_STR == field) {
			HANDLE_STEAL_STRING(op_code, ret_val, ((sdn_list *)value)->number);
		}
		else {
			ERR("Not supported field(%d)", field);
			ret_val = NULL;
		}
		break;
	case CTS_VALUE_PHONELOG:
		/* phonelog value is write only */
	case CTS_VALUE_LIST_CHANGE:
		/* Change list value doesn't have string value */
	case CTS_VALUE_EVENT:
		/* evet value doesn't have string value */
	default:
		ERR("The value has unsupported type");
		ret_val = NULL;
		break;
	}
	return ret_val;
}

API const char* contacts_svc_value_get_str(CTSvalue *value, int field)
{
	return cts_value_handle_str(CTS_HANDLE_STR_GET, value, field);
}

API char* contacts_svc_value_steal_str(CTSvalue *value, int field)
{
	return cts_value_handle_str(CTS_HANDLE_STR_STEAL, value, field);
}

static inline int cts_value_set_int_plog(cts_plog *value, int field, int intval)
{
	switch (field)
	{
	case CTS_PLOG_VAL_LOG_TIME_INT:
		value->log_time = intval;
		break;
	case CTS_PLOG_VAL_LOG_TYPE_INT:
		value->log_type = intval;
		break;
	case CTS_PLOG_VAL_DURATION_INT:
	case CTS_PLOG_VAL_MSGID_INT:
		value->extra_data1 = intval;
		break;
	case CTS_PLOG_VAL_RELATED_ID_INT:
		value->related_id = intval;
		break;
	default:
		ERR("The field(%d) is not supported in value(plog)", field);
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

static inline int cts_value_set_int_addrbook(cts_addrbook *value,
		int field, int intval)
{
	switch (field)
	{
	case CTS_ADDRESSBOOK_VAL_ACC_ID_INT:
		value->acc_id = intval;
		break;
	case CTS_ADDRESSBOOK_VAL_ACC_TYPE_INT:
		value->acc_type = intval;
		break;
	case CTS_ADDRESSBOOK_VAL_MODE_INT:
		value->mode = intval;
		break;
	default:
		ERR("The field(%d) is not supported in value(addressbook)", field);
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

API int contacts_svc_value_set_int(CTSvalue *value, int field, int intval)
{
	retv_if(NULL == value, CTS_ERR_ARG_NULL);

	switch (value->v_type)
	{
	case CTS_VALUE_BASIC:
		((cts_basic*)value)->type = CTS_BASIC_VAL_INT;
		((cts_basic*)value)->val.i = intval;
		break;
	case CTS_VALUE_EXTEND:
		retvm_if(CTS_EXTEND_VAL_DATA1_INT != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		((cts_extend *)value)->data1 = intval;
		break;
	case CTS_VALUE_EMAIL:
	case CTS_VALUE_NUMBER:
		retvm_if(CTS_NUM_VAL_TYPE_INT != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		((cts_number *)value)->type = intval;
		break;
	case CTS_VALUE_PHONELOG:
		return cts_value_set_int_plog((cts_plog *)value, field, intval);
	case CTS_VALUE_GROUP_RELATION:
		retvm_if(CTS_GROUPREL_VAL_ID_INT != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for creating");
		((cts_group *)value)->id = intval;
		break;
	case CTS_VALUE_GROUP:
		retvm_if(CTS_GROUP_VAL_ADDRESSBOOK_ID_INT != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(!value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for updating");
		((cts_group *)value)->addrbook_id = intval;
		break;
	case CTS_VALUE_MESSENGER:
		retvm_if(CTS_MESSENGER_VAL_TYPE_INT != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		((cts_messenger *)value)->type = intval;
		break;
	case CTS_VALUE_WEB:
		retvm_if(CTS_WEB_VAL_TYPE_INT != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		((cts_web *)value)->type = intval;
		break;
	case CTS_VALUE_EVENT:
		if (CTS_EVENT_VAL_TYPE_INT == field)
			((cts_event *)value)->type = intval;
		else if (CTS_EVENT_VAL_DATE_INT == field)
			((cts_event *)value)->date = intval;
		else
		{
			ERR("Not supported field");
			return CTS_ERR_ARG_INVALID;
		}
		break;
	case CTS_VALUE_POSTAL:
		retvm_if(CTS_POSTAL_VAL_TYPE_INT != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		((cts_postal *)value)->type = intval;
		break;
	case CTS_VALUE_ADDRESSBOOK:
		return cts_value_set_int_addrbook((cts_addrbook *)value, field, intval);
	case CTS_VALUE_COMPANY:
		/* company value doesn't have integer value */
	case CTS_VALUE_NAME:
		/* name value doesn't have integer value */
	case CTS_VALUE_CONTACT_BASE_INFO:
		/* base_info value doesn't have integer value for set */
	default:
		ERR("The value has unsupported type");
		return CTS_ERR_ARG_INVALID;
	}

	return CTS_SUCCESS;
}

int contacts_svc_value_set_dbl(CTSvalue *value, int field, double dblval)
{
	retv_if(NULL == value, CTS_ERR_ARG_NULL);

	switch (value->v_type)
	{
	case CTS_VALUE_BASIC:
		((cts_basic*)value)->type = CTS_BASIC_VAL_DBL;
		((cts_basic*)value)->val.d = dblval;
		break;
	case CTS_VALUE_EMAIL:
	case CTS_VALUE_NUMBER:
	case CTS_VALUE_WEB:
	case CTS_VALUE_POSTAL:
	case CTS_VALUE_EVENT:
	case CTS_VALUE_MESSENGER:
	case CTS_VALUE_GROUP_RELATION:
	case CTS_VALUE_COMPANY:
	case CTS_VALUE_NAME:
	case CTS_VALUE_CONTACT_BASE_INFO:
	default:
		ERR("The value has unsupported type");
		return CTS_ERR_ARG_INVALID;
	}

	return CTS_SUCCESS;
}

API int contacts_svc_value_set_bool(CTSvalue *value,
		int field, bool boolval)
{
	retv_if(NULL == value, CTS_ERR_ARG_NULL);

	switch (value->v_type)
	{
	case CTS_VALUE_CONTACT_BASE_INFO:
		if (CTS_BASE_VAL_FAVORITE_BOOL == field)
			((cts_ct_base*)value)->is_favorite = boolval;
		else {
			ERR("The field(%d) is not supported in value(BASE_INFO)", field);
			return CTS_ERR_ARG_INVALID;
		}
		break;
	case CTS_VALUE_NUMBER:
		if (CTS_NUM_VAL_DEFAULT_BOOL == field)
			((cts_number *)value)->is_default = boolval;
		else if (CTS_NUM_VAL_FAVORITE_BOOL == field)
			((cts_number *)value)->is_favorite = boolval;
		else if (CTS_NUM_VAL_DELETE_BOOL == field) {
			retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
					"The field is only used for updating");
			value->deleted = boolval;
		}
		else {
			ERR("Not supported field");
			return CTS_ERR_ARG_INVALID;
		}
		break;
	case CTS_VALUE_EMAIL:
		if (CTS_EMAIL_VAL_DEFAULT_BOOL == field)
			((cts_email *)value)->is_default = boolval;
		else if (CTS_EMAIL_VAL_DELETE_BOOL == field) {
			retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
					"The field is only used for updating");
			value->deleted = boolval;
		}
		else {
			ERR("Not supported field");
			return CTS_ERR_ARG_INVALID;
		}
		break;
	case CTS_VALUE_POSTAL:
		if (CTS_POSTAL_VAL_DEFAULT_BOOL == field)
			((cts_postal *)value)->is_default = boolval;
		else if (CTS_POSTAL_VAL_DELETE_BOOL == field) {
			retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
					"The field is only used for updating");
			value->deleted = boolval;
		}
		else {
			ERR("Not supported field");
			return CTS_ERR_ARG_INVALID;
		}
		break;
	case CTS_VALUE_GROUP_RELATION:
		retvm_if(CTS_GROUPREL_VAL_DELETE_BOOL != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for updating");
		value->deleted = boolval;
		break;
	case CTS_VALUE_EVENT:
		retvm_if(CTS_EVENT_VAL_DELETE_BOOL != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for updating");
		value->deleted = boolval;
		break;
	case CTS_VALUE_MESSENGER:
		retvm_if(CTS_MESSENGER_VAL_DELETE_BOOL != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for updating");
		value->deleted = boolval;
		break;
	case CTS_VALUE_WEB:
		retvm_if(CTS_WEB_VAL_DELETE_BOOL != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for updating");
		value->deleted = boolval;
		break;
	case CTS_VALUE_NICKNAME:
		retvm_if(CTS_NICKNAME_VAL_DELETE_BOOL != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for updating");
		value->deleted = boolval;
		break;
	case CTS_VALUE_EXTEND:
		retvm_if(CTS_EXTEND_VAL_DELETE_BOOL != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		retvm_if(false == value->embedded, CTS_ERR_ARG_INVALID,
				"The field is only used for updating");
		value->deleted = boolval;
		break;
	case CTS_VALUE_BASIC:
		((cts_basic*)value)->type = CTS_BASIC_VAL_BOOL;
		((cts_basic*)value)->val.b = boolval;
		break;
	case CTS_VALUE_COMPANY:
		/* company value doesn't have boolean value */
	case CTS_VALUE_NAME:
		/* name value doesn't have boolean value */
	default:
		ERR("The value has unsupported type");
		return CTS_ERR_ARG_INVALID;
	}

	return CTS_SUCCESS;
}

static inline int cts_base_set_str(cts_ct_base *base, int field, char *strval)
{
	switch (field)
	{
	case CTS_BASE_VAL_IMG_PATH_STR:
		if (base->embedded)
			FREEandSTRDUP(base->img_path, strval);
		else
			base->img_path = strval;
		base->img_changed = true;
		break;
	case CTS_BASE_VAL_RINGTONE_PATH_STR:
		if (base->embedded)
			FREEandSTRDUP(base->ringtone_path, strval);
		else
			base->ringtone_path = strval;
		base->ringtone_changed = true;
		break;
	case CTS_BASE_VAL_NOTE_STR:
		if (base->embedded)
			FREEandSTRDUP(base->note, strval);
		else
			base->note = strval;
		base->note_changed = true;
		break;
	case CTS_BASE_VAL_UID_STR:
		if (base->embedded)
			FREEandSTRDUP(base->uid, strval);
		else
			base->uid = strval;
		base->uid_changed = true;
		break;
	case CTS_BASE_VAL_FULL_IMG_PATH_STR:
		if (base->embedded)
			FREEandSTRDUP(base->full_img_path, strval);
		else
			base->full_img_path = strval;
		base->full_img_changed = true;
		break;
	default:
		ERR("Not supported field");
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

static inline int cts_name_set_str(cts_name *name, int field, char *strval)
{
	switch (field)
	{
	case CTS_NAME_VAL_FIRST_STR:
		if (name->embedded) {
			FREEandSTRDUP(name->first, strval);
		}
		else
			name->first = strval;
		break;
	case CTS_NAME_VAL_LAST_STR:
		if (name->embedded) {
			FREEandSTRDUP(name->last, strval);
		}
		else
			name->last = strval;
		break;
	case CTS_NAME_VAL_ADDITION_STR:
		if (name->embedded) {
			FREEandSTRDUP(name->addition, strval);
		}
		else
			name->addition = strval;
		break;
	case CTS_NAME_VAL_DISPLAY_STR:
		if (name->embedded) {
			FREEandSTRDUP(name->display, strval);
		}
		else
			name->display = strval;
		break;
	case CTS_NAME_VAL_PREFIX_STR:
		if (name->embedded) {
			FREEandSTRDUP(name->prefix, strval);
		}
		else
			name->prefix = strval;
		break;
	case CTS_NAME_VAL_SUFFIX_STR:
		if (name->embedded) {
			FREEandSTRDUP(name->suffix, strval);
		}
		else
			name->suffix = strval;
		break;
	default:
		ERR("Not supported field");
		return CTS_ERR_ARG_INVALID;
	}
	name->is_changed = true;
	return CTS_SUCCESS;
}

static inline int cts_postal_set_str(cts_postal *postal, int field, char *strval)
{
	switch (field)
	{
	case CTS_POSTAL_VAL_POBOX_STR:
		if (postal->embedded) {
			FREEandSTRDUP(postal->pobox, strval);
		}
		else
			postal->pobox = strval;
		break;
	case CTS_POSTAL_VAL_POSTALCODE_STR:
		if (postal->embedded) {
			FREEandSTRDUP(postal->postalcode, strval);
		}
		else
			postal->postalcode = strval;
		break;
	case CTS_POSTAL_VAL_REGION_STR:
		if (postal->embedded) {
			FREEandSTRDUP(postal->region, strval);
		}
		else
			postal->region = strval;
		break;
	case CTS_POSTAL_VAL_LOCALITY_STR:
		if (postal->embedded) {
			FREEandSTRDUP(postal->locality, strval);
		}
		else
			postal->locality = strval;
		break;
	case CTS_POSTAL_VAL_STREET_STR:
		if (postal->embedded) {
			FREEandSTRDUP(postal->street, strval);
		}
		else
			postal->street = strval;
		break;
	case CTS_POSTAL_VAL_EXTENDED_STR:
		if (postal->embedded) {
			FREEandSTRDUP(postal->extended, strval);
		}
		else
			postal->extended = strval;
		break;
	case CTS_POSTAL_VAL_COUNTRY_STR:
		if (postal->embedded) {
			FREEandSTRDUP(postal->country, strval);
		}
		else
			postal->country = strval;
		break;
	default:
		ERR("Not supported field");
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

static inline int cts_company_set_str(
		cts_company *com, int field, char *strval)
{
	switch (field)
	{
	case CTS_COMPANY_VAL_NAME_STR:
		if (com->embedded) {
			FREEandSTRDUP(com->name, strval);
		}
		else
			com->name = strval;
		break;
	case CTS_COMPANY_VAL_DEPARTMENT_STR:
		if (com->embedded) {
			FREEandSTRDUP(com->department, strval);
		}
		else
			com->department = strval;
		break;
	case CTS_COMPANY_VAL_JOB_TITLE_STR:
		if (com->embedded) {
			FREEandSTRDUP(com->jot_title, strval);
		}
		else
			com->jot_title = strval;
		break;
	case CTS_COMPANY_VAL_ROLE_STR:
		if (com->embedded) {
			FREEandSTRDUP(com->role, strval);
		}
		else
			com->role = strval;
		break;
	case CTS_COMPANY_VAL_ASSISTANT_NAME_STR:
		if (com->embedded) {
			FREEandSTRDUP(com->assistant_name, strval);
		}
		else
			com->assistant_name = strval;
		break;
	default:
		ERR("Not supported field");
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

static inline int cts_group_set_str(
		cts_group *group, int field, char *strval)
{
	switch (field)
	{
	case CTS_GROUP_VAL_NAME_STR:
		if (group->embedded) {
			FREEandSTRDUP(group->name, strval);
		}
		else
			group->name = strval;
		break;
	case CTS_GROUP_VAL_RINGTONE_STR:
		if (group->embedded) {
			FREEandSTRDUP(group->ringtone_path, strval);
		}
		else
			group->ringtone_path = strval;
		break;
	default:
		ERR("Not supported field");
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

static inline int cts_extend_set_str(cts_extend *extend, int field, char *strval)
{
	switch (field)
	{
	case CTS_EXTEND_VAL_DATA2_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data2, strval);
		}
		else
			extend->data2 = strval;
		break;
	case CTS_EXTEND_VAL_DATA3_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data3, strval);
		}
		else
			extend->data3 = strval;
		break;
	case CTS_EXTEND_VAL_DATA4_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data4, strval);
		}
		else
			extend->data4 = strval;
		break;
	case CTS_EXTEND_VAL_DATA5_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data5, strval);
		}
		else
			extend->data5 = strval;
		break;
	case CTS_EXTEND_VAL_DATA6_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data6, strval);
		}
		else
			extend->data6 = strval;
		break;
	case CTS_EXTEND_VAL_DATA7_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data7, strval);
		}
		else
			extend->data7 = strval;
		break;
	case CTS_EXTEND_VAL_DATA8_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data8, strval);
		}
		else
			extend->data8 = strval;
		break;
	case CTS_EXTEND_VAL_DATA9_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data9, strval);
		}
		else
			extend->data9 = strval;
		break;

	case CTS_EXTEND_VAL_DATA10_STR:
		if (extend->embedded) {
			FREEandSTRDUP(extend->data10, strval);
		}
		else
			extend->data10 = strval;
		break;
	default:
		ERR("Not supported field");
		return CTS_ERR_ARG_INVALID;
	}
	return CTS_SUCCESS;
}

API int contacts_svc_value_set_str(CTSvalue *value, int field, const char *strval)
{
	char *str;

	retv_if(NULL == value, CTS_ERR_ARG_NULL);

	if (strval && *strval)
		str = (char *)strval;
	else
		str = NULL;

	switch (value->v_type)
	{
	case CTS_VALUE_BASIC:
		((cts_basic*)value)->type = CTS_BASIC_VAL_STR;
		if (value->embedded)
			FREEandSTRDUP(((cts_basic*)value)->val.s, str);
		else
			((cts_basic*)value)->val.s = str;
		break;
	case CTS_VALUE_CONTACT_BASE_INFO:
		return cts_base_set_str((cts_ct_base *)value, field, str);
	case CTS_VALUE_NAME:
		return cts_name_set_str((cts_name *)value, field, str);
	case CTS_VALUE_POSTAL:
		return cts_postal_set_str((cts_postal *)value, field, str);
	case CTS_VALUE_COMPANY:
		return cts_company_set_str((cts_company *)value, field, str);
	case CTS_VALUE_GROUP:
		return cts_group_set_str((cts_group *)value, field, str);
	case CTS_VALUE_EXTEND:
		return cts_extend_set_str((cts_extend *)value, field, str);
	case CTS_VALUE_NUMBER:
		retvm_if(CTS_NUM_VAL_NUMBER_STR != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		if (value->embedded)
			FREEandSTRDUP(((cts_number*)value)->number, str);
		else
			((cts_number *)value)->number = str;
		break;
	case CTS_VALUE_EMAIL:
		retvm_if(CTS_EMAIL_VAL_ADDR_STR != field, CTS_ERR_ARG_INVALID, "Not supported field");
		if (value->embedded)
			FREEandSTRDUP(((cts_email*)value)->email_addr, str);
		else
			((cts_email *)value)->email_addr = str;
		break;
	case CTS_VALUE_GROUP_RELATION:
		retvm_if(CTS_GROUPREL_VAL_NAME_STR != field, CTS_ERR_ARG_INVALID,
				"Not supported field(%d) for CTS_VALUE_GROUP_RELATION", field);
		retvm_if(value->embedded, CTS_ERR_ARG_INVALID,
				"CTS_GROUPREL_VAL_NAME_STR is readonly");
		((cts_group *)value)->name = str;
		break;
	case CTS_VALUE_PHONELOG:  /* phonelog value never be embedded*/
		if (CTS_PLOG_VAL_NUMBER_STR == field)
			((cts_plog *)value)->number = str;
		else if (CTS_PLOG_VAL_SHORTMSG_STR == field)
			((cts_plog *)value)->extra_data2 = str;
		else
		{
			ERR("Not supported field");
			return CTS_ERR_ARG_INVALID;
		}
		break;
	case CTS_VALUE_MESSENGER:
		retvm_if(CTS_MESSENGER_VAL_IM_ID_STR != field, CTS_ERR_ARG_INVALID, "Not supported field");
		if (value->embedded)
			FREEandSTRDUP(((cts_messenger *)value)->im_id, str);
		else
			((cts_messenger *)value)->im_id = str;
		break;
	case CTS_VALUE_WEB:
		retvm_if(CTS_WEB_VAL_ADDR_STR != field, CTS_ERR_ARG_INVALID, "Not supported field");
		if (value->embedded)
			FREEandSTRDUP(((cts_web *)value)->url, str);
		else
			((cts_web *)value)->url = str;
		break;
	case CTS_VALUE_NICKNAME:
		retvm_if(CTS_NICKNAME_VAL_NAME_STR != field, CTS_ERR_ARG_INVALID, "Not supported field");
		if (value->embedded)
			FREEandSTRDUP(((cts_nickname *)value)->nick, str);
		else
			((cts_nickname *)value)->nick = str;
		break;
	case CTS_VALUE_ADDRESSBOOK:
		retvm_if(CTS_ADDRESSBOOK_VAL_NAME_STR != field, CTS_ERR_ARG_INVALID,
				"Not supported field");
		if (value->embedded)
			FREEandSTRDUP(((cts_addrbook *)value)->name, str);
		else
			((cts_addrbook *)value)->name = str;
		break;
	case CTS_VALUE_EVENT:
		/* evet value doesn't have string value */
	default:
		ERR("The value has unsupported type");
		return CTS_ERR_ARG_INVALID;
	}

	return CTS_SUCCESS;
}