• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List

osengine/osengine_mapping.c

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 

Generated on Sat Aug 13 2011 for OpenSync by  doxygen 1.7.1