OpenSync
0.22
|
00001 /* 00002 * libopensync - A synchronization framework 00003 * Copyright (C) 2004-2005 Armin Bauer <armin.bauer@opensync.org> 00004 * 00005 * This library is free software; you can redistribute it and/or 00006 * modify it under the terms of the GNU Lesser General Public 00007 * License as published by the Free Software Foundation; either 00008 * version 2.1 of the License, or (at your option) any later version. 00009 * 00010 * This library is distributed in the hope that it will be useful, 00011 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00013 * Lesser General Public License for more details. 00014 * 00015 * You should have received a copy of the GNU Lesser General Public 00016 * License along with this library; if not, write to the Free Software 00017 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 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; /*must not be more the one for objtype=NULL*/ 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 //entry->orig_change = change; 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 //OSyncEngine *engine = table->engine; 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 /*FIXME: We should be able to return error here. What if entry == NULL? */ 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 /* Set fl_mapped accordingly, if the entry was already mapped previously */ 00277 if (entry->mapping) 00278 osync_flag_set(entry->fl_mapped); 00279 00280 //send_read_change(engine, entry); 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 //FIXME Free the changes on the views 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 //g_list_free(view->changes); 00548 //view->changes = NULL; 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