00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "engine.h"
00022 #include "engine_internals.h"
00023
00031
00032 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00033 OSyncMappingTable *osengine_mappingtable_new(OSyncEngine *engine)
00034 {
00035 osync_trace(TRACE_ENTRY, "osengine_mappingtable_new(%p)", engine);
00036 OSyncMappingTable *table = g_malloc0(sizeof(OSyncMappingTable));
00037 table->engine = engine;
00038 table->group = engine->group;
00039
00040 GList *c;
00041 for (c = engine->clients; c; c = c->next) {
00042 OSyncClient *client = c->data;
00043 osengine_mappingview_new(table, client);
00044 }
00045
00046 osync_trace(TRACE_EXIT, "osengine_mappingtable_new: %p", table);
00047 return table;
00048 }
00049
00050 void osengine_mappingtable_reset(OSyncMappingTable *table)
00051 {
00052 GList *v;
00053 for (v = table->views; v; v = v->next) {
00054 OSyncMappingView *view = v->data;
00055 osengine_mappingview_reset(view);
00056 }
00057 }
00058
00059 void osengine_mappingtable_free(OSyncMappingTable *table)
00060 {
00061 osync_trace(TRACE_ENTRY, "osengine_mappingtable_free(%p)", table);
00062 GList *c = NULL;
00063 GList *m = NULL;
00064
00065 GList *mappings = g_list_copy(table->mappings);
00066 GList *unmapped = g_list_copy(table->unmapped);
00067 GList *views = g_list_copy(table->views);
00068 osync_trace(TRACE_INTERNAL, "Free mappings");
00069 for (m = mappings; m; m = m->next) {
00070 OSyncMapping *mapping = m->data;
00071 osengine_mapping_free(mapping);
00072 }
00073 osync_trace(TRACE_INTERNAL, "Free unmapped");
00074 for (c = unmapped; c; c = c->next) {
00075 OSyncMappingEntry *entry = c->data;
00076 osengine_mappingentry_free(entry);
00077 }
00078 for (c = views; c; c = c->next) {
00079 OSyncMappingView *view = c->data;
00080 osengine_mappingview_free(view);
00081 }
00082 g_list_free(mappings);
00083 g_list_free(unmapped);
00084 g_list_free(views);
00085 g_free(table);
00086 osync_trace(TRACE_EXIT, "osengine_mappingtable_free");
00087 }
00088
00089 OSyncMappingEntry *osengine_mappingtable_find_entry(OSyncMappingTable *table, const char *uid, const char *objtype, long long int memberid)
00090 {
00091 osync_trace(TRACE_ENTRY, "%s(%p, %s, %s)", __func__, table, uid, objtype ? objtype : "None");
00092 GList *v;
00093 int count_of_entries = 0;
00094 OSyncMappingEntry *ret_entry = NULL;
00095 for (v = table->views; v; v = v->next) {
00096 OSyncMappingView *view = v->data;
00097 GList *c;
00098
00099 if (memberid && memberid != osync_member_get_id(view->client->member))
00100 continue;
00101
00102 for (c = view->changes; c; c = c->next) {
00103 OSyncMappingEntry *entry = c->data;
00104 g_assert(entry->change);
00105 if(objtype){
00106 if ( (!strcmp(
00107 osync_change_get_uid(entry->change), uid)) &&
00108 (!strcmp(
00109 osync_objtype_get_name(
00110 osync_change_get_objtype(entry->change))
00111 , objtype))
00112 ) {
00113 ret_entry = entry;
00114 count_of_entries++;
00115 }
00116 } else {
00117 if (!strcmp(osync_change_get_uid(entry->change), uid)) {
00118 ret_entry = entry;
00119 count_of_entries++;
00120 }
00121 }
00122 }
00123 }
00124 if(count_of_entries == 1 && ret_entry){
00125 osync_trace(TRACE_EXIT, "%s: %p", __func__, ret_entry);
00126 return ret_entry;
00127 }
00128 if(count_of_entries >1){
00129 if (!objtype)
00130 {
00131 osync_trace(TRACE_EXIT_ERROR, "%s: possible dataloss", __func__ );
00132 } else {
00133 osync_trace(TRACE_EXIT_ERROR, "%s: changes.db corrupted", __func__ );
00134 }
00135 return NULL;
00136 }
00137
00138 osync_trace(TRACE_EXIT, "%s: Not Found", __func__);
00139 return NULL;
00140 }
00141
00142 OSyncMappingEntry *osengine_mappingtable_store_change(OSyncMappingTable *table, OSyncChange *change)
00143 {
00144 osync_trace(TRACE_ENTRY, "osengine_mappingtable_store_change(%p, %p)", table, change);
00145 OSyncMappingView *view = osengine_mappingtable_find_view(table, osync_change_get_member(change));
00146 g_assert(view);
00147 OSyncMappingEntry *entry = osengine_mappingview_store_change(view, change);
00148 osync_trace(TRACE_EXIT, "osengine_mappingtable_store_change: %p", entry);
00149 return entry;
00150 }
00151
00152 OSyncMapping *osengine_mappingtable_find_mapping(OSyncMappingTable *table, OSyncChange *change)
00153 {
00154 GList *m;
00155 for (m = table->mappings; m; m = m->next) {
00156 OSyncMapping *mapping = m->data;
00157 if (osengine_mapping_find_entry(mapping, change, NULL))
00158 return mapping;
00159 }
00160 return NULL;
00161 }
00162
00163 OSyncMapping *osengine_mappingtable_mapping_from_id(OSyncMappingTable *table, long long int id)
00164 {
00165 GList *m;
00166 for (m = table->mappings; m; m = m->next) {
00167 OSyncMapping *mapping = m->data;
00168 if (mapping->id == id)
00169 return mapping;
00170 }
00171 return NULL;
00172 }
00173
00174 OSyncMappingView *osengine_mappingtable_find_view(OSyncMappingTable *table, OSyncMember *member)
00175 {
00176 GList *v;
00177 for (v = table->views; v; v = v->next) {
00178 OSyncMappingView *view = v->data;
00179 if (view->memberid == osync_member_get_id(member))
00180 return view;
00181 }
00182 return NULL;
00183 }
00184
00185 void osengine_mappingtable_add_mapping(OSyncMappingTable *table, OSyncMapping *mapping)
00186 {
00187 table->mappings = g_list_append(table->mappings, mapping);
00188 mapping->table = table;
00189 }
00190
00191 osync_bool osengine_mappingtable_load(OSyncMappingTable *table, OSyncError **error)
00192 {
00193 osync_trace(TRACE_ENTRY, "osengine_mappingtable_load(%p, %p)", table, error);
00194 OSyncChange **changes = NULL;
00195 if (!osync_changes_load(table->group, &changes, error)) {
00196 osync_trace(TRACE_EXIT_ERROR, "osengine_mappingtable_load: %s", osync_error_print(error));
00197 return FALSE;
00198 }
00199
00200 int i = 0;
00201 OSyncChange *change = NULL;
00202 OSyncMapping *mapping = NULL;
00203 while ((change = changes[i])) {
00204 OSyncMappingEntry *entry = osengine_mappingentry_new(NULL);
00205 entry->change = change;
00206
00207 entry->client = (OSyncClient *)osync_member_get_data(osync_change_get_member(change));
00208
00209 if (!osync_change_get_mappingid(change)) {
00210 table->unmapped = g_list_append(table->unmapped, entry);
00211 } else {
00212 if (!mapping || mapping->id != osync_change_get_mappingid(change)) {
00213 mapping = osengine_mapping_new(table);
00214 mapping->id = osync_change_get_mappingid(change);
00215 }
00216 osengine_mapping_add_entry(mapping, entry);
00217 }
00218
00219 osync_flag_set(entry->fl_has_data);
00220
00221 OSyncMappingView *view = osengine_mappingtable_find_view(table, osync_change_get_member(change));
00222 if (view)
00223 osengine_mappingview_add_entry(view, entry);
00224
00225 i++;
00226 }
00227
00228 osync_trace(TRACE_EXIT, "osengine_mappingtable_load: TRUE");
00229 return TRUE;
00230 }
00231
00232 long long int osengine_mappingtable_get_next_id(OSyncMappingTable *table)
00233 {
00234 long long int new_id = 1;
00235 GList *m;
00236 for (m = table->mappings; m; m = m->next) {
00237 OSyncMapping *mapping = m->data;
00238 if (new_id <= mapping->id)
00239 new_id = mapping->id + 1;
00240 }
00241 return new_id;
00242 }
00243
00244 void osengine_mappingtable_inject_changes(OSyncMappingTable *table)
00245 {
00246 osync_trace(TRACE_ENTRY, "%s(%p)", __func__, table);
00247
00248
00249 char **uids = NULL;
00250 char **objtypes = NULL;
00251 long long int *memberids = NULL;
00252 int *types = NULL;
00253 char *uid = NULL;
00254 char *objtype = NULL;
00255 int type = 0;
00256 int i = 0;
00257 OSyncError *error = NULL;
00258 osync_group_open_changelog(table->engine->group, &uids, &objtypes, &memberids, &types, &error);
00259
00260 for (i = 0; (uid = uids[i]) ; i++) {
00261 type = types[i];
00262 objtype = objtypes[i];
00263 long long int memberid = memberids[i];
00264 OSyncMappingEntry *entry = osengine_mappingtable_find_entry(table, uid, objtype, memberid);
00265
00266 if (!entry) {
00267 osync_trace(TRACE_INTERNAL, "Mappingtable and changelog inconsistent: no entry with uid %s", uid);
00268
00269 g_assert_not_reached();
00270 }
00271
00272 osync_change_set_changetype(entry->change, type);
00273 osync_trace(TRACE_INTERNAL, "Injecting %p with changetype %i", entry, osync_change_get_changetype(entry->change));
00274 osync_flag_attach(entry->fl_read, table->engine->cmb_read_all);
00275
00276
00277 if (entry->mapping)
00278 osync_flag_set(entry->fl_mapped);
00279
00280
00281 }
00282
00283 osync_trace(TRACE_EXIT, "%s", __func__);
00284 }
00285
00286 OSyncMappingTable *_osengine_mappingtable_load_group(OSyncGroup *group)
00287 {
00288 OSyncMappingTable *table = g_malloc0(sizeof(OSyncMappingTable));
00289 table->group = group;
00290
00291 int i;
00292 for (i = 0; i < osync_group_num_members(group); i++) {
00293 OSyncMember *member = osync_group_nth_member(group, i);
00294 OSyncMappingView *view = g_malloc0(sizeof(OSyncMappingView));
00295 table->views = g_list_append(table->views, view);
00296 view->table = table;
00297 view->memberid = osync_member_get_id(member);
00298 }
00299
00300 if (!osengine_mappingtable_load(table, NULL))
00301 return NULL;
00302 return table;
00303 }
00304
00305 void osengine_mappingtable_close(OSyncMappingTable *table)
00306 {
00307 osync_changes_close(table->group);
00308
00309 }
00310
00311 OSyncMapping *osengine_mapping_new(OSyncMappingTable *table)
00312 {
00313 g_assert(table);
00314 OSyncMapping *mapping = g_malloc0(sizeof(OSyncMapping));
00315 osengine_mappingtable_add_mapping(table, mapping);
00316 if (table->engine) {
00317 mapping->fl_solved = osync_flag_new(NULL);
00318
00319 mapping->fl_chkconflict = osync_flag_new(NULL);
00320 osync_flag_set(mapping->fl_chkconflict);
00321
00322 mapping->fl_multiplied = osync_flag_new(NULL);
00323 osync_flag_set(mapping->fl_multiplied);
00324
00325 mapping->cmb_has_data = osync_comb_flag_new(FALSE, FALSE);
00326 osync_flag_set_pos_trigger(mapping->cmb_has_data, (OSyncFlagTriggerFunc)send_mapping_changed, table->engine, mapping);
00327
00328 mapping->cmb_has_info = osync_comb_flag_new(FALSE, FALSE);
00329
00330 mapping->cmb_synced = osync_comb_flag_new(FALSE, TRUE);
00331
00332 mapping->cmb_deleted = osync_comb_flag_new(FALSE, FALSE);
00333
00334 osync_flag_attach(mapping->cmb_synced, table->engine->cmb_synced);
00335 osync_flag_attach(mapping->fl_multiplied, table->engine->cmb_multiplied);
00336 osync_flag_attach(mapping->fl_chkconflict, table->engine->cmb_chkconflict);
00337 }
00338 osync_trace(TRACE_INTERNAL, "osengine_mapping_new(%p): %p", table, mapping);
00339 return mapping;
00340 }
00341
00342 void osengine_mapping_free(OSyncMapping *mapping)
00343 {
00344 osync_trace(TRACE_ENTRY, "osengine_mapping_free(%p)", mapping);
00345
00346 while (g_list_nth_data(mapping->entries, 0))
00347 osengine_mappingentry_free(g_list_nth_data(mapping->entries, 0));
00348
00349 osync_flag_detach(mapping->cmb_synced);
00350 osync_flag_detach(mapping->fl_chkconflict);
00351 osync_flag_detach(mapping->fl_multiplied);
00352
00353 mapping->table->mappings = g_list_remove(mapping->table->mappings, mapping);
00354 osync_flag_free(mapping->fl_solved);
00355 osync_flag_free(mapping->cmb_has_data);
00356 osync_flag_free(mapping->cmb_has_info);
00357 osync_flag_free(mapping->cmb_synced);
00358 osync_flag_free(mapping->fl_chkconflict);
00359 osync_flag_free(mapping->cmb_deleted);
00360 osync_flag_free(mapping->fl_multiplied);
00361
00362 g_free(mapping);
00363 osync_trace(TRACE_EXIT, "osengine_mapping_free");
00364 }
00365
00366 void osengine_mapping_add_entry(OSyncMapping *mapping, OSyncMappingEntry *entry)
00367 {
00368 osync_trace(TRACE_INTERNAL, "osengine_mapping_add_entry(%p, %p)", mapping, entry);
00369 g_assert(!osengine_mapping_find_entry(mapping, NULL, entry->view));
00370 mapping->entries = g_list_append(mapping->entries, entry);
00371 entry->mapping = mapping;
00372
00373 if (mapping->table->engine) {
00374 osync_flag_attach(entry->fl_has_data, mapping->cmb_has_data);
00375 osync_flag_attach(entry->fl_has_info, mapping->cmb_has_info);
00376 osync_flag_attach(entry->fl_synced, mapping->cmb_synced);
00377 osync_flag_attach(entry->fl_deleted, mapping->cmb_deleted);
00378 osync_flag_set_pos_trigger(entry->fl_dirty, (OSyncFlagTriggerFunc)send_mappingentry_changed, mapping->table->engine, entry);
00379 }
00380 osync_change_set_mappingid(entry->change, mapping->id);
00381
00382 mapping->table->unmapped = g_list_remove(mapping->table->unmapped, entry);
00383 mapping->table->entries = g_list_append(mapping->table->entries, entry);
00384 }
00385
00386 void osengine_mapping_remove_entry(OSyncMapping *mapping, OSyncMappingEntry *entry)
00387 {
00388 mapping->entries = g_list_remove(mapping->entries, entry);
00389 mapping->table->entries = g_list_remove(mapping->table->entries, entry);
00390 entry->mapping = NULL;
00391
00392 osync_flag_detach(entry->fl_has_data);
00393 osync_flag_detach(entry->fl_has_info);
00394 osync_flag_detach(entry->fl_synced);
00395 osync_flag_detach(entry->fl_deleted);
00396 }
00397
00398 OSyncMappingEntry *osengine_mapping_find_entry(OSyncMapping *mapping, OSyncChange *change, OSyncMappingView *view)
00399 {
00400 GList *e;
00401 for (e = mapping->entries; e; e = e->next) {
00402 OSyncMappingEntry *entry = e->data;
00403 if (change && entry->change == change)
00404 return entry;
00405 if (view && entry->view == view)
00406 return entry;
00407 }
00408 return NULL;
00409 }
00410
00411 OSyncMappingEntry *osengine_mapping_nth_entry(OSyncMapping *mapping, int nth)
00412 {
00413 return (OSyncMappingEntry *)g_list_nth_data(mapping->entries, nth);
00414 }
00415
00416 int osengine_mapping_num_changes(OSyncMapping *mapping)
00417 {
00418 return g_list_length(mapping->entries);
00419 }
00420
00421 OSyncChange *osengine_mapping_nth_change(OSyncMapping *mapping, int nth)
00422 {
00423 OSyncMappingEntry *entry = g_list_nth_data(mapping->entries, nth);
00424 if (!entry)
00425 return NULL;
00426 return entry->change;
00427 }
00428
00429 long long osengine_mapping_get_id(OSyncMapping *mapping)
00430 {
00431 return mapping->id;
00432 }
00433
00434 void osengine_mapping_reset(OSyncMapping *mapping)
00435 {
00436 osync_trace(TRACE_ENTRY, "osengine_mapping_reset(%p)", mapping);
00437 GList *e;
00438 for (e = mapping->entries; e; e = e->next) {
00439 OSyncMappingEntry *entry = e->data;
00440 osengine_mappingentry_reset(entry);
00441 }
00442
00443 osync_flag_set(mapping->fl_multiplied);
00444 osync_flag_set(mapping->fl_chkconflict);
00445 mapping->master = NULL;
00446 osync_trace(TRACE_EXIT, "osengine_mapping_reset");
00447 }
00448
00449 void osengine_mapping_delete(OSyncMapping *mapping)
00450 {
00451 osync_trace(TRACE_ENTRY, "osengine_mapping_delete(%p)", mapping);
00452 GList *entries = g_list_copy(mapping->entries);
00453 GList *c = NULL;
00454 for (c = entries; c; c = c->next) {
00455 OSyncMappingEntry *entry = c->data;
00456 osync_change_delete(entry->change, NULL);
00457 }
00458 g_list_free(entries);
00459 osengine_mapping_free(mapping);
00460 osync_trace(TRACE_EXIT, "osengine_mapping_delete");
00461 }
00462
00463 OSyncMappingView *osengine_mappingview_new(OSyncMappingTable *table, OSyncClient *client)
00464 {
00465 g_assert(table);
00466 OSyncMappingView *view = g_malloc0(sizeof(OSyncMappingView));
00467 table->views = g_list_append(table->views, view);
00468 view->client = client;
00469 view->table = table;
00470 view->memberid = osync_member_get_id(client->member);
00471 osync_trace(TRACE_INTERNAL, "osengine_mappingview_new(%p)", view);
00472 return view;
00473 }
00474
00475 void osengine_mappingview_free(OSyncMappingView *view)
00476 {
00477 osync_trace(TRACE_INTERNAL, "osengine_mappingview_free(%p)", view);
00478 g_list_free(view->changes);
00479 view->changes = NULL;
00480 g_free(view);
00481 }
00482
00483 void osengine_mappingview_add_entry(OSyncMappingView *view, OSyncMappingEntry *entry)
00484 {
00485 view->changes = g_list_append(view->changes, entry);
00486 entry->view = view;
00487 }
00488
00489 OSyncMappingEntry *osengine_mappingview_store_change(OSyncMappingView *view, OSyncChange *change)
00490 {
00491 osync_trace(TRACE_ENTRY, "osengine_mappingview_store_change(%p, %p)", view, change);
00492 g_assert(change);
00493 GList *c;
00494 for (c = view->changes; c; c = c->next) {
00495 OSyncMappingEntry *entry = c->data;
00496 g_assert(entry->change);
00497
00502 if (!strcmp(osync_change_get_uid(entry->change), osync_change_get_uid(change))) {
00503 OSyncObjType * entry_objtype = osync_change_get_objtype(entry->change);
00504 OSyncObjType * change_objtype = osync_change_get_objtype(change);
00505
00506 const char * entry_objtype_name = osync_objtype_get_name(entry_objtype);
00507 const char * change_objtype_name = osync_objtype_get_name(change_objtype);
00508
00509 if (
00510 (change_objtype_name == NULL) ||
00511 (entry_objtype_name == NULL) ||
00512 (!strcmp(change_objtype_name, entry_objtype_name)) ||
00513 (!strcmp(change_objtype_name, "data")) ||
00514 (!strcmp(entry_objtype_name, "data"))
00515 ) {
00516 osengine_mappingentry_update(entry, change);
00517 osync_trace(TRACE_EXIT, "osengine_mappingview_store_change: %p", entry);
00518 return entry;
00519 }
00520 }
00521
00522 }
00523
00524 OSyncMappingEntry *newentry = osengine_mappingentry_new(NULL);
00525 newentry->change = change;
00526 newentry->client = view->client;
00527 view->table->unmapped = g_list_append(view->table->unmapped, newentry);
00528 osengine_mappingview_add_entry(view, newentry);
00529 osync_trace(TRACE_EXIT, "osengine_mappingview_store_change: %p (New MappingEntry)", newentry);
00530 return newentry;
00531 }
00532
00533 osync_bool osengine_mappingview_uid_is_unique(OSyncMappingView *view, OSyncMappingEntry *entry, osync_bool spare_deleted)
00534 {
00535 GList *e = NULL;
00536
00537 for (e = view->changes; e; e = e->next) {
00538 OSyncMappingEntry *exentry = e->data;
00539 if ((exentry != entry) && (!spare_deleted || (osync_change_get_changetype(exentry->change) != CHANGE_DELETED)) && !strcmp(osync_change_get_uid(exentry->change), osync_change_get_uid(entry->change)))
00540 return FALSE;
00541 }
00542 return TRUE;
00543 }
00544
00545 void osengine_mappingview_reset(OSyncMappingView *view)
00546 {
00547
00548
00549 }
00550
00551 OSyncMappingEntry *osengine_mappingentry_new(OSyncMapping *mapping)
00552 {
00553 OSyncMappingEntry *entry = g_malloc0(sizeof(OSyncMappingEntry));
00554 osync_trace(TRACE_INTERNAL, "osengine_mappingentry_new(%p): %p", mapping, entry);
00555 entry->fl_has_data = osync_flag_new(NULL);
00556 entry->fl_dirty = osync_flag_new(NULL);
00557 entry->fl_mapped = osync_flag_new(NULL);
00558 entry->fl_has_info = osync_flag_new(NULL);
00559 entry->fl_synced = osync_flag_new(NULL);
00560 entry->fl_deleted = osync_flag_new(NULL);
00561 entry->fl_read = osync_flag_new(NULL);
00562 entry->fl_committed = osync_flag_new(NULL);
00563 osync_flag_set(entry->fl_synced);
00564
00565 if (mapping)
00566 osengine_mapping_add_entry(mapping, entry);
00567
00568 return entry;
00569 }
00570
00571 void osengine_mappingentry_free(OSyncMappingEntry *entry)
00572 {
00573 osync_trace(TRACE_INTERNAL, "osengine_mappingentry_free(%p)", entry);
00574
00575 if (entry->mapping)
00576 osengine_mapping_remove_entry(entry->mapping, entry);
00577
00578 osync_flag_free(entry->fl_has_data);
00579 osync_flag_free(entry->fl_dirty);
00580 osync_flag_free(entry->fl_mapped);
00581 osync_flag_free(entry->fl_has_info);
00582 osync_flag_free(entry->fl_synced);
00583 osync_flag_free(entry->fl_deleted);
00584 osync_flag_free(entry->fl_read);
00585 osync_flag_free(entry->fl_committed);
00586
00587 entry->view->changes = g_list_remove(entry->view->changes, entry);
00588 entry->view = NULL;
00589
00590 g_free(entry);
00591 }
00592
00593 void osengine_mappingentry_update(OSyncMappingEntry *entry, OSyncChange *change)
00594 {
00595 osync_trace(TRACE_ENTRY, "%s(%p, %p)", __func__, entry, change);
00596
00597 OSyncObjFormat *format = osync_change_get_objformat(entry->change);
00598 OSyncObjType *type = osync_change_get_objtype(entry->change);
00599
00600 osync_change_update(change, entry->change);
00601
00602 if (osync_change_get_changetype(change) == CHANGE_DELETED && format && type) {
00603 osync_change_set_objformat(entry->change, format);
00604 osync_change_set_objtype(entry->change, type);
00605
00606 osync_trace(TRACE_INTERNAL, "Change was deleted. Old objtype %s and format %s", osync_change_get_objtype(entry->change) ? osync_objtype_get_name(osync_change_get_objtype(entry->change)) : "None", osync_change_get_objformat(entry->change) ? osync_objformat_get_name(osync_change_get_objformat(entry->change)) : "None");
00607 }
00608
00609 osync_trace(TRACE_EXIT, "%s", __func__);
00610 }
00611
00612 OSyncMappingEntry *osengine_mappingentry_copy(OSyncMappingEntry *entry)
00613 {
00614 OSyncMappingEntry *newentry = osengine_mappingentry_new(NULL);
00615
00616 OSyncError *error = NULL;
00617 newentry->change = osync_change_copy(entry->change, &error);
00618 newentry->client = entry->client;
00619 osengine_mappingview_add_entry(entry->view, newentry);
00620 return newentry;
00621 }
00622
00623 void osengine_mappingentry_reset(OSyncMappingEntry *entry)
00624 {
00625 osync_trace(TRACE_INTERNAL, "osengine_mappingentry_reset(%p)", entry);
00626
00627 osync_flag_set(entry->fl_has_data);
00628 osync_flag_unset(entry->fl_dirty);
00629 osync_flag_unset(entry->fl_has_info);
00630 osync_flag_unset(entry->fl_deleted);
00631 osync_flag_set(entry->fl_synced);
00632
00633 osync_change_reset(entry->change);
00634 }
00635 #endif
00636