Exemplo n.º 1
0
OSyncMappingTable *mappingtable_load(const char *path, const char *objtype, unsigned int num_mappings)
{
	OSyncError *error = NULL;
	OSyncMappingTable *table = NULL;
	OSyncArchive *archive = NULL;

	osync_trace(TRACE_ENTRY, "%s(%s, %s, %i)", __func__, path, objtype, num_mappings);
	
	table = osync_mapping_table_new(&error);
	fail_unless(table != NULL, NULL);
	fail_unless(error == NULL, NULL);
	
	archive = osync_archive_new(path, &error);
	fail_unless(archive != NULL, NULL);
	fail_unless(error == NULL, NULL);
	
	fail_unless(osync_mapping_table_load(table, archive, objtype, &error), NULL);
	fail_unless(error == NULL, NULL);
	
	osync_archive_unref(archive);
	
	fail_unless(osync_mapping_table_num_mappings(table) == num_mappings, NULL);
	
	osync_trace(TRACE_EXIT, "%s: %p", __func__, table);
	return table;
}
Exemplo n.º 2
0
OSyncObjEngine *osync_obj_engine_new(OSyncEngine *parent, const char *objtype, OSyncFormatEnv *formatenv, OSyncError **error)
{
  OSyncObjEngine *engine = NULL;
  osync_assert(parent);
  osync_assert(objtype);
	
  osync_trace(TRACE_ENTRY, "%s(%p, %s, %p, %p)", __func__, parent, objtype, formatenv, error);
	
  engine = osync_try_malloc0(sizeof(OSyncObjEngine), error);
  if (!engine)
    goto error;
  engine->ref_count = 1;
  engine->slowsync = FALSE;
  engine->written = FALSE;
	
  /* we dont reference the parent to avoid circular dependencies. This object is completely
   * dependent on the engine anyways */
  engine->parent = parent;
	
  engine->objtype = g_strdup(objtype);
  engine->formatenv = formatenv;
	
  engine->mapping_table = osync_mapping_table_new(error);
  if (!engine->mapping_table)
    goto error_free_engine;
	
  engine->archive = osync_engine_get_archive(parent);
	
  osync_trace(TRACE_EXIT, "%s: %p", __func__, engine);
  return engine;

 error_free_engine:
  osync_obj_engine_unref(engine);
 error:
  osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
  return NULL;
}