include/Common/Common_Define.h

   1 /*
   2  * oma-ds-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JuHak Park <juhaki.park@samsung.com>,
   7  *          JuneHyuk Lee <junhyuk7.lee@samsung.com>,
   8  *          SunBong Ha <sunbong.ha@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  * http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24
  25
  26
  27
  28 /*
  29  * For any sort of issue you concern as to this software,
  30  * you may use following point of contact.
  31  * All resources contributed on this software
  32  * are orinigally written by S-Core Inc., a member of Samsung Group.
  33  *
  34  * SeongWon Shim <seongwon.shim@samsung.com>
  35  */
  36
  37 /**
  38  *   @Common_Define.h
  39  *   @version                                                                   0.1
  40  *   @brief                                                                             This file is the header file of interface for common structure
  41  */
  42
  43 #ifndef COMMON_DEFINE_H_
  44 #define COMMON_DEFINE_H_
  45
  46 #include "Common_Define_Internal.h"
  47
  48 /**
  49  * @par Description: API to create DatastoreInfo structure
  50  *
  51  *
  52  * @par Purpose:
  53  * @par Typical use case:
  54  * @par Method of function operation:
  55  * @par Important notes:
  56  * @param[in]           string type, target uri
  57  * @param[in]           string type, source uri
  58  * @param[out]          Status structure
  59  *
  60  * @return                              DatastoreInfo on success
  61  *                                                      NULL on error
  62  *
  63  * @par Errors:
  64  *
  65  * @pre None.
  66  * @post
  67  * @see
  68  * @remarks None.
  69  *
  70  * @par Sample Code:
  71  * @code
  72  * @endcode
  73  */
  74 DatastoreInfo *create_datastoreinfo(char *target, char *source);
  75
  76
  77 /**
  78  * @par Description: API to free list of DatastoreInfo structure
  79  *
  80  *
  81  * @par Purpose:
  82  * @par Typical use case:
  83  * @par Method of function operation:
  84  * @par Important notes:
  85  * @param[in]           list of DatastoreInfo structure
  86  * @param[out]
  87  *
  88  * @return
  89  *
  90  * @par Errors:
  91  *
  92  * @pre None.
  93  * @post
  94  * @see
  95  * @remarks None.
  96  *
  97  * @par Sample Code:
  98  * @code
  99  * @endcode
 100  */
 101 void free_datastoreinfos(GList *pDatastoreInfos);
 102
 103
 104 /**
 105  * @par Description: API to free DatastoreInfo structure
 106  *
 107  *
 108  * @par Purpose:
 109  * @par Typical use case:
 110  * @par Method of function operation:
 111  * @par Important notes:
 112  * @param[in]           DatastoreInfo structure
 113  * @param[out]
 114  *
 115  * @return
 116  *
 117  * @par Errors:
 118  *
 119  * @pre None.
 120  * @post
 121  * @see
 122  * @remarks None.
 123  *
 124  * @par Sample Code:
 125  * @code
 126  * @endcode
 127  */
 128 void free_datastoreinfo(DatastoreInfo *pDatastoreInfo);
 129
 130 /**
 131  * @par Description: API to set sync type in DatastoreInfo structure
 132  *
 133  *
 134  * @par Purpose:
 135  * @par Typical use case:
 136  * @par Method of function operation:
 137  * @par Important notes:
 138  * @param[in]           DatastoreInfo structure
 139  * @param[in]           enum type, sync type
 140  * @param[out]
 141  *
 142  * @return
 143  *
 144  * @par Errors:
 145  *
 146  * @pre None.
 147  * @post
 148  * @see
 149  * @remarks None.
 150  *
 151  * @par Sample Code:
 152  * @code
 153  * @endcode
 154  */
 155 void set_datastoreInfo_synctype(DatastoreInfo *datastoreInfo, AlertType syncType);
 156
 157 /**
 158  * @par Description: API to set last anchor in DatastoreInfo structure
 159  *
 160  *
 161  * @par Purpose:
 162  * @par Typical use case:
 163  * @par Method of function operation:
 164  * @par Important notes:
 165  * @param[in]           DatastoreInfo structure
 166  * @param[in]           string type, last anchor
 167  * @param[out]
 168  *
 169  * @return
 170  *
 171  * @par Errors:
 172  *
 173  * @pre None.
 174  * @post
 175  * @see
 176  * @remarks None.
 177  *
 178  * @par Sample Code:
 179  * @code
 180  * @endcode
 181  */
 182 void set_datastoreinfo_lastanchor(DatastoreInfo *datastoreInfo, char *lastAnchor);
 183
 184 /**
 185  * @par Description: API to set next anchor in DatastoreInfo structure
 186  *
 187  *
 188  * @par Purpose:
 189  * @par Typical use case:
 190  * @par Method of function operation:
 191  * @par Important notes:
 192  * @param[in]           DatastoreInfo structure
 193  * @param[in]           string type, next anchor
 194  * @param[out]
 195  *
 196  * @return
 197  *
 198  * @par Errors:
 199  *
 200  * @pre None.
 201  * @post
 202  * @see
 203  * @remarks None.
 204  *
 205  * @par Sample Code:
 206  * @code
 207  * @endcode
 208  */
 209 void set_datastoreinfo_nextanchor(DatastoreInfo *datastoreInfo, char *nextAnchor);
 210
 211 /**
 212  * @par Description: API to set maxobjsize in DatastoreInfo structure
 213  *
 214  *
 215  * @par Purpose:
 216  * @par Typical use case:
 217  * @par Method of function operation:
 218  * @par Important notes:
 219  * @param[in]           DatastoreInfo structure
 220  * @param[in]           unsigned int, maxobjsize
 221  * @param[out]
 222  *
 223  * @return
 224  *
 225  * @par Errors:
 226  *
 227  * @pre None.
 228  * @post
 229  * @see
 230  * @remarks None.
 231  *
 232  * @par Sample Code:
 233  * @code
 234  * @endcode
 235  */
 236 void set_datastoreinfo_maxobjsize(DatastoreInfo *datastoreInfo, unsigned int maxObjSize);
 237
 238 /**
 239  * @par Description: API to create ChangedItem structure
 240  *
 241  *
 242  * @par Purpose:
 243  * @par Typical use case:
 244  * @par Method of function operation:
 245  * @par Important notes:
 246  * @param[in]           enum type, change type of item
 247  * @param[in]           string type, luid of item
 248  * @param[out]
 249  *
 250  * @return                              ChangedItem on success
 251  *                                                      NULL on error
 252  *
 253  * @par Errors:
 254  *
 255  * @pre None.
 256  * @post
 257  * @see
 258  * @remarks None.
 259  *
 260  * @par Sample Code:
 261  * @code
 262  * @endcode
 263  */
 264 ChangedItem *create_changeditem(ChangeType type, char *luid);
 265
 266 /**
 267  * @par Description: API to free ChangedItem structure
 268  *
 269  *
 270  * @par Purpose:
 271  * @par Typical use case:
 272  * @par Method of function operation:
 273  * @par Important notes:
 274  * @param[in]           ChangedItem structure
 275  * @param[out]
 276  *
 277  * @return
 278  *
 279  * @par Errors:
 280  *
 281  * @pre None.
 282  * @post
 283  * @see
 284  * @remarks None.
 285  *
 286  * @par Sample Code:
 287  * @code
 288  * @endcode
 289  */
 290 void free_changeditem(ChangedItem *pChangedItem);
 291
 292
 293 /**
 294  * @par Description: API to set content type in ChangedItem structure
 295  *
 296  *
 297  * @par Purpose:
 298  * @par Typical use case:
 299  * @par Method of function operation:
 300  * @par Important notes:
 301  * @param[in]           ChangedItem structure
 302  * @param[in]           string type, content type
 303  * @param[out]
 304  *
 305  * @return
 306  *
 307  * @par Errors:
 308  *
 309  * @pre None.
 310  * @post
 311  * @see
 312  * @remarks None.
 313  *
 314  * @par Sample Code:
 315  * @code
 316  * @endcode
 317  */
 318 void set_changeditem_contenttype(ChangedItem *pChangedItem, char *content_type);
 319
 320 /**
 321  * @par Description: API to set data in ChangedItem structure
 322  *
 323  *
 324  * @par Purpose:
 325  * @par Typical use case:
 326  * @par Method of function operation:
 327  * @par Important notes:
 328  * @param[in]           ChangedItem structure
 329  * @param[in]           string type, data
 330  * @param[out]
 331  *
 332  * @return
 333  *
 334  * @par Errors:
 335  *
 336  * @pre None.
 337  * @post
 338  * @see
 339  * @remarks None.
 340  *
 341  * @par Sample Code:
 342  * @code
 343  * @endcode
 344  */
 345 void set_changeditem_data(ChangedItem *changedItem, char *data);
 346
 347 /**
 348  * @par Description: API to set in ChangedItem structure
 349  *
 350  *
 351  * @par Purpose:
 352  * @par Typical use case:
 353  * @par Method of function operation:
 354  * @par Important notes:
 355  * @param[in]           ChangedItem structure
 356  * @param[in]           datastore index(0=contacts, 1=calendar, 2= memo)
 357  * @param[out]
 358  *
 359  * @return
 360  *
 361  * @par Errors:
 362  *
 363  * @pre None.
 364  * @post
 365  * @see
 366  * @remarks None.
 367  *
 368  * @par Sample Code:
 369  * @code
 370  * @endcode
 371  */
 372 void set_changedItem_indexofdatastore(ChangedItem *changedItem, unsigned int indexOfDatastore);
 373
 374 /**
 375  * @par Description: API to create ChangedDatastore structure
 376  *
 377  *
 378  * @par Purpose:
 379  * @par Typical use case:
 380  * @par Method of function operation:
 381  * @par Important notes:
 382  * @param[in]           string type, source uri
 383  * @param[in]           string type, target uri
 384  * @param[in]           int type, has numberOfChanges or not
 385  * @param[in]           unsigned int type, if numberOfChanges is true set count else set zero
 386  * @param[out]
 387  *
 388  * @return                              ChangedDatastore on success
 389  *                                                      NULL on error
 390  *
 391  * @par Errors:
 392  *
 393  * @pre None.
 394  * @post
 395  * @see
 396  * @remarks None.
 397  *
 398  * @par Sample Code:
 399  * @code
 400  * @endcode
 401  */
 402 ChangedDatastore *create_changeddatastore(char *source, char *target, int hasNumberOfChanges, unsigned int numberOfChanges);
 403
 404 /**
 405  * @par Description: API to free list of ChangedDatastore
 406  *
 407  *
 408  * @par Purpose:
 409  * @par Typical use case:
 410  * @par Method of function operation:
 411  * @par Important notes:
 412  * @param[in]           list of ChangedDatastore
 413  * @param[out]
 414  *
 415  * @return
 416  *
 417  * @par Errors:
 418  *
 419  * @pre None.
 420  * @post
 421  * @see
 422  * @remarks None.
 423  *
 424  * @par Sample Code:
 425  * @code
 426  * @endcode
 427  */
 428 void free_changeddatastores(GList *pChangedDatastores);
 429
 430 /**
 431  * @par Description: API to free ChangedDatastore structure
 432  *
 433  *
 434  * @par Purpose:
 435  * @par Typical use case:
 436  * @par Method of function operation:
 437  * @par Important notes:
 438  * @param[in]           ChangedDatastore structure
 439  * @param[out]
 440  *
 441  * @return
 442  *
 443  * @par Errors:
 444  *
 445  * @pre None.
 446  * @post
 447  * @see
 448  * @remarks None.
 449  *
 450  * @par Sample Code:
 451  * @code
 452  * @endcode
 453  */
 454 void free_changeddatastore(ChangedDatastore *pChangedDatastore);
 455
 456 /**
 457  * @par Description: API to set changedItem in ChangedDatastore structure
 458  *
 459  *
 460  * @par Purpose:
 461  * @par Typical use case:
 462  * @par Method of function operation:
 463  * @par Important notes:
 464  * @param[in]           ChangedDatastore structure
 465  * @param[in]           list of ChangedItem structure
 466  * @param[out]
 467  *
 468  * @return
 469  *
 470  * @par Errors:
 471  *
 472  * @pre None.
 473  * @post
 474  * @see
 475  * @remarks None.
 476  *
 477  * @par Sample Code:
 478  * @code
 479  * @endcode
 480  */
 481 void set_changeddatastore_changeditem(ChangedDatastore *changedDatastore, GList *changedItem);
 482
 483 /**
 484  * @par Description: API to add changedItem in ChangedDatastore structure
 485  *
 486  *
 487  * @par Purpose:
 488  * @par Typical use case:
 489  * @par Method of function operation:
 490  * @par Important notes:
 491  * @param[in]           ChangedDatastore structure
 492  * @param[in]           ChangedItem structure
 493  * @param[out]
 494  *
 495  * @return
 496  *
 497  * @par Errors:
 498  *
 499  * @pre None.
 500  * @post
 501  * @see
 502  * @remarks None.
 503  *
 504  * @par Sample Code:
 505  * @code
 506  * @endcode
 507  */
 508 void add_changeddatastore_changeditem(ChangedDatastore *changedDatastore, ChangedItem *changedItem);
 509
 510 /**
 511  * @par Description: API to create AppliedStatus structure
 512  *
 513  *
 514  * @par Purpose:
 515  * @par Typical use case:
 516  * @par Method of function operation:
 517  * @par Important notes:
 518  * @param[in]           string type, luid of item
 519  * @param[in]           enum type, change type( CHANGE_ADD , CHANGE_REPLACE , CHANGE_DELETE)
 520  * @param[in]           int type, status code(200....)
 521  * @param[out]
 522  *
 523  * @return                              AppliedStatus on success
 524  *                                                      NULL on error
 525  *
 526  * @par Errors:
 527  *
 528  * @pre None.
 529  * @post
 530  * @see
 531  * @remarks None.
 532  *
 533  * @par Sample Code:
 534  * @code
 535  * @endcode
 536  */
 537 AppliedStatus *create_appliedstatus(char *luid, ChangeType changeType, int status);
 538
 539 /**
 540  * @par Description: API to free list of AppliedStatus structure
 541  *
 542  *
 543  * @par Purpose:
 544  * @par Typical use case:
 545  * @par Method of function operation:
 546  * @par Important notes:
 547  * @param[in]           list of AppliedStatus structure
 548  * @param[out]
 549  *
 550  * @return
 551  *
 552  * @par Errors:
 553  *
 554  * @pre None.
 555  * @post
 556  * @see
 557  * @remarks None.
 558  *
 559  * @par Sample Code:
 560  * @code
 561  * @endcode
 562  */
 563 void free_appliedstatuses(GList *pAppliedStatuses);
 564
 565 /**
 566  * @par Description: API to free AppliedStatus structure
 567  *
 568  *
 569  * @par Purpose:
 570  * @par Typical use case:
 571  * @par Method of function operation:
 572  * @par Important notes:
 573  * @param[in]           AppliedStatus structure
 574  * @param[out]
 575  *
 576  * @return
 577  *
 578  * @par Errors:
 579  *
 580  * @pre None.
 581  * @post
 582  * @see
 583  * @remarks None.
 584  *
 585  * @par Sample Code:
 586  * @code
 587  * @endcode
 588  */
 589 void free_appliedstatus(AppliedStatus *pAppliedStatus);
 590
 591 /**
 592  * @par Description: API to create SendingStatus structure
 593  *
 594  *
 595  * @par Purpose:
 596  * @par Typical use case:
 597  * @par Method of function operation:
 598  * @par Important notes:
 599  * @param[in]           source uri
 600  * @param[in]           target uri
 601  * @param[out]
 602  *
 603  * @return                              SendingStatus on success
 604  *                                                      NULL on error
 605  *
 606  * @par Errors:
 607  *
 608  * @pre None.
 609  * @post
 610  * @see
 611  * @remarks None.
 612  *
 613  * @par Sample Code:
 614  * @code
 615  * @endcode
 616  */
 617 SendingStatus *create_sendingstatus(char *source, char *target);
 618
 619 /**
 620  * @par Description: API to free list of SendingStatus structure
 621  *
 622  *
 623  * @par Purpose:
 624  * @par Typical use case:
 625  * @par Method of function operation:
 626  * @par Important notes:
 627  * @param[in]           list of SendingStatus structure
 628  * @param[out]
 629  *
 630  * @return
 631  *
 632  * @par Errors:
 633  *
 634  * @pre None.
 635  * @post
 636  * @see
 637  * @remarks None.
 638  *
 639  * @par Sample Code:
 640  * @code
 641  * @endcode
 642  */
 643 void free_sendingstatuses(GList *pSendingStatuses);
 644
 645 /**
 646  * @par Description: API to free SendingStatus structure
 647  *
 648  *
 649  * @par Purpose:
 650  * @par Typical use case:
 651  * @par Method of function operation:
 652  * @par Important notes:
 653  * @param[in]           SendingStatus structure
 654  * @param[out]
 655  *
 656  * @return
 657  *
 658  * @par Errors:
 659  *
 660  * @pre None.
 661  * @post
 662  * @see
 663  * @remarks None.
 664  *
 665  * @par Sample Code:
 666  * @code
 667  * @endcode
 668  */
 669 void free_sendingstatus(SendingStatus *pSendingStatus);
 670
 671 /**
 672  * @par Description: API to add AppliedStatus in SendingStatus structure
 673  *
 674  *
 675  * @par Purpose:
 676  * @par Typical use case:
 677  * @par Method of function operation:
 678  * @par Important notes:
 679  * @param[in]           SendingStatus structure
 680  * @param[in]           AppliedStatus structure
 681  * @param[out]
 682  *
 683  * @return
 684  *
 685  * @par Errors:
 686  *
 687  * @pre None.
 688  * @post
 689  * @see
 690  * @remarks None.
 691  *
 692  * @par Sample Code:
 693  * @code
 694  * @endcode
 695  */
 696 void add_sendingstatus_appliedstatus(SendingStatus *sendingStatus, AppliedStatus *appliedStatus);
 697
 698 /**
 699  * @par Description: API to create Datastore structure
 700  *
 701  *
 702  * @par Purpose:
 703  * @par Typical use case:
 704  * @par Method of function operation:
 705  * @par Important notes:
 706  * @param[in]           string type, target uri
 707  * @param[in]           string type, source uri
 708  * @param[out]
 709  *
 710  * @return                              Datastore on success
 711  *                                                      NULL on error
 712  *
 713  * @par Errors:
 714  *
 715  * @pre None.
 716  * @post
 717  * @see
 718  * @remarks None.
 719  *
 720  * @par Sample Code:
 721  * @code
 722  * @endcode
 723  */
 724 Datastore *create_datastore(char *target, char *source);
 725
 726 /**
 727  * @par Description: API to set content type infomation in Datastore structure
 728  *
 729  *
 730  * @par Purpose:
 731  * @par Typical use case:
 732  * @par Method of function operation:
 733  * @par Important notes:
 734  * @param[in]           Datastore structure
 735  * @param[in]           int type, datastore_id(TYPE_CONTACT, TYPE_CALENDAR, TYPE_MEMO)
 736  * @param[in]           int type, folder_type_id(9, 8, 10)
 737  * @param[out]
 738  *
 739  * @return
 740  *
 741  * @par Errors:
 742  *
 743  * @pre None.
 744  * @post
 745  * @see
 746  * @remarks None.
 747  *
 748  * @par Sample Code:
 749  * @code
 750  * @endcode
 751  */
 752 void set_datastore_contenttype_info(Datastore *datastore, int datastore_id, int folder_type_id);
 753
 754 /**
 755  * @par Description: API to set account information in Datastore structure
 756  *
 757  *
 758  * @par Purpose:
 759  * @par Typical use case:
 760  * @par Method of function operation:
 761  * @par Important notes:
 762  * @param[in]           Datastore structure
 763  * @param[in]           string type, account_id
 764  * @param[in]           string type, account_pw
 765  * @param[out]
 766  *
 767  * @return
 768  *
 769  * @par Errors:
 770  *
 771  * @pre None.
 772  * @post
 773  * @see
 774  * @remarks None.
 775  *
 776  * @par Sample Code:
 777  * @code
 778  * @endcode
 779  */
 780 void set_datastore_account_info(Datastore *datastore, char *account_id, char *account_pw);
 781
 782 /**
 783  * @par Description: API to set client sync type in Datastore structure
 784  *
 785  *
 786  * @par Purpose:
 787  * @par Typical use case:
 788  * @par Method of function operation:
 789  * @par Important notes:
 790  * @param[in]           Datastore structure
 791  * @param[in]           enum type, sync type
 792  * @param[out]
 793  *
 794  * @return
 795  *
 796  * @par Errors:
 797  *
 798  * @pre None.
 799  * @post
 800  * @see
 801  * @remarks None.
 802  *
 803  * @par Sample Code:
 804  * @code
 805  * @endcode
 806  */
 807 void set_datastore_client_sync_type(Datastore *datastore, AlertType syncType);
 808
 809 /**
 810  * @par Description: API to set server sync type in Datastore structure
 811  *
 812  *
 813  * @par Purpose:
 814  * @par Typical use case:
 815  * @par Method of function operation:
 816  * @par Important notes:
 817  * @param[in]           Datastore structure
 818  * @param[in]           enum type, sync type
 819  * @param[out]
 820  *
 821  * @return
 822  *
 823  * @par Errors:
 824  *
 825  * @pre None.
 826  * @post
 827  * @see
 828  * @remarks None.
 829  *
 830  * @par Sample Code:
 831  * @code
 832  * @endcode
 833  */
 834 void set_datastore_server_sync_type(Datastore *datastore, AlertType syncType);
 835
 836
 837 /**
 838  * @par Description: API to set client anchor in Datastore structure
 839  *
 840  *
 841  * @par Purpose:
 842  * @par Typical use case:
 843  * @par Method of function operation:
 844  * @par Important notes:
 845  * @param[in]           Datastore structure
 846  * @param[in]           string type, last anchor
 847  * @param[in]           string type, next anchor
 848  * @param[out]
 849  *
 850  * @return
 851  *
 852  * @par Errors:
 853  *
 854  * @pre None.
 855  * @post
 856  * @see
 857  * @remarks None.
 858  *
 859  * @par Sample Code:
 860  * @code
 861  * @endcode
 862  */
 863 void set_datastore_client_anchor(Datastore *datastore, char *lastAnchor, char *nextAnchor);
 864
 865 /**
 866  * @par Description: API to set client anchor in Datastore structure
 867  *
 868  *
 869  * @par Purpose:
 870  * @par Typical use case:
 871  * @par Method of function operation:
 872  * @par Important notes:
 873  * @param[in]           Datastore structure
 874  * @param[in]           string type, last anchor
 875  * @param[in]           string type, next anchor
 876  * @param[out]
 877  *
 878  * @return
 879  *
 880  * @par Errors:
 881  *
 882  * @pre None.
 883  * @post
 884  * @see
 885  * @remarks None.
 886  *
 887  * @par Sample Code:
 888  * @code
 889  * @endcode
 890  */
 891 void set_datastore_server_anchor(Datastore *datastore, char *lastAnchor, char *nextAnchor);
 892
 893 /**
 894  * @par Description: API to create SyncResult structure
 895  *
 896  *
 897  * @par Purpose:
 898  * @par Typical use case:
 899  * @par Method of function operation:
 900  * @par Important notes:
 901  * @param[in]           Datastore structure
 902  * @param[in]           string type, last anchor
 903  * @param[in]           string type, next anchor
 904  * @param[out]
 905  *
 906  * @return                              SyncResult on success
 907  *                                                      NULL on error
 908  *
 909  * @par Errors:
 910  *
 911  * @pre None.
 912  * @post
 913  * @see
 914  * @remarks None.
 915  *
 916  * @par Sample Code:
 917  * @code
 918  * @endcode
 919  */
 920 SyncResult *create_sync_result();
 921
 922 /**
 923  * @par Description: API to duplicate SyncResult structure
 924  *
 925  *
 926  * @par Purpose:
 927  * @par Typical use case:
 928  * @par Method of function operation:
 929  * @par Important notes:
 930  * @param[in]           SyncResult structure
 931  * @param[out]
 932  *
 933  * @return                              SyncResult on success
 934  *                                                      NULL on error
 935  *
 936  * @par Errors:
 937  *
 938  * @pre None.
 939  * @post
 940  * @see
 941  * @remarks None.
 942  *
 943  * @par Sample Code:
 944  * @code
 945  * @endcode
 946  */
 947 SyncResult *dup_syncresult(SyncResult *orgSyncResult);
 948
 949 /**
 950  * @par Description: API to set number of total item in SyncResult structure
 951  *
 952  *
 953  * @par Purpose:
 954  * @par Typical use case:
 955  * @par Method of function operation:
 956  * @par Important notes:
 957  * @param[in]           SyncResult structure
 958  * @param[in]           number of total item
 959  * @param[out]
 960  *
 961  * @return
 962  *
 963  * @par Errors:
 964  *
 965  * @pre None.
 966  * @post
 967  * @see
 968  * @remarks None.
 969  *
 970  * @par Sample Code:
 971  * @code
 972  * @endcode
 973  */
 974 void set_numberofchange(SyncResult *syncResult, unsigned int numberOfChange);
 975
 976 /**
 977  * @par Description: API to set number of received item in SyncResult structure
 978  *
 979  *
 980  * @par Purpose:
 981  * @par Typical use case:
 982  * @par Method of function operation:
 983  * @par Important notes:
 984  * @param[in]           SyncResult structure
 985  * @param[in]           number of received item
 986  * @param[out]
 987  *
 988  * @return
 989  *
 990  * @par Errors:
 991  *
 992  * @pre None.
 993  * @post
 994  * @see
 995  * @remarks None.
 996  *
 997  * @par Sample Code:
 998  * @code
 999  * @endcode
1000  */
1001 void add_receive_count(SyncResult *syncResult, unsigned int received_count);
1002
1003 /**
1004  * @par Description: API to set number of add item in SyncResult structure
1005  *
1006  *
1007  * @par Purpose:
1008  * @par Typical use case:
1009  * @par Method of function operation:
1010  * @par Important notes:
1011  * @param[in]           SyncResult structure
1012  * @param[in]           number of add item
1013  * @param[out]
1014  *
1015  * @return
1016  *
1017  * @par Errors:
1018  *
1019  * @pre None.
1020  * @post
1021  * @see
1022  * @remarks None.
1023  *
1024  * @par Sample Code:
1025  * @code
1026  * @endcode
1027  */
1028 void add_add_count(SyncResult *syncResult, unsigned int add_cnt);
1029
1030 /**
1031  * @par Description: API to set number of replace item in SyncResult structure
1032  *
1033  *
1034  * @par Purpose:
1035  * @par Typical use case:
1036  * @par Method of function operation:
1037  * @par Important notes:
1038  * @param[in]           SyncResult structure
1039  * @param[in]           number of replace item
1040  * @param[out]
1041  *
1042  * @return
1043  *
1044  * @par Errors:
1045  *
1046  * @pre None.
1047  * @post
1048  * @see
1049  * @remarks None.
1050  *
1051  * @par Sample Code:
1052  * @code
1053  * @endcode
1054  */
1055 void add_replace_count(SyncResult *syncResult, unsigned int replace_cnt);
1056
1057 /**
1058  * @par Description: API to set number of delete item in SyncResult structure
1059  *
1060  *
1061  * @par Purpose:
1062  * @par Typical use case:
1063  * @par Method of function operation:
1064  * @par Important notes:
1065  * @param[in]           SyncResult structure
1066  * @param[in]           number of delete item
1067  * @param[out]
1068  *
1069  * @return
1070  *
1071  * @par Errors:
1072  *
1073  * @pre None.
1074  * @post
1075  * @see
1076  * @remarks None.
1077  *
1078  * @par Sample Code:
1079  * @code
1080  * @endcode
1081  */
1082 void add_delete_count(SyncResult *syncResult, unsigned int delete_cnt);
1083
1084 /**
1085  * @par Description: API to free PreSyncReturnObj structure
1086  *
1087  *
1088  * @par Purpose:
1089  * @par Typical use case:
1090  * @par Method of function operation:
1091  * @par Important notes:
1092  * @param[in]           PreSyncReturnObj structure
1093  * @param[out]
1094  *
1095  * @return
1096  *
1097  * @par Errors:
1098  *
1099  * @pre None.
1100  * @post
1101  * @see
1102  * @remarks None.
1103  *
1104  * @par Sample Code:
1105  * @code
1106  * @endcode
1107  */
1108 void free_presyncreturnobj(PreSyncReturnObj *pPreSyncReturnObj);
1109
1110 /**
1111  * @par Description: API to free SyncObj structure
1112  *
1113  *
1114  * @par Purpose:
1115  * @par Typical use case:
1116  * @par Method of function operation:
1117  * @par Important notes:
1118  * @param[in]           SyncObj structure
1119  * @param[out]
1120  *
1121  * @return
1122  *
1123  * @par Errors:
1124  *
1125  * @pre None.
1126  * @post
1127  * @see
1128  * @remarks None.
1129  *
1130  * @par Sample Code:
1131  * @code
1132  * @endcode
1133  */
1134 void free_syncobj(SyncObj *pSyncObj);
1135
1136 /**
1137  * @par Description: API to free SyncReturnObj structure
1138  *
1139  *
1140  * @par Purpose:
1141  * @par Typical use case:
1142  * @par Method of function operation:
1143  * @par Important notes:
1144  * @param[in]           SyncReturnObj structure
1145  * @param[out]
1146  *
1147  * @return
1148  *
1149  * @par Errors:
1150  *
1151  * @pre None.
1152  * @post
1153  * @see
1154  * @remarks None.
1155  *
1156  * @par Sample Code:
1157  * @code
1158  * @endcode
1159  */
1160 void free_syncreturnobj(SyncReturnObj *pSyncReturnObj);
1161
1162 /**
1163  * @par Description: API to free Datastore structure
1164  *
1165  *
1166  * @par Purpose:
1167  * @par Typical use case:
1168  * @par Method of function operation:
1169  * @par Important notes:
1170  * @param[in]           Datastore structure
1171  * @param[out]
1172  *
1173  * @return
1174  *
1175  * @par Errors:
1176  *
1177  * @pre None.
1178  * @post
1179  * @see
1180  * @remarks None.
1181  *
1182  * @par Sample Code:
1183  * @code
1184  * @endcode
1185  */
1186 void free_datastore(Datastore *pDatastore);
1187
1188
1189 #endif /* COMMON_DEFINE_H_ */