Ticket #1084: ticket1084_capformats_v1.diff

wrapper/opensync-merger.i

@@ -51 +51 @@
 
 typedef struct {} Capabilities;
 %extend Capabilities {
-        Capabilities() {
+        Capabilities(const char *capsformat) {
                 Error *err = NULL;
-                Capabilities *caps = osync_capabilities_new(&err);
+                Capabilities *caps = osync_capabilities_new(capsformat, &err);
                 if (raise_exception_on_error(err))
                         return NULL;
                 else

opensync/opensync-format.h

@@ -25 +25 @@
 
 #include "format/opensync_converter.h"
 #include "format/opensync_format_env.h"
+#include "format/opensync_format_merger.h"
 #include "format/opensync_objformat.h"
 #include "format/opensync_objformat_sink.h"
 

opensync/CMakeLists.txt

@@ -31 +31 @@
    format/opensync_converter.c
    format/opensync_filter.c
    format/opensync_format_env.c
+   format/opensync_format_merger.c
    format/opensync_objformat.c
    format/opensync_objformat_sink.c
    format/opensync_time.c

opensync/opensync.h

@@ -194 +194 @@
 typedef struct OSyncObjFormat OSyncObjFormat;
 typedef struct OSyncFormatConverterPath OSyncFormatConverterPath;
 typedef struct OSyncFormatConverter OSyncFormatConverter;
+typedef struct OSyncFormatMerger OSyncFormatMerger;
 typedef struct OSyncObjFormatSink OSyncObjFormatSink;
 
 /* Plugin component */

opensync/format/opensync_format_env_internals.h

@@ -42 +42 @@
 struct OSyncFormatEnv {
         /** A List of formats */
         OSyncList *objformats;
-        /** A list of available converters */
+        /** A list of available converters (OSyncFormatConverter*) */
         OSyncList *converters;
+        /** A list of available mergers (OSyncFormatMerger*) */
+        OSyncList *mergers;
         /** A list of filter functions */
         OSyncList *custom_filters;
         
@@ -160 +162 @@
 OSYNC_TEST_EXPORT OSyncFormatConverter *osync_format_env_nth_converter(OSyncFormatEnv *env, int nth);
 
 
+/** @brief Finds first merger with the given objformat and capabilities format
+ * 
+ * @param env Pointer to the environment
+ * @param objformat The object format
+ * @param capsformat The capabilities format
+ * @returns The merger, or NULL if not found
+ * 
+ */
+OSYNC_TEST_EXPORT OSyncFormatMerger *osync_format_env_find_merger(OSyncFormatEnv *env, OSyncObjFormat *objformat, const char *capsformat);
+
 /*@}*/
 
 #endif /* _OPENSYNC_FORMAT_ENV_INTERNALS_H_ */

opensync/format/opensync_format_merger_private.h

@@ +1 @@
+/*
+ * libopensync - A synchronization framework
+ * Copyright (C) 2009       Daniel Gollub <gollub@b1-systems.de>
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ * 
+ */
+
+#ifndef OPENSYNC_FORMAT_MERGER_PRIVATE_H_
+#define OPENSYNC_FORMAT_MERGER_PRIVATE_H_
+
+/**
+ * @defgroup OSyncMergerPrivateAPI OpenSync Merger Private
+ * @ingroup OSyncFormatPrivate
+ * @brief Private part for creating and managing object format mergers
+ * 
+ */
+/*@{*/
+
+/** @brief Represent a merger
+ */
+struct OSyncFormatMerger {
+        char *capsformat;
+        OSyncObjFormat *objformat;
+        OSyncFormatMergerMergeFunc merge_func;
+        OSyncFormatMergerDemergeFunc demerge_func;
+        OSyncFormatMergerInitializeFunc initialize_func;
+        OSyncFormatMergerFinalizeFunc finalize_func;
+        int ref_count;
+        void *userdata;
+};
+
+/*@}*/
+
+#endif /*OPENSYNC_FORMAT_MERGER_PRIVATE_H_*/

opensync/format/opensync_format_merger.c

@@ +1 @@
+/*
+ * libopensync - A synchronization framework
+ * Copyright (C) 2009       Daniel Gollub <gollub@b1-systems.de>
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ * 
+ */
+ 
+#include "opensync.h"
+#include "opensync_internals.h"
+
+#include "opensync-format.h"
+
+#include "opensync/capabilities/opensync_capabilities_internals.h"
+
+#include "opensync_format_merger_private.h"
+#include "opensync_format_merger_internals.h"
+
+OSyncFormatMerger *osync_format_merger_new(OSyncObjFormat *objformat, const char *capsformat, OSyncFormatMergeFunc merge_func, OSyncFormatDemergeFunc demerge_func, OSyncError **error)
+{
+        osync_assert(capsformat);
+        osync_assert(objformat);
+
+        OSyncFormatMerger *merger = NULL;
+        osync_trace(TRACE_ENTRY, "%s(%s(%p), %s, %p, %p, %p)", __func__, __NULLSTR(osync_objformat_get_name(objformat)), objformat, __NULLSTR(capsformat), merge_func, demerge_func, error);
+        
+        merger = osync_try_malloc0(sizeof(OSyncFormatMerger), error);
+        if (!merger) {
+                osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
+                return NULL;
+        }
+        
+        merger->objformat = objformat;
+        osync_objformat_ref(objformat);
+
+        merger->capsformat = osync_strdup(capsformat);
+        
+        merger->merge_func = merge_func;
+        merger->demerge_func = demerge_func;
+        merger->initialize_func = NULL;
+        merger->finalize_func = NULL;
+        merger->userdata = NULL;
+        merger->ref_count = 1;
+        
+        osync_trace(TRACE_EXIT, "%s: %p", __func__, merger);
+        return merger;
+}
+
+OSyncFormatMerger *osync_format_merger_ref(OSyncFormatMerger *merger)
+{
+        osync_assert(merger);
+        
+        g_atomic_int_inc(&(merger->ref_count));
+
+        return merger;
+}
+
+void osync_format_merger_unref(OSyncFormatMerger *merger)
+{
+        osync_assert(merger);
+        
+        if (g_atomic_int_dec_and_test(&(merger->ref_count))) {
+                if (merger->objformat)
+                        osync_objformat_unref(merger->objformat);
+
+                osync_free(merger->capsformat);
+                        
+                osync_free(merger);
+        }
+}
+
+OSyncObjFormat *osync_format_merger_get_objformat(OSyncFormatMerger *merger)
+{
+        osync_return_val_if_fail(merger, NULL);
+        return merger->objformat;
+}
+
+const char *osync_format_merger_get_capsformat(OSyncFormatMerger *merger)
+{
+        osync_return_val_if_fail(merger, NULL);
+        return merger->capsformat;
+}
+
+osync_bool osync_format_merger_merge(OSyncFormatMerger *merger, char **buffer, unsigned int *size, const char *entire_buf, unsigned int entire_size, OSyncCapabilities *caps, OSyncError **error)
+{
+        osync_assert(merger);
+        osync_assert(buffer);
+        osync_assert(size);
+        osync_assert(entire_buf);
+        osync_assert(caps);
+
+        osync_return_val_if_fail(merger->merge_func, TRUE);
+        
+        osync_trace(TRACE_ENTRY, "%s(%p, %p, %u, %p, %u, %p(%s), %p)", __func__, merger, buffer, *size, entire_buf, entire_size, caps, __NULLSTR(osync_capabilities_get_capsformat(caps)), error);
+        
+        if (!merger->merge_func(buffer, size, entire_buf, entire_size, caps, merger->userdata, error))
+                goto error;
+        
+        osync_trace(TRACE_EXIT, "%s", __func__);
+        return TRUE;
+
+error:
+        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
+        return FALSE;
+}
+
+
+osync_bool osync_format_merger_demerge(OSyncFormatMerger *merger, char **buffer, unsigned int *size, OSyncCapabilities *caps, OSyncError **error)
+{
+        osync_assert(merger);
+        osync_assert(buffer);
+        osync_assert(size);
+        osync_assert(caps);
+
+        osync_return_val_if_fail(merger->demerge_func, TRUE);
+
+        osync_trace(TRACE_ENTRY, "%s(%p, %p, %u, %p(%s), %p)", __func__, merger, buffer, *size, caps, __NULLSTR(osync_capabilities_get_capsformat(caps)), error);
+        
+        if (!merger->demerge_func(buffer, size, caps, merger->userdata, error))
+                goto error;
+
+        osync_trace(TRACE_EXIT, "%s", __func__);
+        return TRUE;
+
+error:
+        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error));
+        return FALSE;
+
+}
+
+void osync_format_merger_set_initialize_func(OSyncFormatMerger *merger, OSyncFormatMergerInitializeFunc initialize_func)
+{
+        osync_assert(merger);
+        merger->initialize_func = initialize_func;
+        
+}
+
+void osync_format_merger_set_finalize_func(OSyncFormatMerger *merger, OSyncFormatMergerFinalizeFunc finalize_func)
+{
+        osync_assert(merger);
+        merger->finalize_func = finalize_func;
+}
+
+void osync_format_merger_initialize(OSyncFormatMerger *merger, const char *config, OSyncError **error) {
+
+        osync_assert(merger);
+
+        if (merger->initialize_func) {
+                merger->userdata = merger->initialize_func(config, error);
+        }
+}
+
+void osync_format_merger_finalize(OSyncFormatMerger *merger)
+{
+        osync_assert(merger);
+
+        if (merger->finalize_func) {
+                merger->finalize_func(merger->userdata);
+        }
+}
+

opensync/format/opensync_format_merger.h

@@ +1 @@
+/*
+ * libopensync - A synchronization framework
+ * Copyright (C) 2009       Daniel Gollub <gollub@b1-systems.de>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ */
+
+#ifndef _OPENSYNC_FORMAT_MERGER_H_
+#define _OPENSYNC_FORMAT_MERGER_H_
+
+/**
+ * @defgroup OSyncMergerAPI OpenSync Merger
+ * @ingroup OSyncFormat
+ * @brief Functions for creating and managing format mergers
+ *
+ */
+/*@{*/
+
+typedef void * (* OSyncFormatMergerInitializeFunc) (const char *config, OSyncError **error);
+typedef void (* OSyncFormatMergerFinalizeFunc) (void *userdata);
+
+typedef osync_bool (* OSyncFormatMergerMergeFunc) (char **data, unsigned int *size, const char *entire, unsigned int entsize, OSyncCapabilities *caps, void *user_data, OSyncError **error);
+typedef osync_bool (* OSyncFormatMergerDemergeFunc) (char **data, unsigned int *size, OSyncCapabilities *caps, void *user_data, OSyncError **error);
+
+
+/**
+ * @brief Creates a new merger
+ * @param type the type of merger
+ * @param sourceformat the source format for the merger
+ * @param targetformat the target format for the merger
+ * @param convert_func the merger function
+ * @param error Pointer to an error struct
+ * @returns The pointer to the newly allocated merger or NULL in case of error
+ */
+OSYNC_EXPORT OSyncFormatMerger *osync_format_merger_new(OSyncObjFormat *objformat, const char *capsformat, OSyncFormatMergerMergeFunc merge_func, OSyncFormatMergerDemergeFunc demerge_func, OSyncError **error);
+
+/** @brief Increase the reference count on a merger
+ *
+ * @param merger Pointer to the merger
+ *
+ */
+OSYNC_EXPORT OSyncFormatMerger *osync_format_merger_ref(OSyncFormatMerger *merger);
+
+/** @brief Decrease the reference count on a merger
+ *
+ * @param merger Pointer to the merger
+ *
+ */
+OSYNC_EXPORT void osync_format_merger_unref(OSyncFormatMerger *merger);
+
+/**
+ * @brief Returns the object format of a merger
+ * @param merger Pointer to the merger
+ * @returns The object format of the specified merger
+ */
+OSYNC_EXPORT OSyncObjFormat *osync_format_merger_get_objformat(OSyncFormatMerger *merger);
+
+/**
+ * @brief Returns the capabilities format (name) 
+ * @param merger Pointer to the merger
+ * @returns The capabilities format (name)
+ */
+OSYNC_EXPORT const char *osync_format_merger_get_capsformat(OSyncFormatMerger *merger);
+
+/**
+ * @brief Sets the initialize function of a merger
+ * @param merger Pointer to the merger
+ * @param initialize_func Pointer to the initialize function
+ */
+OSYNC_EXPORT void osync_format_merger_set_initialize_func(OSyncFormatMerger *merger, OSyncFormatMergerInitializeFunc initialize_func);
+
+/**
+ * @brief Sets the finalize function of a merger
+ * @param merger Pointer to the merger
+ * @param finalize_func Pointer to the finalize function
+ */
+OSYNC_EXPORT void osync_format_merger_set_finalize_func(OSyncFormatMerger *merger, OSyncFormatMergerFinalizeFunc finalize_func);
+
+/**
+ * @brief Invokes initialize function of a merger
+ *
+ * @param merger Pointer to the merger which should be initialized
+ * @param config configuration
+ * @param error Pointer to an error struct
+ *
+ * @todo config is not used currently. Should be used in the future to pass a directory for xml format schema location
+ */
+OSYNC_EXPORT void osync_format_merger_initialize(OSyncFormatMerger *merger, const char *config, OSyncError **error);
+
+/**
+ * @brief Invokes finalize function of a merger
+ *
+ * @param merger Pointer to the merger which should be finalized
+ */
+OSYNC_EXPORT void osync_format_merger_finalize(OSyncFormatMerger *merger);
+
+/*@}*/
+
+#endif /*_OPENSYNC_FORMAT_MERGER_H_*/
+

opensync/format/opensync_format_env.c

@@ -766 +766 @@
                         osync_converter_unref(env->converters->data);
                         env->converters = osync_list_remove(env->converters, env->converters->data);
                 }
+
+                /* Free the mergers */
+                while (env->mergers) {
+                        osync_converter_unref(env->mergers->data);
+                        env->mergers = osync_list_remove(env->mergers, env->mergers->data);
+                }
+
         
                 /* Free the filters */
                 while (env->custom_filters) {
@@ -811 +818 @@
         return FALSE;
 }
 
+/* ObjFormats */
+
 void osync_format_env_register_objformat(OSyncFormatEnv *env, OSyncObjFormat *format)
 {
         osync_assert(env);
@@ -853 +862 @@
         return osync_list_copy(env->objformats);
 }
 
+/* Converters */
+
 void osync_format_env_register_converter(OSyncFormatEnv *env, OSyncFormatConverter *converter)
 {
         osync_assert(env);
@@ -934 +945 @@
         return osync_list_copy(env->converters);
 }
 
+/* Filters */
+
 void osync_format_env_register_filter(OSyncFormatEnv *env, OSyncCustomFilter *filter)
 {
         osync_assert(env);
@@ -1187 +1200 @@
         return path;
 }
 
+/* Mergers */
+
+void osync_format_env_register_merger(OSyncFormatEnv *env, OSyncFormatMerger *merger)
+{
+        osync_return_if_fail(env);
+        osync_return_if_fail(merger);
+        
+        env->mergers = osync_list_append(env->mergers, merger);
+        osync_format_merger_ref(merger);
+}
+
+OSyncFormatMerger *osync_format_env_find_merger(OSyncFormatEnv *env, OSyncObjFormat *objformat, const char *capsformat)
+{
+        OSyncList *c = NULL;
+
+        osync_return_val_if_fail(env, NULL);
+        osync_return_val_if_fail(objformat, NULL);
+        osync_return_val_if_fail(capsformat, NULL);
+        
+        for (c = env->mergers; c; c = c->next) {
+                OSyncFormatMerger *merger = c->data;
+                if (!osync_objformat_is_equal(objformat, osync_format_merger_get_objformat(merger)))
+                        continue;
+                        
+                if (!strcmp(capsformat, osync_format_merger_get_capsformat(merger)))
+                        continue;
+                
+                return merger;
+        }
+        
+        return NULL;
+}
+

opensync/format/opensync_format_env.h

@@ -245 +245 @@
  */
 OSYNC_EXPORT OSyncFormatConverterPath *osync_format_env_find_path_formats_with_detectors(OSyncFormatEnv *env, OSyncData *sourcedata, OSyncList *targets, const char *preferred_format, OSyncError **error);
 
+
+/** @brief Registers Format Merger/Demerger
+ * 
+ * @param env The format environment
+ * @param converter Pointer of the Format Merger/Demerger 
+ */
+OSYNC_EXPORT void osync_format_env_register_merger(OSyncFormatEnv *env, OSyncFormatMerger *merger);
+
 /*@}*/
 
 #endif /* _OPENSYNC_FORMAT_ENV_H_ */

opensync/format/opensync_format_merger_internals.h

@@ +1 @@
+/*
+ * libopensync - A synchronization framework
+ * Copyright (C) 2009       Daniel Gollub <gollub@b1-systems.de>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ */
+
+#ifndef _OPENSYNC_FORMAT_MERGER_INTERNALS_H_
+#define _OPENSYNC_FORMAT_MERGER_INTERNALS_H_
+
+#endif /*_OPENSYNC_FORMAT_MERGER_INTERNALS_H_*/
+

opensync/capabilities/opensync_capabilities_private.h

@@ -63 +63 @@
         OSyncCapabilitiesObjType *last_objtype;
         /** The wrapped xml document */
         xmlDocPtr doc;
+        /** The capabilities format name */
+        char *capsformat;
 };
 
 /**

opensync/capabilities/opensync_capabilities.c

@@ -75 +75 @@
 
 /* end of private part */
 
