opensync/engine/opensync_mapping_entry_engine.c

   1 /*
   2  * libosengine - A synchronization engine for the opensync framework
   3  * Copyright (C) 2004-2005  Armin Bauer <armin.bauer@opensync.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  18  *
  19  */
  20
  21 #include "opensync.h"
  22 #include "opensync_internals.h"
  23
  24 #include "opensync-archive.h"
  25 #include "opensync-group.h"
  26 #include "opensync-engine.h"
  27 #include "opensync-data.h"
  28 #include "opensync-mapping.h"
  29
  30 #include "opensync_obj_engine.h"
  31
  32 #include "opensync_mapping_engine.h"
  33 #include "opensync_sink_engine_internals.h"
  34
  35 #include "opensync_mapping_entry_engine_internals.h"
  36 #include "opensync_mapping_engine_internals.h"
  37
  38
  39 OSyncMappingEntryEngine *osync_entry_engine_new(OSyncMappingEntry *entry, OSyncMappingEngine *mapping_engine, OSyncSinkEngine *sink_engine, OSyncObjEngine *objengine, OSyncError **error)
  40 {
  41   OSyncMappingEntryEngine *engine = NULL;
  42   osync_trace(TRACE_ENTRY, "%s(%p, %p, %p, %p, %p)", __func__, entry, mapping_engine, sink_engine, objengine, error);
  43   osync_assert(sink_engine);
  44   osync_assert(entry);
  45
  46   engine = osync_try_malloc0(sizeof(OSyncMappingEntryEngine), error);
  47   if (!engine)
  48     goto error;
  49   engine->ref_count = 1;
  50
  51   engine->sink_engine = sink_engine;
  52
  53   engine->objengine = objengine;
  54
  55   engine->mapping_engine = osync_mapping_engine_ref(mapping_engine);
  56   engine->entry = osync_mapping_entry_ref(entry);
  57
  58   sink_engine->entries = g_list_append(sink_engine->entries, engine);
  59   osync_entry_engine_ref(engine);
  60
  61   osync_trace(TRACE_EXIT, "%s: %p", __func__, engine);
  62   return engine;
  63
  64  error:
  65   osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
  66   return NULL;
  67 }
  68
  69 OSyncMappingEntryEngine *osync_entry_engine_ref(OSyncMappingEntryEngine *engine)
  70 {
  71   osync_assert(engine);
  72
  73   g_atomic_int_inc(&(engine->ref_count));
  74
  75   return engine;
  76 }
  77
  78 void osync_entry_engine_unref(OSyncMappingEntryEngine *engine)
  79 {
  80   osync_assert(engine);
  81
  82   if (g_atomic_int_dec_and_test(&(engine->ref_count))) {
  83
  84     if (engine->change)
  85       osync_change_unref(engine->change);
  86
  87     if (engine->mapping_engine)
  88       osync_mapping_engine_unref(engine->mapping_engine);
  89
  90     if (engine->entry)
  91       osync_mapping_entry_unref(engine->entry);
  92
  93     g_free(engine);
  94   }
  95 }
  96
  97 osync_bool osync_entry_engine_matches(OSyncMappingEntryEngine *engine, OSyncChange *change)
  98 {
  99   OSyncMappingEntry *entry = NULL;
 100   const char *mapping_entry_uid = NULL;
 101   osync_assert(engine);
 102   osync_assert(engine->entry);
 103   osync_assert(change);
 104
 105   entry = engine->entry;
 106   mapping_entry_uid = osync_mapping_entry_get_uid(entry);
 107   osync_assert(mapping_entry_uid);
 108
 109   if (!strcmp(mapping_entry_uid, osync_change_get_uid(change)))
 110     return TRUE;
 111
 112   return FALSE;
 113 }
 114
 115 void osync_entry_engine_update(OSyncMappingEntryEngine *engine, OSyncChange *change)
 116 {
 117   osync_assert(engine);
 118
 119   if (engine->change)
 120     osync_change_unref(engine->change);
 121
 122   engine->change = change;
 123   engine->mapping_engine->synced = FALSE;
 124
 125   if (change)
 126     osync_change_ref(change);
 127 }
 128
 129 OSyncChange *osync_entry_engine_get_change(OSyncMappingEntryEngine *engine)
 130 {
 131   osync_assert(engine);
 132   return engine->change;
 133 }
 134
 135 osync_bool osync_entry_engine_is_dirty(OSyncMappingEntryEngine *engine)
 136 {
 137   osync_assert(engine);
 138   return engine->dirty;
 139 }
 140
 141 void osync_entry_engine_set_dirty(OSyncMappingEntryEngine *engine, osync_bool dirty)
 142 {
 143   osync_assert(engine);
 144   engine->dirty = dirty;
 145 }
 146