-OSyncCapabilities *osync_capabilities_new(OSyncError **error)
+OSyncCapabilities *osync_capabilities_new(const char *capsformat, OSyncError **error)
 {
+        osync_assert(capsformat);
+
         OSyncCapabilities *capabilities = NULL;
         osync_trace(TRACE_ENTRY, "%s(%p)", __func__, error);
         
@@ -87 +89 @@
         }
         
         capabilities->ref_count = 1;
+        capabilities->capsformat = osync_strdup(capsformat);
         capabilities->first_objtype = NULL;
         capabilities->last_objtype = NULL;
         capabilities->doc = xmlNewDoc(BAD_CAST "1.0");
@@ -176 +179 @@
                                 objtype = tmp;
                         }
                 osync_xml_free_doc(capabilities->doc);
+
+                osync_free(capabilities->capsformat);
+                
                 osync_free(capabilities);
         }
 }
@@ -353 +359 @@
         return res;
 }
 
+const char *osync_capabilities_get_capsformat(OSyncCapabilities *capabilities)
+{
+        osync_return_val_if_fail(capabilities, NULL);
+        return capabilities->capsformat;
+}
+

opensync/capabilities/opensync_capabilities_internals.h

@@ -81 +81 @@
  */
 osync_bool osync_capabilities_member_set_capabilities(OSyncMember *member, OSyncCapabilities* capabilities, OSyncError** error);
 
+/**
+ * @brief Get the capabilities format (name).
+ *
+ * @param capabilities Te pointer to a capabilities object
+ * @return The capabilities format (name)
+ */
+OSYNC_TEST_EXPORT const char *osync_capabilities_get_capsformat(OSyncCapabilities *capabilities);
+
 /*@}*/
 
 #endif /*OPENSYNC_CAPABILITIES_INTERNAL_H_*/

opensync/capabilities/opensync_capabilities.h

@@ -36 +36 @@
 
 /**
  * @brief Creates a new capabilities object
+ * @param capsformat The capabilities format name
  * @param error The error which will hold the info in case of an error
  * @return The pointer to the newly allocated capabilities object or NULL in case of error
  */
-OSYNC_EXPORT OSyncCapabilities *osync_capabilities_new(OSyncError **error);
+OSYNC_EXPORT OSyncCapabilities *osync_capabilities_new(const char *capsformat, OSyncError **error);
 
 /**
  * @brief Creates a new capabilities object from an xml document. 

tests/capabilities-tests/check_capabilities.c

@@ -8 +8 @@
         char *testbed = setup_testbed("capabilities");
 
         OSyncError *error = NULL;
-        OSyncCapabilities *capabilities = osync_capabilities_new(&error);
+        OSyncCapabilities *capabilities = osync_capabilities_new("dummy-caps", &error);
         fail_unless(capabilities != NULL, NULL);
         fail_unless(error == NULL, NULL);
         
@@ -26 +26 @@
         char *testbed = setup_testbed("capabilities");
 
         OSyncError *error = NULL;
-        OSyncCapabilities *capabilities = osync_capabilities_new(&error);
+        OSyncCapabilities *capabilities = osync_capabilities_new("dummy-caps", &error);
         fail_unless(capabilities != NULL, NULL);
         fail_unless(error == NULL, NULL);
         

opensync.sym

@@ -153 +153 @@
 osync_format_env_new
 osync_format_env_ref
 osync_format_env_register_converter
+osync_format_env_register_merger
 osync_format_env_register_objformat
 osync_format_env_unref
+osync_format_merger_finalize
+osync_format_merger_get_capsformat
+osync_format_merger_get_objformat
+osync_format_merger_initialize
+osync_format_merger_new
+osync_format_merger_ref
+osync_format_merger_set_finalize_func
+osync_format_merger_set_initialize_func
+osync_format_merger_unref
 osync_free
 osync_get_version
 osync_group_add_member