libopensync: headers diff between 0.34 and 0.35 versions

	opensync-context.h	opensync-context.h

	skipping to change at line 29	skipping to change at line 29
	*/	*/

	#ifndef _OPENSYNC_CONTEXT_H	#ifndef _OPENSYNC_CONTEXT_H
	#define _OPENSYNC_CONTEXT_H	#define _OPENSYNC_CONTEXT_H

	OPENSYNC_BEGIN_DECLS	OPENSYNC_BEGIN_DECLS

	typedef void (* OSyncContextCallbackFn)(void , OSyncError );	typedef void (* OSyncContextCallbackFn)(void , OSyncError );
	typedef void (* OSyncContextChangeFn) (OSyncChange , void );	typedef void (* OSyncContextChangeFn) (OSyncChange , void );


	OSyncContext osync_context_new(OSyncError *error);	OSYNC_EXPORT OSyncContext osync_context_new(OSyncError *error);
	void osync_context_ref(OSyncContext *context);	OSYNC_EXPORT OSyncContext osync_context_ref(OSyncContext context);
	void osync_context_unref(OSyncContext *context);	OSYNC_EXPORT void osync_context_unref(OSyncContext *context);


	void osync_context_set_callback(OSyncContext *context, OSyncContextCallback	OSYNC_EXPORT void osync_context_set_callback(OSyncContext *context, OSyncCo
	Fn callback, void *userdata);	ntextCallbackFn callback, void *userdata);
	void osync_context_set_changes_callback(OSyncContext *context, OSyncContext	OSYNC_EXPORT void osync_context_set_changes_callback(OSyncContext *context,
	ChangeFn changes);	OSyncContextChangeFn changes);
	void osync_context_set_warning_callback(OSyncContext *context, OSyncContext	OSYNC_EXPORT void osync_context_set_warning_callback(OSyncContext *context,
	CallbackFn warning);	OSyncContextCallbackFn warning);


	void osync_context_report_error(OSyncContext *context, OSyncErrorType type,	OSYNC_EXPORT void osync_context_report_error(OSyncContext *context, OSyncEr
	const char *format, ...);	rorType type, const char *format, ...);
	void osync_context_report_success(OSyncContext *context);	OSYNC_EXPORT void osync_context_report_success(OSyncContext *context);
	void osync_context_report_osyncerror(OSyncContext context, OSyncError err	OSYNC_EXPORT void osync_context_report_osyncerror(OSyncContext *context, OS
	or);	yncError *error);


	void osync_context_report_osyncwarning(OSyncContext context, OSyncError e	OSYNC_EXPORT void osync_context_report_osyncwarning(OSyncContext *context,
	rror);	OSyncError *error);
	void osync_context_report_change(OSyncContext context, OSyncChange change	OSYNC_EXPORT void osync_context_report_change(OSyncContext *context, OSyncC
	);	hange *change);

	OPENSYNC_END_DECLS	OPENSYNC_END_DECLS

	#endif //_OPENSYNC_CONTEXT_H	#endif //_OPENSYNC_CONTEXT_H

End of changes. 4 change blocks.
	18 lines changed or deleted	18 lines changed or added

	opensync-engine.h	opensync-engine.h
	#ifndef HAVE_ENGINE_H	#ifndef HAVE_ENGINE_H
	#define HAVE_ENGINE_H	#define HAVE_ENGINE_H

	OPENSYNC_BEGIN_DECLS	OPENSYNC_BEGIN_DECLS

	#include "engine/opensync_engine.h"	#include "engine/opensync_engine.h"

		#include "engine/opensync_mapping_engine.h"
	#include "engine/opensync_obj_engine.h"	#include "engine/opensync_obj_engine.h"
	#include "engine/opensync_status.h"	#include "engine/opensync_status.h"

	OPENSYNC_END_DECLS	OPENSYNC_END_DECLS

	#endif	#endif

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	opensync.h	opensync.h

	skipping to change at line 24	skipping to change at line 24
	*	*
	* You should have received a copy of the GNU Lesser General Public	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef HAVE_OPENSYNC_H	#ifndef HAVE_OPENSYNC_H
	#define HAVE_OPENSYNC_H	#define HAVE_OPENSYNC_H


	#ifdef _WIN32

	#include <windows.h>
	#include <process.h>
	#define __func__ __FUNCTION__
	#define OSYNC_EXPORT __declspec(dllexport)

	#else

	#include <unistd.h>
	#define OSYNC_EXPORT

	#endif

	#include <sys/types.h>	#include <sys/types.h>
	#include <time.h>	#include <time.h>
	#include <fcntl.h>	#include <fcntl.h>

	#ifdef __cplusplus	#ifdef __cplusplus

	#define OPENSYNC_BEGIN_DECLS extern "C" {	#define OPENSYNC_BEGIN_DECLS extern "C" {
	#define OPENSYNC_END_DECLS }	#define OPENSYNC_END_DECLS }

	#else	#else

	#define OPENSYNC_BEGIN_DECLS	#define OPENSYNC_BEGIN_DECLS
	#define OPENSYNC_END_DECLS	#define OPENSYNC_END_DECLS

	#endif	#endif


		#ifdef _WIN32
		#include <windows.h>
		#include <process.h>
		#define __func__ __FUNCTION__
		#define OSYNC_EXPORT __declspec(dllexport)

		#elif __GNUC__
		#include <unistd.h>
		#define OSYNC_EXPORT __attribute__ ((visibility("default")))

		#elif __sun
		#include <unistd.h>
		#define OSYNC_EXPORT __global

		#else
		#define OSYNC_EXPORT
		#endif

	OPENSYNC_BEGIN_DECLS	OPENSYNC_BEGIN_DECLS

	/**************************************************************	/**************************************************************
	* Defines	* Defines
	*************************************************************/	*************************************************************/
	#ifndef TRUE	#ifndef TRUE
	#define TRUE 1	#define TRUE 1
	#endif	#endif

	#ifndef FALSE	#ifndef FALSE

End of changes. 2 change blocks.
	14 lines changed or deleted	18 lines changed or added

	opensync_anchor.h	opensync_anchor.h

	skipping to change at line 24	skipping to change at line 24
	*	*
	* You should have received a copy of the GNU Lesser General Public	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef OPENSYNC_ANCHOR_H_	#ifndef OPENSYNC_ANCHOR_H_
	#define OPENSYNC_ANCHOR_H_	#define OPENSYNC_ANCHOR_H_


	osync_bool osync_anchor_compare(const char anchordb, const char key, cons	OSYNC_EXPORT osync_bool osync_anchor_compare(const char *anchordb, const ch
	t char *new_anchor);	ar key, const char new_anchor);
	void osync_anchor_update(const char anchordb, const char key, const char	OSYNC_EXPORT void osync_anchor_update(const char anchordb, const char key
	*new_anchor);	, const char *new_anchor);
	char osync_anchor_retrieve(const char anchordb, const char *key);	OSYNC_EXPORT char osync_anchor_retrieve(const char anchordb, const char *
		key);

	#endif /* OPENSYNC_ANCHOR_H_ */	#endif /* OPENSYNC_ANCHOR_H_ */

End of changes. 1 change blocks.
	5 lines changed or deleted	6 lines changed or added

	opensync_change.h	opensync_change.h
	#ifndef _OPENSYNC_CHANGE_H_	#ifndef _OPENSYNC_CHANGE_H_
	#define _OPENSYNC_CHANGE_H_	#define _OPENSYNC_CHANGE_H_


	OSyncChange osync_change_new(OSyncError *error);	OSYNC_EXPORT OSyncChange osync_change_new(OSyncError *error);
	void osync_change_ref(OSyncChange *change);	OSYNC_EXPORT OSyncChange osync_change_ref(OSyncChange change);
	void osync_change_unref(OSyncChange *change);	OSYNC_EXPORT void osync_change_unref(OSyncChange *change);


	OSyncChange osync_change_clone(OSyncChange source, OSyncError **error);	OSYNC_EXPORT OSyncChange osync_change_clone(OSyncChange source, OSyncErro r **error);


	void osync_change_set_hash(OSyncChange change, const char hash);	OSYNC_EXPORT void osync_change_set_hash(OSyncChange change, const char ha
	const char osync_change_get_hash(OSyncChange change);	sh);
		OSYNC_EXPORT const char osync_change_get_hash(OSyncChange change);


	void osync_change_set_uid(OSyncChange change, const char uid);	OSYNC_EXPORT void osync_change_set_uid(OSyncChange change, const char uid
	const char osync_change_get_uid(OSyncChange change);	);
		OSYNC_EXPORT const char osync_change_get_uid(OSyncChange change);


	OSyncChangeType osync_change_get_changetype(OSyncChange *change);	OSYNC_EXPORT OSyncChangeType osync_change_get_changetype(OSyncChange *chang
	void osync_change_set_changetype(OSyncChange *change, OSyncChangeType type)	e);
	;	OSYNC_EXPORT void osync_change_set_changetype(OSyncChange *change, OSyncCha
		ngeType type);


	void osync_change_set_data(OSyncChange change, OSyncData data);	OSYNC_EXPORT void osync_change_set_data(OSyncChange change, OSyncData dat
	OSyncData osync_change_get_data(OSyncChange change);	a);
		OSYNC_EXPORT OSyncData osync_change_get_data(OSyncChange change);


	OSyncConvCmpResult osync_change_compare(OSyncChange *leftchange, OSyncChang	OSYNC_EXPORT OSyncConvCmpResult osync_change_compare(OSyncChange *leftchang
	e *rightchange);	e, OSyncChange *rightchange);
	osync_bool osync_change_duplicate(OSyncChange change, osync_bool dirty, O	OSYNC_EXPORT osync_bool osync_change_duplicate(OSyncChange *change, osync_b
	SyncError **error);	ool dirty, OSyncError *error);


	OSyncObjFormat osync_change_get_objformat(OSyncChange change);	OSYNC_EXPORT OSyncObjFormat osync_change_get_objformat(OSyncChange change
	const char osync_change_get_objtype(OSyncChange change);	);
	void osync_change_set_objtype(OSyncChange change, const char objtype);	OSYNC_EXPORT const char osync_change_get_objtype(OSyncChange change);
		OSYNC_EXPORT void osync_change_set_objtype(OSyncChange *change, const char
		*objtype);

	#endif //_OPENSYNC_CHANGE_H_	#endif //_OPENSYNC_CHANGE_H_

End of changes. 8 change blocks.
	20 lines changed or deleted	26 lines changed or added

	opensync_client.h	opensync_client.h

	skipping to change at line 24	skipping to change at line 24
	*	*
	* You should have received a copy of the GNU Lesser General Public	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef OPENSYNC_CLIENT_H_	#ifndef OPENSYNC_CLIENT_H_
	#define OPENSYNC_CLIENT_H_	#define OPENSYNC_CLIENT_H_


	OSyncClient osync_client_new(OSyncError *error);	OSYNC_EXPORT OSyncClient osync_client_new(OSyncError *error);
	void osync_client_ref(OSyncClient *client);	OSYNC_EXPORT OSyncClient osync_client_ref(OSyncClient client);
	void osync_client_unref(OSyncClient *client);	OSYNC_EXPORT void osync_client_unref(OSyncClient *client);


	void osync_client_set_incoming_queue(OSyncClient client, OSyncQueue incom	OSYNC_EXPORT void osync_client_set_incoming_queue(OSyncClient *client, OSyn
	ing);	cQueue *incoming);
	void osync_client_set_outgoing_queue(OSyncClient client, OSyncQueue outgo	OSYNC_EXPORT void osync_client_set_outgoing_queue(OSyncClient *client, OSyn
	ing);	cQueue *outgoing);


	void osync_client_run_and_block(OSyncClient *client);	OSYNC_EXPORT void osync_client_run_and_block(OSyncClient *client);
	osync_bool osync_client_run(OSyncClient client, OSyncError *error);	OSYNC_EXPORT osync_bool osync_client_run(OSyncClient client, OSyncError *
	void osync_client_shutdown(OSyncClient *client);	error);
	void osync_client_error_shutdown(OSyncClient client, OSyncError error);	OSYNC_EXPORT void osync_client_shutdown(OSyncClient *client);
	void osync_client_disconnect(OSyncClient *client);	OSYNC_EXPORT void osync_client_error_shutdown(OSyncClient *client, OSyncErr
		or *error);
		OSYNC_EXPORT void osync_client_disconnect(OSyncClient *client);


	osync_bool osync_client_run_external(OSyncClient client, char pipe_path, OSyncPlugin plugin, OSyncError *error);	OSYNC_EXPORT osync_bool osync_client_run_external(OSyncClient client, char pipe_path, OSyncPlugin plugin, OSyncError *error);

	#endif /OPENSYNC_CLIENT_H_/	#endif /OPENSYNC_CLIENT_H_/

End of changes. 4 change blocks.
	13 lines changed or deleted	15 lines changed or added

	opensync_converter.h	opensync_converter.h

	skipping to change at line 33	skipping to change at line 33

	typedef enum {	typedef enum {
	/** Simple converter */	/** Simple converter */
	OSYNC_CONVERTER_CONV = 1,	OSYNC_CONVERTER_CONV = 1,
	/** Encapsulator */	/** Encapsulator */
	OSYNC_CONVERTER_ENCAP = 2,	OSYNC_CONVERTER_ENCAP = 2,
	/** Desencapsulator */	/** Desencapsulator */
	OSYNC_CONVERTER_DECAP = 3,	OSYNC_CONVERTER_DECAP = 3,
	/** Detector */	/** Detector */
	OSYNC_CONVERTER_DETECTOR = 4	OSYNC_CONVERTER_DETECTOR = 4

	} ConverterType;	} OSyncConverterType;


	OSYNC_EXPORT typedef osync_bool (* OSyncFormatDetectFunc) (const char *data	typedef osync_bool (* OSyncFormatDetectFunc) (const char *data, int size);
	, int size);	typedef osync_bool (* OSyncFormatConvertFunc) (char *input, unsigned int in
	OSYNC_EXPORT typedef osync_bool (* OSyncFormatConvertFunc) (char *input, un	psize, char *output, unsigned int outpsize, osync_bool *free_input, const
	signed int inpsize, char *output, unsigned int outpsize, osync_bool *free	char config, OSyncError *error);
	_input, const char config, OSyncError *error);


	OSYNC_EXPORT OSyncFormatConverter osync_converter_new(ConverterType type, OSyncObjFormat sourceformat, OSyncObjFormat targetformat, OSyncFormatConv ertFunc convert_func, OSyncError *error);	OSYNC_EXPORT OSyncFormatConverter osync_converter_new(OSyncConverterType t ype, OSyncObjFormat sourceformat, OSyncObjFormat targetformat, OSyncForma tConvertFunc convert_func, OSyncError *error);
	OSYNC_EXPORT OSyncFormatConverter osync_converter_new_detector(OSyncObjFor mat sourceformat, OSyncObjFormat targetformat, OSyncFormatDetectFunc dete ct_func, OSyncError *error);	OSYNC_EXPORT OSyncFormatConverter osync_converter_new_detector(OSyncObjFor mat sourceformat, OSyncObjFormat targetformat, OSyncFormatDetectFunc dete ct_func, OSyncError *error);

	OSYNC_EXPORT void osync_converter_ref(OSyncFormatConverter *converter);	OSYNC_EXPORT OSyncFormatConverter osync_converter_ref(OSyncFormatConverter converter);
	OSYNC_EXPORT void osync_converter_unref(OSyncFormatConverter *converter);	OSYNC_EXPORT void osync_converter_unref(OSyncFormatConverter *converter);

	OSYNC_EXPORT OSyncObjFormat osync_converter_get_sourceformat(OSyncFormatCo nverter converter);	OSYNC_EXPORT OSyncObjFormat osync_converter_get_sourceformat(OSyncFormatCo nverter converter);
	OSYNC_EXPORT OSyncObjFormat osync_converter_get_targetformat(OSyncFormatCo nverter converter);	OSYNC_EXPORT OSyncObjFormat osync_converter_get_targetformat(OSyncFormatCo nverter converter);

	OSYNC_EXPORT ConverterType osync_converter_get_type(OSyncFormatConverter *c onverter);	OSYNC_EXPORT OSyncConverterType osync_converter_get_type(OSyncFormatConvert er *converter);

	OSYNC_EXPORT OSyncObjFormat osync_converter_detect(OSyncFormatConverter c onverter, OSyncData *data);	OSYNC_EXPORT OSyncObjFormat osync_converter_detect(OSyncFormatConverter c onverter, OSyncData *data);
	OSYNC_EXPORT osync_bool osync_converter_invoke(OSyncFormatConverter conver ter, OSyncData data, const char config, OSyncError *error);	OSYNC_EXPORT osync_bool osync_converter_invoke(OSyncFormatConverter conver ter, OSyncData data, const char config, OSyncError *error);
	OSYNC_EXPORT osync_bool osync_converter_matches(OSyncFormatConverter conve rter, OSyncData data);	OSYNC_EXPORT osync_bool osync_converter_matches(OSyncFormatConverter conve rter, OSyncData data);

	OSYNC_EXPORT OSyncFormatConverterPath osync_converter_path_new(OSyncError *error);	OSYNC_EXPORT OSyncFormatConverterPath osync_converter_path_new(OSyncError *error);

	OSYNC_EXPORT void osync_converter_path_ref(OSyncFormatConverterPath *path);	OSYNC_EXPORT OSyncFormatConverterPath osync_converter_path_ref(OSyncFormat ConverterPath path);
	OSYNC_EXPORT void osync_converter_path_unref(OSyncFormatConverterPath *path );	OSYNC_EXPORT void osync_converter_path_unref(OSyncFormatConverterPath *path );

	OSYNC_EXPORT void osync_converter_path_add_edge(OSyncFormatConverterPath p ath, OSyncFormatConverter edge);	OSYNC_EXPORT void osync_converter_path_add_edge(OSyncFormatConverterPath p ath, OSyncFormatConverter edge);
	OSYNC_EXPORT int osync_converter_path_num_edges(OSyncFormatConverterPath *p ath);	OSYNC_EXPORT int osync_converter_path_num_edges(OSyncFormatConverterPath *p ath);
	OSYNC_EXPORT OSyncFormatConverter osync_converter_path_nth_edge(OSyncForma tConverterPath path, unsigned int nth);	OSYNC_EXPORT OSyncFormatConverter osync_converter_path_nth_edge(OSyncForma tConverterPath path, unsigned int nth);
	OSYNC_EXPORT const char osync_converter_path_get_config(OSyncFormatConvert erPath path);	OSYNC_EXPORT const char osync_converter_path_get_config(OSyncFormatConvert erPath path);
	OSYNC_EXPORT void osync_converter_path_set_config(OSyncFormatConverterPath path, const char config);	OSYNC_EXPORT void osync_converter_path_set_config(OSyncFormatConverterPath path, const char config);

	#endif //_OPENSYNC_CONVERTER_H_	#endif //_OPENSYNC_CONVERTER_H_

End of changes. 6 change blocks.
	10 lines changed or deleted	9 lines changed or added

	opensync_engine.h	opensync_engine.h

	skipping to change at line 132	skipping to change at line 132
	/*! @brief Struct for the engine status callback	/*! @brief Struct for the engine status callback
	* @ingroup OSEnginePublic	* @ingroup OSEnginePublic
	*/	*/
	typedef struct OSyncEngineUpdate {	typedef struct OSyncEngineUpdate {
	/** The type of the status update */	/** The type of the status update */
	OSyncEngineEvent type;	OSyncEngineEvent type;
	/** If the status was a error, this error will be set */	/** If the status was a error, this error will be set */
	OSyncError *error;	OSyncError *error;
	} OSyncEngineUpdate;	} OSyncEngineUpdate;


	OSyncEngine osync_engine_new(OSyncGroup group, OSyncError **error);	OSYNC_EXPORT OSyncEngine osync_engine_new(OSyncGroup group, OSyncError **
	void osync_engine_ref(OSyncEngine *engine);	error);
	void osync_engine_unref(OSyncEngine *engine);	OSYNC_EXPORT OSyncEngine osync_engine_ref(OSyncEngine engine);
		OSYNC_EXPORT void osync_engine_unref(OSyncEngine *engine);


	void osync_engine_set_plugindir(OSyncEngine engine, const char dir);	OSYNC_EXPORT void osync_engine_set_plugindir(OSyncEngine *engine, const cha
	void osync_engine_set_formatdir(OSyncEngine engine, const char dir);	r *dir);
		OSYNC_EXPORT void osync_engine_set_formatdir(OSyncEngine *engine, const cha
		r *dir);


	OSyncGroup osync_engine_get_group(OSyncEngine engine);	OSYNC_EXPORT OSyncGroup osync_engine_get_group(OSyncEngine engine);
	OSyncArchive osync_engine_get_archive(OSyncEngine engine);	OSYNC_EXPORT OSyncArchive osync_engine_get_archive(OSyncEngine engine);


	osync_bool osync_engine_initialize(OSyncEngine engine, OSyncError *error)	OSYNC_EXPORT osync_bool osync_engine_initialize(OSyncEngine *engine, OSyncE
	;	rror **error);
	osync_bool osync_engine_finalize(OSyncEngine engine, OSyncError *error);	OSYNC_EXPORT osync_bool osync_engine_finalize(OSyncEngine *engine, OSyncErr
		or **error);


	osync_bool osync_engine_synchronize(OSyncEngine engine, OSyncError *error	OSYNC_EXPORT osync_bool osync_engine_synchronize(OSyncEngine *engine, OSync
	);	Error **error);
	osync_bool osync_engine_synchronize_and_block(OSyncEngine *engine, OSyncErr	OSYNC_EXPORT osync_bool osync_engine_synchronize_and_block(OSyncEngine *eng
	or **error);	ine, OSyncError **error);
	osync_bool osync_engine_wait_sync_end(OSyncEngine engine, OSyncError *err	OSYNC_EXPORT osync_bool osync_engine_wait_sync_end(OSyncEngine *engine, OSy
	or);	ncError **error);


	osync_bool osync_engine_discover(OSyncEngine engine, OSyncMember member,	OSYNC_EXPORT osync_bool osync_engine_discover(OSyncEngine *engine, OSyncMem
	OSyncError **error);	ber member, OSyncError *error);
	osync_bool osync_engine_discover_and_block(OSyncEngine *engine, OSyncMember	OSYNC_EXPORT osync_bool osync_engine_discover_and_block(OSyncEngine *engine
	member, OSyncError *error);	, OSyncMember member, OSyncError *error);


	//void osync_engine_pause(OSyncEngine *engine);	//OSYNC_EXPORT void osync_engine_pause(OSyncEngine *engine);
	//void osync_engine_abort(OSyncEngine *engine);	//OSYNC_EXPORT void osync_engine_abort(OSyncEngine *engine);


	//void osync_engine_one_iteration(OSyncEngine *engine);	//OSYNC_EXPORT void osync_engine_one_iteration(OSyncEngine *engine);
	//void osync_engine_flag_manual(OSyncEngine *engine);	//OSYNC_EXPORT void osync_engine_flag_manual(OSyncEngine *engine);

	typedef struct OSyncMappingEngine OSyncMappingEngine;	typedef struct OSyncMappingEngine OSyncMappingEngine;

	//typedef void ( osync_message_cb) (OSyncEngine , OSyncClient , const c har , void , void *);	//typedef void ( osync_message_cb) (OSyncEngine , OSyncClient , const c har , void , void *);
	typedef void (* osync_conflict_cb) (OSyncEngine , OSyncMappingEngine , vo id *);	typedef void (* osync_conflict_cb) (OSyncEngine , OSyncMappingEngine , vo id *);
	typedef void (* osync_status_change_cb) (OSyncChangeUpdate , void );	typedef void (* osync_status_change_cb) (OSyncChangeUpdate , void );
	typedef void (* osync_status_mapping_cb) (OSyncMappingUpdate , void );	typedef void (* osync_status_mapping_cb) (OSyncMappingUpdate , void );
	typedef void (* osync_status_member_cb) (OSyncMemberUpdate , void );	typedef void (* osync_status_member_cb) (OSyncMemberUpdate , void );
	typedef void (* osync_status_engine_cb) (OSyncEngineUpdate , void );	typedef void (* osync_status_engine_cb) (OSyncEngineUpdate , void );

		OSYNC_EXPORT
		OSYNC_EXPORT /void osync_engine_set_message_callback(OSyncEngine engine,
		osync_message_cb callback, void user_data);/
		OSYNC_EXPORT void osync_engine_set_conflict_callback(OSyncEngine *engine, o
		sync_conflict_cb callback, void *user_data);
		OSYNC_EXPORT void osync_engine_set_changestatus_callback(OSyncEngine *engin
		e, osync_status_change_cb callback, void *user_data);
		OSYNC_EXPORT void osync_engine_set_mappingstatus_callback(OSyncEngine *engi
		ne, osync_status_mapping_cb callback, void *user_data);
		OSYNC_EXPORT void osync_engine_set_enginestatus_callback(OSyncEngine *engin
		e, osync_status_engine_cb callback, void *user_data);
		OSYNC_EXPORT void osync_engine_set_memberstatus_callback(OSyncEngine *engin
		e, osync_status_member_cb callback, void *user_data);


	/void osync_engine_set_message_callback(OSyncEngine engine, osync_message	OSYNC_EXPORT void osync_engine_event(OSyncEngine *engine, OSyncEngineEvent
	_cb callback, void user_data);/	event);
	void osync_engine_set_conflict_callback(OSyncEngine *engine, osync_conflict	OSYNC_EXPORT osync_bool osync_engine_check_get_changes(OSyncEngine *engine)
	_cb callback, void *user_data);	;
	void osync_engine_set_changestatus_callback(OSyncEngine *engine, osync_stat
	us_change_cb callback, void *user_data);
	void osync_engine_set_mappingstatus_callback(OSyncEngine *engine, osync_sta
	tus_mapping_cb callback, void *user_data);
	void osync_engine_set_enginestatus_callback(OSyncEngine *engine, osync_stat
	us_engine_cb callback, void *user_data);
	void osync_engine_set_memberstatus_callback(OSyncEngine *engine, osync_stat
	us_member_cb callback, void *user_data);

	void osync_engine_event(OSyncEngine *engine, OSyncEngineEvent event);
	osync_bool osync_engine_check_get_changes(OSyncEngine *engine);


	int osync_engine_num_proxies(OSyncEngine *engine);	OSYNC_EXPORT int osync_engine_num_proxies(OSyncEngine *engine);
	OSyncClientProxy osync_engine_nth_proxy(OSyncEngine engine, int nth);	OSYNC_EXPORT OSyncClientProxy osync_engine_nth_proxy(OSyncEngine engine,
	OSyncClientProxy osync_engine_find_proxy(OSyncEngine engine, OSyncMember	int nth);
	*member);	OSYNC_EXPORT OSyncClientProxy osync_engine_find_proxy(OSyncEngine engine,
		OSyncMember *member);


	int osync_engine_num_objengine(OSyncEngine *engine);	OSYNC_EXPORT int osync_engine_num_objengine(OSyncEngine *engine);
	OSyncObjEngine osync_engine_nth_objengine(OSyncEngine engine, int nth);	OSYNC_EXPORT OSyncObjEngine osync_engine_nth_objengine(OSyncEngine engine
	OSyncObjEngine osync_engine_find_objengine(OSyncEngine engine, const char	, int nth);
	*objtype);	OSYNC_EXPORT OSyncObjEngine osync_engine_find_objengine(OSyncEngine engin
		e, const char *objtype);


	osync_bool osync_engine_mapping_solve(OSyncEngine *engine, OSyncMappingEngi	OSYNC_EXPORT osync_bool osync_engine_mapping_solve(OSyncEngine *engine, OSy
	ne mapping_engine, OSyncChange change, OSyncError **error);	ncMappingEngine mapping_engine, OSyncChange change, OSyncError **error);
	osync_bool osync_engine_mapping_duplicate(OSyncEngine *engine, OSyncMapping	OSYNC_EXPORT osync_bool osync_engine_mapping_duplicate(OSyncEngine *engine,
	Engine mapping_engine, OSyncError *error);	OSyncMappingEngine mapping_engine, OSyncError *error);
	osync_bool osync_engine_mapping_ignore_conflict(OSyncEngine *engine, OSyncM	OSYNC_EXPORT osync_bool osync_engine_mapping_ignore_conflict(OSyncEngine *e
	appingEngine mapping_engine, OSyncError *error);	ngine, OSyncMappingEngine mapping_engine, OSyncError *error);
	osync_bool osync_engine_mapping_use_latest(OSyncEngine *engine, OSyncMappin	OSYNC_EXPORT osync_bool osync_engine_mapping_use_latest(OSyncEngine *engine
	gEngine mapping_engine, OSyncError *error);	, OSyncMappingEngine mapping_engine, OSyncError *error);

	#endif /OPENSYNC_ENGINE_H_/	#endif /OPENSYNC_ENGINE_H_/

End of changes. 13 change blocks.
	55 lines changed or deleted	63 lines changed or added

	opensync_hashtable.h	opensync_hashtable.h

	skipping to change at line 24	skipping to change at line 24
	*	*
	* You should have received a copy of the GNU Lesser General Public	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef OPENSYNC_HASHTABLE_H_	#ifndef OPENSYNC_HASHTABLE_H_
	#define OPENSYNC_HASHTABLE_H_	#define OPENSYNC_HASHTABLE_H_


	OSyncHashTable osync_hashtable_new(const char path, const char *objtype,	OSYNC_EXPORT OSyncHashTable osync_hashtable_new(const char path, const ch
	OSyncError **error);	ar objtype, OSyncError *error);
	void osync_hashtable_free(OSyncHashTable *table);	OSYNC_EXPORT void osync_hashtable_free(OSyncHashTable *table);
		OSYNC_EXPORT
	void osync_hashtable_reset(OSyncHashTable *table);	OSYNC_EXPORT void osync_hashtable_reset(OSyncHashTable *table);
	int osync_hashtable_num_entries(OSyncHashTable *table);	OSYNC_EXPORT int osync_hashtable_num_entries(OSyncHashTable *table);
	osync_bool osync_hashtable_nth_entry(OSyncHashTable table, int i, char *u	OSYNC_EXPORT osync_bool osync_hashtable_nth_entry(OSyncHashTable *table, in
	id, char **hash);	t i, char uid, char hash);
	void osync_hashtable_write(OSyncHashTable table, const char uid, const ch	OSYNC_EXPORT void osync_hashtable_write(OSyncHashTable table, const char
	ar *hash);	uid, const char *hash);
	void osync_hashtable_delete(OSyncHashTable table, const char uid);	OSYNC_EXPORT void osync_hashtable_delete(OSyncHashTable *table, const char
	void osync_hashtable_update_hash(OSyncHashTable *table, OSyncChangeType typ	*uid);
	e, const char uid, const char hash);	OSYNC_EXPORT void osync_hashtable_update_hash(OSyncHashTable *table, OSyncC
	void osync_hashtable_report(OSyncHashTable table, const char uid);	hangeType type, const char uid, const char hash);
	char *osync_hashtable_get_deleted(OSyncHashTable table);	OSYNC_EXPORT void osync_hashtable_report(OSyncHashTable *table, const char
	OSyncChangeType osync_hashtable_get_changetype(OSyncHashTable *table, const	*uid);
	char uid, const char hash);	OSYNC_EXPORT char *osync_hashtable_get_deleted(OSyncHashTable table);
	char osync_hashtable_get_hash(OSyncHashTable table, const char *uid);	OSYNC_EXPORT OSyncChangeType osync_hashtable_get_changetype(OSyncHashTable
		table, const char uid, const char *hash);
		OSYNC_EXPORT char osync_hashtable_get_hash(OSyncHashTable table, const ch
		ar *uid);

	#endif /* OPENSYNC_HASHTABLE_H_ */	#endif /* OPENSYNC_HASHTABLE_H_ */

End of changes. 1 change blocks.
	18 lines changed or deleted	21 lines changed or added

	opensync_list.h	opensync_list.h

	skipping to change at line 51	skipping to change at line 51
	OSyncList *next;	OSyncList *next;
	OSyncList *prev;	OSyncList *prev;
	};	};

	typedef int (OSyncCompareFunc)(void a, void *b);	typedef int (OSyncCompareFunc)(void a, void *b);
	typedef int (OSyncCompareDataFunc)(void a, void b, void user_data);	typedef int (OSyncCompareDataFunc)(void a, void b, void user_data);
	typedef void (OSyncFunc)(void data, void *user_data);	typedef void (OSyncFunc)(void data, void *user_data);

	/* Doubly linked lists	/* Doubly linked lists
	*/	*/

	OSyncList* osync_list_alloc (void);	OSYNC_EXPORT OSyncList* osync_list_alloc (void);
	void osync_list_free (OSyncList *list);	OSYNC_EXPORT void osync_list_free (OSyncList
	void osync_list_free_1 (OSyncList *list);	*list);
	#define osync_list_free1 osync_list_free_1	OSYNC_EXPORT void osync_list_free_1 (OSyncList
	OSyncList* osync_list_append (OSyncList *list	*list);
	,	#define osync_list_free1 osync_list_free_1
		OSYNC_EXPORT OSyncList* osync_list_append (OSyncList
		*list,
	void * data);	void * data);

	OSyncList* osync_list_prepend (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_prepend (OSyncList *list,
	void * data);	void * data);

	OSyncList* osync_list_insert (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_insert (OSyncList *list,
	void * data,	void * data,
	int position);	int position);

	OSyncList* osync_list_insert_sorted (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_insert_sorted (OSyncList *list,
	void * data,	void * data,
	OSyncCompareFunc func);	OSyncCompareFunc func);

	OSyncList* osync_list_insert_sorted_with_data (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_insert_sorted_with_data (OSyncList *list,
	void * data,	void * data,
	OSyncCompareDataFunc func,	OSyncCompareDataFunc func,
	void * user_data);	void * user_data);

	OSyncList* osync_list_insert_before (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_insert_before (OSyncList *list,
	OSyncList *sibling,	OSyncList *sibling,
	void * data);	void * data);

	OSyncList* osync_list_concat (OSyncList *list 1,	OSYNC_EXPORT OSyncList* osync_list_concat (OSyncList *list1,
	OSyncList *list2);	OSyncList *list2);

	OSyncList* osync_list_remove (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_remove (OSyncList *list,
	void * data);	void * data);

	OSyncList* osync_list_remove_all (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_remove_all (OSyncList *list,
	void * data);	void * data);

	OSyncList* osync_list_remove_link (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_remove_link (OSyncList *list,
	OSyncList *llink);	OSyncList *llink);

	OSyncList* osync_list_delete_link (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_delete_link (OSyncList *list,
	OSyncList *link_);	OSyncList *link_);

	OSyncList* osync_list_reverse (OSyncList *list	OSYNC_EXPORT OSyncList* osync_list_reverse (OSyncList
	);	*list);
	OSyncList* osync_list_copy (OSyncList *list	OSYNC_EXPORT OSyncList* osync_list_copy (OSyncList
	);	*list);
	OSyncList* osync_list_nth (OSyncList *list	OSYNC_EXPORT OSyncList* osync_list_nth (OSyncList
	,	*list,
	unsigned int n);	unsigned int n);

	OSyncList* osync_list_nth_prev (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_nth_prev (OSyncList *list,
	unsigned int n);	unsigned int n);

	OSyncList* osync_list_find (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_find (OSyncList *list,
	void * data);	void * data);

	OSyncList* osync_list_find_custom (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_find_custom (OSyncList *list,
	void * data,	void * data,
	OSyncCompareFunc func);	OSyncCompareFunc func);

	int osync_list_position (OSyncList *list,	OSYNC_EXPORT int osync_list_position (OSyncList *list,
	OSyncList *llink);	OSyncList *llink);

	int osync_list_index (OSyncList *list,	OSYNC_EXPORT int osync_list_index (OSyncList *list,
	void * data);	void * data);

	OSyncList* osync_list_last (OSyncList *list	OSYNC_EXPORT OSyncList* osync_list_last (OSyncList
	);	*list);
	OSyncList* osync_list_first (OSyncList *list	OSYNC_EXPORT OSyncList* osync_list_first (OSyncList
	);	*list);
	unsigned int osync_list_length (const OSyncList	OSYNC_EXPORT unsigned int osync_list_length (const OSyn
	*list);	cList *list);
	void osync_list_foreach (OSyncList *list,	OSYNC_EXPORT void osync_list_foreach (OSyncList
		*list,
	OSyncFunc func,	OSyncFunc func,
	void * user_data);	void * user_data);

	OSyncList* osync_list_sort (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_sort (OSyncList *list,
	OSyncCompareFunc compare_func) ;	OSyncCompareFunc compare_func) ;

	OSyncList* osync_list_sort_with_data (OSyncList *list ,	OSYNC_EXPORT OSyncList* osync_list_sort_with_data (OSyncList *list,
	OSyncCompareDataFunc compare_func,	OSyncCompareDataFunc compare_func,
	void * user_data) ;	void * user_data) ;

	void * osync_list_nth_data (OSyncList *list,	OSYNC_EXPORT void * osync_list_nth_data (OSyncList *list,
	unsigned int n);	unsigned int n);

	OPENSYNC_END_DECLS	OPENSYNC_END_DECLS

	#endif /* _OPENSYNC_LIST_H_ */	#endif /* _OPENSYNC_LIST_H_ */

End of changes. 21 change blocks.
	37 lines changed or deleted	40 lines changed or added

	opensync_mapping_entry.h	opensync_mapping_entry.h

	skipping to change at line 24	skipping to change at line 24
	*	*
	* You should have received a copy of the GNU Lesser General Public	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef OPENSYNC_MAPPING_ENTRY_H_	#ifndef OPENSYNC_MAPPING_ENTRY_H_
	#define OPENSYNC_MAPPING_ENTRY_H_	#define OPENSYNC_MAPPING_ENTRY_H_


	OSyncMappingEntry osync_mapping_entry_new(OSyncError *error);	OSYNC_EXPORT OSyncMappingEntry osync_mapping_entry_new(OSyncError *error)
	void osync_mapping_entry_ref(OSyncMappingEntry *entry);	;
	void osync_mapping_entry_unref(OSyncMappingEntry *entry);	OSYNC_EXPORT OSyncMappingEntry osync_mapping_entry_ref(OSyncMappingEntry
		entry);
		OSYNC_EXPORT void osync_mapping_entry_unref(OSyncMappingEntry *entry);


	osync_bool osync_mapping_entry_matches(OSyncMappingEntry entry, OSyncChang e change);	OSYNC_EXPORT osync_bool osync_mapping_entry_matches(OSyncMappingEntry entr y, OSyncChange change);


	/void osync_mapping_entry_update(OSyncMappingEntry entry, OSyncChange *ch	/*
	ange);	OSYNC_EXPORT void osync_mapping_entry_update(OSyncMappingEntry *entry, OSyn
	OSyncChange osync_mapping_entry_get_change(OSyncMappingEntry entry);	cChange *change);
		OSYNC_EXPORT OSyncChange *osync_mapping_entry_get_change(OSyncMappingEntry
		*entry);


	osync_bool osync_mapping_entry_is_dirty(OSyncMappingEntry *entry);	OSYNC_EXPORT osync_bool osync_mapping_entry_is_dirty(OSyncMappingEntry *ent
	void osync_mapping_entry_set_dirty(OSyncMappingEntry *entry, osync_bool dir	ry);
	ty);*/	OSYNC_EXPORT void osync_mapping_entry_set_dirty(OSyncMappingEntry *entry, o
		sync_bool dirty);
		*/


	void osync_mapping_entry_set_uid(OSyncMappingEntry entry, const char uid)	OSYNC_EXPORT void osync_mapping_entry_set_uid(OSyncMappingEntry *entry, con
	;	st char *uid);
	const char osync_mapping_entry_get_uid(OSyncMappingEntry entry);	OSYNC_EXPORT const char osync_mapping_entry_get_uid(OSyncMappingEntry ent
		ry);


	long long int osync_mapping_entry_get_member_id(OSyncMappingEntry *entry);	OSYNC_EXPORT long long int osync_mapping_entry_get_member_id(OSyncMappingEn
	void osync_mapping_entry_set_member_id(OSyncMappingEntry *entry, long long	try *entry);
	int id);	OSYNC_EXPORT void osync_mapping_entry_set_member_id(OSyncMappingEntry *entr
		y, long long int id);


	long long int osync_mapping_entry_get_id(OSyncMappingEntry *entry);	OSYNC_EXPORT long long int osync_mapping_entry_get_id(OSyncMappingEntry *en
	void osync_mapping_entry_set_id(OSyncMappingEntry *entry, long long int id)	try);
	;	OSYNC_EXPORT void osync_mapping_entry_set_id(OSyncMappingEntry *entry, long
		long int id);

	#endif /OPENSYNC_MAPPING_ENTRY_H_/	#endif /OPENSYNC_MAPPING_ENTRY_H_/

End of changes. 7 change blocks.
	19 lines changed or deleted	28 lines changed or added

	opensync_mapping_table.h	opensync_mapping_table.h

	skipping to change at line 24	skipping to change at line 24
	*	*
	* You should have received a copy of the GNU Lesser General Public	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef OPENSYNC_MAPPING_TABLE_H_	#ifndef OPENSYNC_MAPPING_TABLE_H_
	#define OPENSYNC_MAPPING_TABLE_H_	#define OPENSYNC_MAPPING_TABLE_H_


	OSyncMappingTable osync_mapping_table_new(OSyncError *error);	OSYNC_EXPORT OSyncMappingTable osync_mapping_table_new(OSyncError *error)
	void osync_mapping_table_ref(OSyncMappingTable *table);	;
	void osync_mapping_table_unref(OSyncMappingTable *table);	OSYNC_EXPORT OSyncMappingTable osync_mapping_table_ref(OSyncMappingTable
		table);
		OSYNC_EXPORT void osync_mapping_table_unref(OSyncMappingTable *table);


	osync_bool osync_mapping_table_load(OSyncMappingTable *table, OSyncArchive	OSYNC_EXPORT osync_bool osync_mapping_table_load(OSyncMappingTable *table,
	archive, const char objtype, OSyncError **error);	OSyncArchive archive, const char objtype, OSyncError **error);
	osync_bool osync_mapping_table_flush(OSyncMappingTable *table, OSyncArchive	OSYNC_EXPORT osync_bool osync_mapping_table_flush(OSyncMappingTable *table,
	archive, const char objtype, OSyncError **error);	OSyncArchive archive, const char objtype, OSyncError **error);


	void osync_mapping_table_close(OSyncMappingTable *table);	OSYNC_EXPORT void osync_mapping_table_close(OSyncMappingTable *table);


	/*	//OSYNC_EXPORT void osync_mapping_table_add_view(OSyncMappingTable *table,
	void osync_mapping_table_add_view(OSyncMappingTable *table, OSyncMappingVie	OSyncMappingView *view);
	w *view);
	*/


	OSyncMapping osync_mapping_table_find_mapping(OSyncMappingTable table, lo	OSYNC_EXPORT OSyncMapping *osync_mapping_table_find_mapping(OSyncMappingTab
	ng long int id);	le *table, long long int id);
	void osync_mapping_table_add_mapping(OSyncMappingTable *table, OSyncMapping	OSYNC_EXPORT void osync_mapping_table_add_mapping(OSyncMappingTable *table,
	*mapping);	OSyncMapping *mapping);
	void osync_mapping_table_remove_mapping(OSyncMappingTable *table, OSyncMapp	OSYNC_EXPORT void osync_mapping_table_remove_mapping(OSyncMappingTable *tab
	ing *mapping);	le, OSyncMapping *mapping);
	int osync_mapping_table_num_mappings(OSyncMappingTable *table);	OSYNC_EXPORT int osync_mapping_table_num_mappings(OSyncMappingTable *table)
	OSyncMapping osync_mapping_table_nth_mapping(OSyncMappingTable table, int	;
	nth);	OSYNC_EXPORT OSyncMapping *osync_mapping_table_nth_mapping(OSyncMappingTabl
		e *table, int nth);


	long long int osync_mapping_table_get_next_id(OSyncMappingTable *table);	OSYNC_EXPORT long long int osync_mapping_table_get_next_id(OSyncMappingTabl e *table);

	#endif /OPENSYNC_MAPPING_TABLE_H_/	#endif /OPENSYNC_MAPPING_TABLE_H_/

End of changes. 6 change blocks.
	22 lines changed or deleted	23 lines changed or added

	opensync_merger.h	opensync_merger.h

	skipping to change at line 27	skipping to change at line 27
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	* Author: Daniel Friedrich <daniel.friedrich@opensync.org>	* Author: Daniel Friedrich <daniel.friedrich@opensync.org>
	*	*
	*/	*/

	#ifndef OPENSYNC_MERGER_H_	#ifndef OPENSYNC_MERGER_H_
	#define OPENSYNC_MERGER_H_	#define OPENSYNC_MERGER_H_

	OSYNC_EXPORT OSyncMerger osync_merger_new(OSyncCapabilities capabilities, OSyncError **error);	OSYNC_EXPORT OSyncMerger osync_merger_new(OSyncCapabilities capabilities, OSyncError **error);

	OSYNC_EXPORT void osync_merger_ref(OSyncMerger *merger);	OSYNC_EXPORT OSyncMerger osync_merger_ref(OSyncMerger merger);
	OSYNC_EXPORT void osync_merger_unref(OSyncMerger *merger);	OSYNC_EXPORT void osync_merger_unref(OSyncMerger *merger);

	OSYNC_EXPORT void osync_merger_merge(OSyncMerger merger, OSyncXMLFormat x mlformat, OSyncXMLFormat *entire);	OSYNC_EXPORT void osync_merger_merge(OSyncMerger merger, OSyncXMLFormat x mlformat, OSyncXMLFormat *entire);
	OSYNC_EXPORT void osync_merger_demerge(OSyncMerger merger, OSyncXMLFormat xmlformat);	OSYNC_EXPORT void osync_merger_demerge(OSyncMerger merger, OSyncXMLFormat xmlformat);

	#endif /OPENSYNC_MERGER_H_/	#endif /OPENSYNC_MERGER_H_/

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync_message.h	opensync_message.h

	skipping to change at line 50	skipping to change at line 50

	/*! @brief Function which can receive messages	/*! @brief Function which can receive messages
	*	*
	* @param sender The sender of the received reply	* @param sender The sender of the received reply
	* @param message The reply that is being received.	* @param message The reply that is being received.
	* @param user_data The userdata which was set previously	* @param user_data The userdata which was set previously
	*	*
	*/	*/
	typedef void (OSyncMessageHandler)(OSyncMessage message, void *user_data) ;	typedef void (OSyncMessageHandler)(OSyncMessage message, void *user_data) ;


	OSyncMessage *osync_message_new(OSyncMessageCommand cmd, int size, OSyncErr	OSYNC_EXPORT OSyncMessage *osync_message_new(OSyncMessageCommand cmd, int s
	or **error);	ize, OSyncError **error);
	OSyncMessage osync_message_new_reply(OSyncMessage message, OSyncError **e	OSYNC_EXPORT OSyncMessage osync_message_new_reply(OSyncMessage message, O
	rror);	SyncError **error);
	OSyncMessage osync_message_new_errorreply(OSyncMessage message, OSyncErro	OSYNC_EXPORT OSyncMessage osync_message_new_errorreply(OSyncMessage messa
	r error, OSyncError *loc_error);	ge, OSyncError error, OSyncError *loc_error);
	OSyncMessage osync_message_new_error(OSyncError error, OSyncError **loc_e	OSYNC_EXPORT OSyncMessage osync_message_new_error(OSyncError error, OSync
	rror);	Error **loc_error);
	OSyncMessage osync_message_new_queue_error(OSyncError error, OSyncError *	OSYNC_EXPORT OSyncMessage osync_message_new_queue_error(OSyncError error,
	*loc_error);	OSyncError **loc_error);
	void osync_message_ref(OSyncMessage *message);	OSYNC_EXPORT OSyncMessage osync_message_ref(OSyncMessage message);
	void osync_message_unref(OSyncMessage *message);	OSYNC_EXPORT void osync_message_unref(OSyncMessage *message);


	void osync_message_set_cmd(OSyncMessage *message, OSyncMessageCommand cmd);	OSYNC_EXPORT void osync_message_set_cmd(OSyncMessage *message, OSyncMessage
	OSyncMessageCommand osync_message_get_cmd(OSyncMessage *message);	Command cmd);
	void osync_message_set_id(OSyncMessage *message, long long int id);	OSYNC_EXPORT OSyncMessageCommand osync_message_get_cmd(OSyncMessage *messag
	long long int osync_message_get_id(OSyncMessage *message);	e);
	unsigned int osync_message_get_message_size(OSyncMessage *message);	OSYNC_EXPORT void osync_message_set_id(OSyncMessage *message, long long int
	void osync_message_set_message_size(OSyncMessage *message, unsigned int siz	id);
	e);	OSYNC_EXPORT long long int osync_message_get_id(OSyncMessage *message);
	void osync_message_get_buffer(OSyncMessage message, char *data, unsigned	OSYNC_EXPORT unsigned int osync_message_get_message_size(OSyncMessage *mess
	int *size);	age);
		OSYNC_EXPORT void osync_message_set_message_size(OSyncMessage *message, uns
		igned int size);
		OSYNC_EXPORT void osync_message_get_buffer(OSyncMessage message, char *da
		ta, unsigned int *size);


	void osync_message_set_handler(OSyncMessage *message, OSyncMessageHandler h	OSYNC_EXPORT void osync_message_set_handler(OSyncMessage *message, OSyncMes
	andler, void *user_data);	sageHandler handler, void *user_data);
	OSyncMessageHandler osync_message_get_handler(OSyncMessage *message);	OSYNC_EXPORT OSyncMessageHandler osync_message_get_handler(OSyncMessage *me
	void osync_message_get_handler_data(OSyncMessage message);	ssage);
		OSYNC_EXPORT void osync_message_get_handler_data(OSyncMessage message);


	osync_bool osync_message_is_error(OSyncMessage *message);	OSYNC_EXPORT osync_bool osync_message_is_error(OSyncMessage *message);
	osync_bool osync_message_send_message(OSyncMessage message, OSyncError *e	OSYNC_EXPORT osync_bool osync_message_send_message(OSyncMessage *message, O
	rror);	SyncError **error);
	osync_bool osync_message_send_with_timeout(OSyncMessage *message, OSyncQueu	OSYNC_EXPORT osync_bool osync_message_send_with_timeout(OSyncMessage *messa
	e queue, OSyncQueue replyQueue, int timeout, OSyncError **error);	ge, OSyncQueue queue, OSyncQueue replyQueue, int timeout, OSyncError **er
	OSyncMessageCommand osync_message_get_command(OSyncMessage *message);	ror);
	char* osync_message_get_commandstr(OSyncMessage *message);	OSYNC_EXPORT OSyncMessageCommand osync_message_get_command(OSyncMessage *me
	void osync_message_reset_timeout(OSyncMessage *message);	ssage);
	osync_bool osync_message_is_answered(OSyncMessage *message);	OSYNC_EXPORT char* osync_message_get_commandstr(OSyncMessage *message);
	void osync_message_set_answered(OSyncMessage *message);	OSYNC_EXPORT void osync_message_reset_timeout(OSyncMessage *message);
		OSYNC_EXPORT osync_bool osync_message_is_answered(OSyncMessage *message);
		OSYNC_EXPORT void osync_message_set_answered(OSyncMessage *message);


	void osync_message_write_int(OSyncMessage *message, int value);	OSYNC_EXPORT void osync_message_write_int(OSyncMessage *message, int value)
	void osync_message_write_long_long_int(OSyncMessage *message, long long int	;
	value);	OSYNC_EXPORT void osync_message_write_long_long_int(OSyncMessage *message,
	void osync_message_write_string(OSyncMessage message, const char value);	long long int value);
	void osync_message_write_data(OSyncMessage message, const void value, int	OSYNC_EXPORT void osync_message_write_string(OSyncMessage *message, const c
	size);	har *value);
	void osync_message_write_buffer(OSyncMessage message, const void value, i	OSYNC_EXPORT void osync_message_write_data(OSyncMessage *message, const voi
	nt size);	d *value, int size);
		OSYNC_EXPORT void osync_message_write_buffer(OSyncMessage *message, const v
		oid *value, int size);


	void osync_message_read_int(OSyncMessage message, int value);	OSYNC_EXPORT void osync_message_read_int(OSyncMessage message, int value)
	void osync_message_read_long_long_int(OSyncMessage *message, long long int	;
	*value);	OSYNC_EXPORT void osync_message_read_long_long_int(OSyncMessage *message, l
	void osync_message_read_string(OSyncMessage message, char *value);	ong long int *value);
	void osync_message_read_data(OSyncMessage message, void value, int size);	OSYNC_EXPORT void osync_message_read_string(OSyncMessage message, char *v
	void osync_message_read_const_data(OSyncMessage message, void *value, int	alue);
	size);	OSYNC_EXPORT void osync_message_read_data(OSyncMessage message, void valu
	void osync_message_read_const_string(OSyncMessage message, char *value);	e, int size);
	void osync_message_read_buffer(OSyncMessage message, void value, int si	OSYNC_EXPORT void osync_message_read_const_data(OSyncMessage *message, void
	ze);	**value, int size);
		OSYNC_EXPORT void osync_message_read_const_string(OSyncMessage *message, ch
		ar **value);
		OSYNC_EXPORT void osync_message_read_buffer(OSyncMessage message, void *v
		alue, int *size);

	#endif //_OPENSYNC_MESSAGES_H	#endif //_OPENSYNC_MESSAGES_H

End of changes. 6 change blocks.
	53 lines changed or deleted	66 lines changed or added

	opensync_obj_engine.h	opensync_obj_engine.h

	skipping to change at line 26	skipping to change at line 26
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef OPENSYNC_OBJ_ENGINE_H_	#ifndef OPENSYNC_OBJ_ENGINE_H_
	#define OPENSYNC_OBJ_ENGINE_H_	#define OPENSYNC_OBJ_ENGINE_H_

	typedef void (* OSyncObjEngineEventCallback) (OSyncObjEngine engine, OSync EngineEvent event, OSyncError error, void *userdata);	typedef void (* OSyncObjEngineEventCallback) (OSyncObjEngine engine, OSync EngineEvent event, OSyncError error, void *userdata);


	OSyncObjEngine osync_obj_engine_new(OSyncEngine engine, const char *objty	OSYNC_EXPORT OSyncObjEngine osync_obj_engine_new(OSyncEngine engine, cons
	pe, OSyncFormatEnv formatenv, OSyncError *error);	t char objtype, OSyncFormatEnv formatenv, OSyncError **error);
	void osync_obj_engine_ref(OSyncObjEngine *engine);	OSYNC_EXPORT OSyncObjEngine osync_obj_engine_ref(OSyncObjEngine engine);
	void osync_obj_engine_unref(OSyncObjEngine *engine);	OSYNC_EXPORT void osync_obj_engine_unref(OSyncObjEngine *engine);

	osync_bool osync_obj_engine_initialize(OSyncObjEngine engine, OSyncError
	*error);
	void osync_obj_engine_finalize(OSyncObjEngine *engine);

	const char osync_obj_engine_get_objtype(OSyncObjEngine engine);

	void osync_obj_engine_set_slowsync(OSyncObjEngine *engine, osync_bool slows
	ync);
	osync_bool osync_obj_engine_get_slowsync(OSyncObjEngine *engine);


	void osync_obj_engine_event(OSyncObjEngine *objengine, OSyncEngineEvent eve	OSYNC_EXPORT osync_bool osync_obj_engine_initialize(OSyncObjEngine *engine,
	nt);	OSyncError **error);
	osync_bool osync_obj_engine_command(OSyncObjEngine *engine, OSyncEngineCmd	OSYNC_EXPORT void osync_obj_engine_finalize(OSyncObjEngine *engine);
	cmd, OSyncError **error);
	void osync_obj_engine_set_callback(OSyncObjEngine *engine, OSyncObjEngineEv
	entCallback callback, void *userdata);
	osync_bool osync_obj_engine_receive_change(OSyncObjEngine *objengine, OSync
	ClientProxy proxy, OSyncChange change, OSyncError **error);


	void osync_obj_engine_set_error(OSyncObjEngine engine, OSyncError error);	OSYNC_EXPORT const char osync_obj_engine_get_objtype(OSyncObjEngine engin e);


	int osync_mapping_engine_num_changes(OSyncMappingEngine *engine);	OSYNC_EXPORT void osync_obj_engine_set_slowsync(OSyncObjEngine *engine, osy
	OSyncChange osync_mapping_engine_nth_change(OSyncMappingEngine engine, in	nc_bool slowsync);
	t nth);	OSYNC_EXPORT osync_bool osync_obj_engine_get_slowsync(OSyncObjEngine *engin
	OSyncChange osync_mapping_engine_member_change(OSyncMappingEngine engine,	e);
	int memberid);
	OSyncMember osync_mapping_engine_change_find_member(OSyncMappingEngine en
	gine, OSyncChange *change);


	osync_bool osync_mapping_engine_supports_ignore(OSyncMappingEngine *engine)	OSYNC_EXPORT void osync_obj_engine_event(OSyncObjEngine *objengine, OSyncEn
	;	gineEvent event);
	osync_bool osync_mapping_engine_supports_use_latest(OSyncMappingEngine *eng	OSYNC_EXPORT osync_bool osync_obj_engine_command(OSyncObjEngine *engine, OS
	ine);	yncEngineCmd cmd, OSyncError **error);
		OSYNC_EXPORT void osync_obj_engine_set_callback(OSyncObjEngine *engine, OSy
		ncObjEngineEventCallback callback, void *userdata);
		OSYNC_EXPORT osync_bool osync_obj_engine_receive_change(OSyncObjEngine *obj
		engine, OSyncClientProxy proxy, OSyncChange change, OSyncError **error);


	osync_bool osync_mapping_engine_solve(OSyncMappingEngine *engine, OSyncChan	OSYNC_EXPORT void osync_obj_engine_set_error(OSyncObjEngine *engine, OSyncE
	ge change, OSyncError *error);	rror *error);
	osync_bool osync_mapping_engine_ignore(OSyncMappingEngine *engine, OSyncErr
	or **error);
	osync_bool osync_mapping_engine_use_latest(OSyncMappingEngine *engine, OSyn
	cError **error);
	osync_bool osync_mapping_engine_duplicate(OSyncMappingEngine *existingMappi
	ng, OSyncError **error);

	#endif /OPENSYNC_OBJ_ENGINE_H_/	#endif /OPENSYNC_OBJ_ENGINE_H_/

End of changes. 6 change blocks.
	42 lines changed or deleted	22 lines changed or added

	opensync_plugin_info.h	opensync_plugin_info.h
	#ifndef OPENSYNC_PLUGIN_INFO_H_	#ifndef OPENSYNC_PLUGIN_INFO_H_
	#define OPENSYNC_PLUGIN_INFO_H_	#define OPENSYNC_PLUGIN_INFO_H_

	OSYNC_EXPORT OSyncPluginInfo osync_plugin_info_new(OSyncError *error);	OSYNC_EXPORT OSyncPluginInfo osync_plugin_info_new(OSyncError *error);

	OSYNC_EXPORT void osync_plugin_info_ref(OSyncPluginInfo *info);	OSYNC_EXPORT OSyncPluginInfo osync_plugin_info_ref(OSyncPluginInfo info);
	OSYNC_EXPORT void osync_plugin_info_unref(OSyncPluginInfo *info);	OSYNC_EXPORT void osync_plugin_info_unref(OSyncPluginInfo *info);

	OSYNC_EXPORT void osync_plugin_info_set_loop(OSyncPluginInfo info, void l oop);	OSYNC_EXPORT void osync_plugin_info_set_loop(OSyncPluginInfo info, void l oop);
	OSYNC_EXPORT void osync_plugin_info_get_loop(OSyncPluginInfo info);	OSYNC_EXPORT void osync_plugin_info_get_loop(OSyncPluginInfo info);

	OSYNC_EXPORT void osync_plugin_info_set_config(OSyncPluginInfo info, const char config);	OSYNC_EXPORT void osync_plugin_info_set_config(OSyncPluginInfo info, const char config);
	OSYNC_EXPORT const char osync_plugin_info_get_config(OSyncPluginInfo info );	OSYNC_EXPORT const char osync_plugin_info_get_config(OSyncPluginInfo info );

	OSYNC_EXPORT void osync_plugin_info_set_configdir(OSyncPluginInfo info, co nst char configdir);	OSYNC_EXPORT void osync_plugin_info_set_configdir(OSyncPluginInfo info, co nst char configdir);
	OSYNC_EXPORT const char osync_plugin_info_get_configdir(OSyncPluginInfo i nfo);	OSYNC_EXPORT const char osync_plugin_info_get_configdir(OSyncPluginInfo i nfo);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync_queue.h	opensync_queue.h

	skipping to change at line 25	skipping to change at line 25
	OSYNC_QUEUE_EVENT_READ,	OSYNC_QUEUE_EVENT_READ,
	OSYNC_QUEUE_EVENT_ERROR,	OSYNC_QUEUE_EVENT_ERROR,
	OSYNC_QUEUE_EVENT_HUP	OSYNC_QUEUE_EVENT_HUP
	} OSyncQueueEvent;	} OSyncQueueEvent;

	typedef enum {	typedef enum {
	OSYNC_QUEUE_SENDER,	OSYNC_QUEUE_SENDER,
	OSYNC_QUEUE_RECEIVER	OSYNC_QUEUE_RECEIVER
	} OSyncQueueType;	} OSyncQueueType;


	OSyncQueue osync_queue_new(const char name, OSyncError **error);	OSYNC_EXPORT OSyncQueue osync_queue_new(const char name, OSyncError **err
	OSyncQueue osync_queue_new_from_fd(int fd, OSyncError *error);	or);
	osync_bool osync_queue_new_pipes(OSyncQueue read_queue, OSyncQueue writ	OSYNC_EXPORT OSyncQueue osync_queue_new_from_fd(int fd, OSyncError *error
	e_queue, OSyncError **error);	);
	osync_bool osync_queue_create(OSyncQueue queue, OSyncError *error);	OSYNC_EXPORT osync_bool osync_queue_new_pipes(OSyncQueue **read_queue, OSyn
		cQueue write_queue, OSyncError error);
		OSYNC_EXPORT osync_bool osync_queue_create(OSyncQueue queue, OSyncError *
		error);


	void osync_queue_free(OSyncQueue *queue);	OSYNC_EXPORT void osync_queue_free(OSyncQueue *queue);
	osync_bool osync_queue_remove(OSyncQueue queue, OSyncError *error);	OSYNC_EXPORT osync_bool osync_queue_remove(OSyncQueue queue, OSyncError *
	osync_bool osync_queue_exists(OSyncQueue *queue);	error);
		OSYNC_EXPORT osync_bool osync_queue_exists(OSyncQueue *queue);


	osync_bool osync_queue_connect(OSyncQueue *queue, OSyncQueueType type, OSyn	OSYNC_EXPORT osync_bool osync_queue_connect(OSyncQueue *queue, OSyncQueueTy
	cError **error);	pe type, OSyncError **error);
	osync_bool osync_queue_disconnect(OSyncQueue queue, OSyncError *error);	OSYNC_EXPORT osync_bool osync_queue_disconnect(OSyncQueue *queue, OSyncErro
	osync_bool osync_queue_is_connected(OSyncQueue *queue);	r **error);
		OSYNC_EXPORT osync_bool osync_queue_is_connected(OSyncQueue *queue);


	void osync_queue_set_message_handler(OSyncQueue *queue, OSyncMessageHandler	OSYNC_EXPORT void osync_queue_set_message_handler(OSyncQueue *queue, OSyncM
	handler, gpointer user_data);	essageHandler handler, gpointer user_data);
	osync_bool osync_queue_send_message(OSyncQueue queue, OSyncQueue replyque	OSYNC_EXPORT osync_bool osync_queue_send_message(OSyncQueue *queue, OSyncQu
	ue, OSyncMessage message, OSyncError *error);	eue replyqueue, OSyncMessage message, OSyncError **error);
	osync_bool osync_queue_send_message_with_timeout(OSyncQueue *queue, OSyncQu	OSYNC_EXPORT osync_bool osync_queue_send_message_with_timeout(OSyncQueue *q
	eue replyqueue, OSyncMessage message, int timeout, OSyncError **error);	ueue, OSyncQueue replyqueue, OSyncMessage message, int timeout, OSyncErro
		r **error);


	void osync_queue_setup_with_gmainloop(OSyncQueue queue, GMainContext cont	OSYNC_EXPORT void osync_queue_setup_with_gmainloop(OSyncQueue *queue, GMain
	ext);	Context *context);
	osync_bool osync_queue_dispatch(OSyncQueue queue, OSyncError *error);	OSYNC_EXPORT osync_bool osync_queue_dispatch(OSyncQueue *queue, OSyncError
		**error);


	OSyncQueueEvent osync_queue_poll(OSyncQueue *queue);	OSYNC_EXPORT OSyncQueueEvent osync_queue_poll(OSyncQueue *queue);


	OSyncMessage osync_queue_get_message(OSyncQueue queue);	OSYNC_EXPORT OSyncMessage osync_queue_get_message(OSyncQueue queue);
	const char osync_queue_get_path(OSyncQueue queue);	OSYNC_EXPORT const char osync_queue_get_path(OSyncQueue queue);
	int osync_queue_get_fd(OSyncQueue *queue);	OSYNC_EXPORT int osync_queue_get_fd(OSyncQueue *queue);


	osync_bool osync_queue_is_alive(OSyncQueue *queue);	OSYNC_EXPORT osync_bool osync_queue_is_alive(OSyncQueue *queue);

	#endif //_OPENSYNC_QUEUE_H	#endif //_OPENSYNC_QUEUE_H

End of changes. 8 change blocks.
	26 lines changed or deleted	33 lines changed or added

	opensync_status.h	opensync_status.h

	skipping to change at line 24	skipping to change at line 24
	*	*
	* You should have received a copy of the GNU Lesser General Public	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*	*
	*/	*/

	#ifndef OPENSYNC_STATUS_H_	#ifndef OPENSYNC_STATUS_H_
	#define OPENSYNC_STATUS_H_	#define OPENSYNC_STATUS_H_


	void osync_status_free_member_update(OSyncMemberUpdate *update);	OSYNC_EXPORT void osync_status_free_member_update(OSyncMemberUpdate *update
	void osync_status_free_engine_update(OSyncEngineUpdate *update);	);
	void osync_status_free_change_update(OSyncChangeUpdate *update);	OSYNC_EXPORT void osync_status_free_engine_update(OSyncEngineUpdate *update
	void osync_status_free_mapping_update(OSyncMappingUpdate *update);	);
		OSYNC_EXPORT void osync_status_free_change_update(OSyncChangeUpdate *update
		);
		OSYNC_EXPORT void osync_status_free_mapping_update(OSyncMappingUpdate *upda
		te);


	void osync_status_update_member(OSyncEngine engine, OSyncMember member, O	OSYNC_EXPORT void osync_status_update_member(OSyncEngine *engine, OSyncMemb
	SyncMemberEvent type, const char objtype, OSyncError error);	er member, OSyncMemberEvent type, const char objtype, OSyncError *error);
	void osync_status_update_engine(OSyncEngine *engine, OSyncEngineEvent type,	OSYNC_EXPORT void osync_status_update_engine(OSyncEngine *engine, OSyncEngi
	OSyncError *error);	neEvent type, OSyncError *error);
	void osync_status_update_change(OSyncEngine engine, OSyncChange change, O	OSYNC_EXPORT void osync_status_update_change(OSyncEngine *engine, OSyncChan
	SyncMember member, OSyncMapping mapping, OSyncChangeEvent type, OSyncErro	ge change, OSyncMember member, OSyncMapping *mapping, OSyncChangeEvent ty
	r *error);	pe, OSyncError *error);
	void osync_status_update_mapping(OSyncEngine engine, OSyncMappingEngine m	OSYNC_EXPORT void osync_status_update_mapping(OSyncEngine *engine, OSyncMap
	apping, OSyncMappingEvent type, OSyncError *error);	pingEngine mapping, OSyncMappingEvent type, OSyncError error);
	void osync_status_conflict(OSyncEngine engine, OSyncMappingEngine mapping	OSYNC_EXPORT void osync_status_conflict(OSyncEngine *engine, OSyncMappingEn
	_engine);	gine *mapping_engine);

	#endif /OPENSYNC_STATUS_H_/	#endif /OPENSYNC_STATUS_H_/

End of changes. 2 change blocks.
	15 lines changed or deleted	19 lines changed or added

	opensync_xmlformat.h	opensync_xmlformat.h

	skipping to change at line 41	skipping to change at line 41
	/** The name of a xmlfield */	/** The name of a xmlfield */
	char *fieldname;	char *fieldname;
	/** The points for this xmlfield */	/** The points for this xmlfield */
	int points;	int points;
	/** The keys of a xmlfield which have to be the same for equality. T his array must end with NULL. */	/** The keys of a xmlfield which have to be the same for equality. T his array must end with NULL. */
	char** keys;	char** keys;
	} OSyncXMLPoints;	} OSyncXMLPoints;

	OSYNC_EXPORT OSyncXMLFormat osync_xmlformat_new(const char objtype, OSync Error **error);	OSYNC_EXPORT OSyncXMLFormat osync_xmlformat_new(const char objtype, OSync Error **error);
	OSYNC_EXPORT OSyncXMLFormat osync_xmlformat_parse(const char buffer, unsi gned int size, OSyncError **error);	OSYNC_EXPORT OSyncXMLFormat osync_xmlformat_parse(const char buffer, unsi gned int size, OSyncError **error);

	OSYNC_EXPORT void osync_xmlformat_ref(OSyncXMLFormat *xmlformat);	OSYNC_EXPORT OSyncXMLFormat osync_xmlformat_ref(OSyncXMLFormat xmlformat) ;
	OSYNC_EXPORT void osync_xmlformat_unref(OSyncXMLFormat *xmlformat);	OSYNC_EXPORT void osync_xmlformat_unref(OSyncXMLFormat *xmlformat);

	OSYNC_EXPORT const char osync_xmlformat_root_name(OSyncXMLFormat xmlforma t);	OSYNC_EXPORT const char osync_xmlformat_root_name(OSyncXMLFormat xmlforma t);
	OSYNC_EXPORT const char osync_xmlformat_get_objtype(OSyncXMLFormat xmlfor mat);	OSYNC_EXPORT const char osync_xmlformat_get_objtype(OSyncXMLFormat xmlfor mat);

	OSYNC_EXPORT OSyncXMLField osync_xmlformat_get_first_field(OSyncXMLFormat xmlformat);	OSYNC_EXPORT OSyncXMLField osync_xmlformat_get_first_field(OSyncXMLFormat xmlformat);
	OSYNC_EXPORT OSyncXMLFieldList osync_xmlformat_search_field(OSyncXMLFormat xmlformat, const char name, OSyncError *error, ...);	OSYNC_EXPORT OSyncXMLFieldList osync_xmlformat_search_field(OSyncXMLFormat xmlformat, const char name, OSyncError *error, ...);

	OSYNC_EXPORT osync_bool osync_xmlformat_assemble(OSyncXMLFormat xmlformat, char buffer, unsigned int size);	OSYNC_EXPORT osync_bool osync_xmlformat_assemble(OSyncXMLFormat xmlformat, char buffer, unsigned int size);
	OSYNC_EXPORT osync_bool osync_xmlformat_validate(OSyncXMLFormat *xmlformat) ;	OSYNC_EXPORT osync_bool osync_xmlformat_validate(OSyncXMLFormat *xmlformat) ;

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	opensync_plugin_info.h	opensync_plugin_info.h
	#ifndef OPENSYNC_PLUGIN_INFO_H_	#ifndef OPENSYNC_PLUGIN_INFO_H_
	#define OPENSYNC_PLUGIN_INFO_H_	#define OPENSYNC_PLUGIN_INFO_H_

	OSYNC_EXPORT OSyncPluginInfo osync_plugin_info_new(OSyncError *error);	OSYNC_EXPORT OSyncPluginInfo osync_plugin_info_new(OSyncError *error);

	OSYNC_EXPORT void osync_plugin_info_ref(OSyncPluginInfo *info);	OSYNC_EXPORT OSyncPluginInfo osync_plugin_info_ref(OSyncPluginInfo info);
	OSYNC_EXPORT void osync_plugin_info_unref(OSyncPluginInfo *info);	OSYNC_EXPORT void osync_plugin_info_unref(OSyncPluginInfo *info);

	OSYNC_EXPORT void osync_plugin_info_set_loop(OSyncPluginInfo info, void l oop);	OSYNC_EXPORT void osync_plugin_info_set_loop(OSyncPluginInfo info, void l oop);
	OSYNC_EXPORT void osync_plugin_info_get_loop(OSyncPluginInfo info);	OSYNC_EXPORT void osync_plugin_info_get_loop(OSyncPluginInfo info);

	OSYNC_EXPORT void osync_plugin_info_set_config(OSyncPluginInfo info, const char config);	OSYNC_EXPORT void osync_plugin_info_set_config(OSyncPluginInfo info, const char config);
	OSYNC_EXPORT const char osync_plugin_info_get_config(OSyncPluginInfo info );	OSYNC_EXPORT const char osync_plugin_info_get_config(OSyncPluginInfo info );

	OSYNC_EXPORT void osync_plugin_info_set_configdir(OSyncPluginInfo info, co nst char configdir);	OSYNC_EXPORT void osync_plugin_info_set_configdir(OSyncPluginInfo info, co nst char configdir);
	OSYNC_EXPORT const char osync_plugin_info_get_configdir(OSyncPluginInfo i nfo);	OSYNC_EXPORT const char osync_plugin_info_get_configdir(OSyncPluginInfo i nfo);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync-error.h	opensync-error.h

	skipping to change at line 51	skipping to change at line 51
	OSYNC_ERROR_MISCONFIGURATION = 9,	OSYNC_ERROR_MISCONFIGURATION = 9,
	OSYNC_ERROR_INITIALIZATION = 10,	OSYNC_ERROR_INITIALIZATION = 10,
	OSYNC_ERROR_PARAMETER = 11,	OSYNC_ERROR_PARAMETER = 11,
	OSYNC_ERROR_EXPECTED = 12,	OSYNC_ERROR_EXPECTED = 12,
	OSYNC_ERROR_NO_CONNECTION = 13,	OSYNC_ERROR_NO_CONNECTION = 13,
	OSYNC_ERROR_TEMPORARY = 14,	OSYNC_ERROR_TEMPORARY = 14,
	OSYNC_ERROR_LOCKED = 15,	OSYNC_ERROR_LOCKED = 15,
	OSYNC_ERROR_PLUGIN_NOT_FOUND = 16	OSYNC_ERROR_PLUGIN_NOT_FOUND = 16
	} OSyncErrorType;	} OSyncErrorType;


	OSYNC_EXPORT void osync_error_ref(OSyncError **error);	OSYNC_EXPORT OSyncError osync_error_ref(OSyncError error);
	OSYNC_EXPORT void osync_error_unref(OSyncError **error);	OSYNC_EXPORT void osync_error_unref(OSyncError **error);
	OSYNC_EXPORT osync_bool osync_error_is_set (OSyncError **error);	OSYNC_EXPORT osync_bool osync_error_is_set (OSyncError **error);
	OSYNC_EXPORT void osync_error_set(OSyncError *error, OSyncErrorType type, const char format, ...);	OSYNC_EXPORT void osync_error_set(OSyncError *error, OSyncErrorType type, const char format, ...);
	OSYNC_EXPORT const char osync_error_get_name(OSyncError *error);	OSYNC_EXPORT const char osync_error_get_name(OSyncError *error);
	OSYNC_EXPORT void osync_error_set_from_error(OSyncError target, OSyncErro r source);	OSYNC_EXPORT void osync_error_set_from_error(OSyncError target, OSyncErro r source);
	OSYNC_EXPORT const char osync_error_print(OSyncError *error);	OSYNC_EXPORT const char osync_error_print(OSyncError *error);
	OSYNC_EXPORT char osync_error_print_stack(OSyncError *error);	OSYNC_EXPORT char osync_error_print_stack(OSyncError *error);
	OSYNC_EXPORT void osync_error_stack(OSyncError parent, OSyncError child );	OSYNC_EXPORT void osync_error_stack(OSyncError parent, OSyncError child );
	OSYNC_EXPORT OSyncError osync_error_get_child(OSyncError *parent);	OSYNC_EXPORT OSyncError osync_error_get_child(OSyncError *parent);
	OSYNC_EXPORT OSyncErrorType osync_error_get_type(OSyncError **error);	OSYNC_EXPORT OSyncErrorType osync_error_get_type(OSyncError **error);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync_archive.h	opensync_archive.h

	skipping to change at line 29	skipping to change at line 29
	*	*
	* Author: Armin Bauer <armin.bauer@opensync.org>	* Author: Armin Bauer <armin.bauer@opensync.org>
	* Author: Daniel Friedrich <daniel.friedrich@opensync.org>	* Author: Daniel Friedrich <daniel.friedrich@opensync.org>
	*	*
	*/	*/

	#ifndef OPENSYNC_ARCHIVE_H_	#ifndef OPENSYNC_ARCHIVE_H_
	#define OPENSYNC_ARCHIVE_H_	#define OPENSYNC_ARCHIVE_H_

	OSYNC_EXPORT OSyncArchive osync_archive_new(const char filename, OSyncErr or **error);	OSYNC_EXPORT OSyncArchive osync_archive_new(const char filename, OSyncErr or **error);

	OSYNC_EXPORT void osync_archive_ref(OSyncArchive *archive);	OSYNC_EXPORT OSyncArchive osync_archive_ref(OSyncArchive archive);
	OSYNC_EXPORT void osync_archive_unref(OSyncArchive *archive);	OSYNC_EXPORT void osync_archive_unref(OSyncArchive *archive);


	OSYNC_EXPORT osync_bool osync_archive_save_data(OSyncArchive archive, cons t char uid, const char objtype, const char data, unsigned int size, OSyn cError **error);	OSYNC_EXPORT osync_bool osync_archive_save_data(OSyncArchive archive, long long int id, const char objtype, const char data, unsigned int size, OSy ncError *error);
	OSYNC_EXPORT int osync_archive_load_data(OSyncArchive archive, const char uid, const char objtype, char data, unsigned int size, OSyncError **er ror);	OSYNC_EXPORT int osync_archive_load_data(OSyncArchive archive, const char uid, const char objtype, char data, unsigned int size, OSyncError **er ror);

	OSYNC_EXPORT long long int osync_archive_save_change(OSyncArchive archive, long long int id, const char uid, const char objtype, long long int mapp ingid, long long int memberid, OSyncError *error);	OSYNC_EXPORT long long int osync_archive_save_change(OSyncArchive archive, long long int id, const char uid, const char objtype, long long int mapp ingid, long long int memberid, OSyncError *error);
	OSYNC_EXPORT osync_bool osync_archive_delete_change(OSyncArchive archive, long long int id, const char objtype, OSyncError **error);	OSYNC_EXPORT osync_bool osync_archive_delete_change(OSyncArchive archive, long long int id, const char objtype, OSyncError **error);
	OSYNC_EXPORT osync_bool osync_archive_load_changes(OSyncArchive archive, c onst char objtype, OSyncList ids, OSyncList uids, OSyncList mappingi ds, OSyncList memberids, OSyncError **error);	OSYNC_EXPORT osync_bool osync_archive_load_changes(OSyncArchive archive, c onst char objtype, OSyncList ids, OSyncList uids, OSyncList mappingi ds, OSyncList memberids, OSyncError **error);
	OSYNC_EXPORT osync_bool osync_archive_flush_changes(OSyncArchive archive, const char objtype, OSyncError **error);	OSYNC_EXPORT osync_bool osync_archive_flush_changes(OSyncArchive archive, const char objtype, OSyncError **error);

	OSYNC_EXPORT osync_bool osync_archive_load_ignored_conflicts(OSyncArchive * archive, const char objtype, OSyncList mappingsids, OSyncList changety pes, OSyncError *error);	OSYNC_EXPORT osync_bool osync_archive_load_ignored_conflicts(OSyncArchive * archive, const char objtype, OSyncList mappingsids, OSyncList changety pes, OSyncError *error);
	OSYNC_EXPORT osync_bool osync_archive_save_ignored_conflict(OSyncArchive a rchive, const char objtype, long long int mappingid, OSyncChangeType chang etype, OSyncError **error);	OSYNC_EXPORT osync_bool osync_archive_save_ignored_conflict(OSyncArchive a rchive, const char objtype, long long int mappingid, OSyncChangeType chang etype, OSyncError **error);
	OSYNC_EXPORT osync_bool osync_archive_flush_ignored_conflict(OSyncArchive * archive, const char objtype, OSyncError *error);	OSYNC_EXPORT osync_bool osync_archive_flush_ignored_conflict(OSyncArchive * archive, const char objtype, OSyncError *error);

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	opensync_capabilities.h	opensync_capabilities.h

	skipping to change at line 28	skipping to change at line 28
	*	*
	* Author: Daniel Friedrich <daniel.friedrich@opensync.org>	* Author: Daniel Friedrich <daniel.friedrich@opensync.org>
	*	*
	*/	*/

	#ifndef OPENSYNC_CAPABILITIES_H_	#ifndef OPENSYNC_CAPABILITIES_H_
	#define OPENSYNC_CAPABILITIES_H_	#define OPENSYNC_CAPABILITIES_H_

	OSYNC_EXPORT OSyncCapabilities osync_capabilities_new(OSyncError *error);	OSYNC_EXPORT OSyncCapabilities osync_capabilities_new(OSyncError *error);
	OSYNC_EXPORT OSyncCapabilities osync_capabilities_parse(const char buffer , unsigned int size, OSyncError **error);	OSYNC_EXPORT OSyncCapabilities osync_capabilities_parse(const char buffer , unsigned int size, OSyncError **error);

	OSYNC_EXPORT void osync_capabilities_ref(OSyncCapabilities *capabilities);	OSYNC_EXPORT OSyncCapabilities osync_capabilities_ref(OSyncCapabilities c apabilities);
	OSYNC_EXPORT void osync_capabilities_unref(OSyncCapabilities *capabilities) ;	OSYNC_EXPORT void osync_capabilities_unref(OSyncCapabilities *capabilities) ;

	OSYNC_EXPORT OSyncCapability osync_capabilities_get_first(OSyncCapabilitie s capabilities, const char *objtype);	OSYNC_EXPORT OSyncCapability osync_capabilities_get_first(OSyncCapabilitie s capabilities, const char *objtype);
	OSYNC_EXPORT osync_bool osync_capabilities_assemble(OSyncCapabilities capa bilities, char buffer, int size);	OSYNC_EXPORT osync_bool osync_capabilities_assemble(OSyncCapabilities capa bilities, char buffer, int size);
	OSYNC_EXPORT void osync_capabilities_sort(OSyncCapabilities *capabilities);	OSYNC_EXPORT void osync_capabilities_sort(OSyncCapabilities *capabilities);

	OSYNC_EXPORT OSyncCapabilities osync_capabilities_load(const char file, O SyncError **error);	OSYNC_EXPORT OSyncCapabilities osync_capabilities_load(const char file, O SyncError **error);
	OSYNC_EXPORT osync_bool osync_capabilities_member_has_capabilities(OSyncMem ber *member);	OSYNC_EXPORT osync_bool osync_capabilities_member_has_capabilities(OSyncMem ber *member);
	OSYNC_EXPORT OSyncCapabilities* osync_capabilities_member_get_capabilities( OSyncMember member, OSyncError* error);	OSYNC_EXPORT OSyncCapabilities* osync_capabilities_member_get_capabilities( OSyncMember member, OSyncError* error);
	OSYNC_EXPORT osync_bool osync_capabilities_member_set_capabilities(OSyncMem ber member, OSyncCapabilities capabilities, OSyncError** error);	OSYNC_EXPORT osync_bool osync_capabilities_member_set_capabilities(OSyncMem ber member, OSyncCapabilities capabilities, OSyncError** error);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync_client_proxy.h	opensync_client_proxy.h

	skipping to change at line 38	skipping to change at line 38
	typedef void (* discover_cb) (OSyncClientProxy proxy, void userdata, OSyn cError *error);	typedef void (* discover_cb) (OSyncClientProxy proxy, void userdata, OSyn cError *error);
	typedef void (* connect_cb) (OSyncClientProxy proxy, void userdata, osync _bool slowsync, OSyncError *error);	typedef void (* connect_cb) (OSyncClientProxy proxy, void userdata, osync _bool slowsync, OSyncError *error);
	typedef void (* disconnect_cb) (OSyncClientProxy proxy, void userdata, OS yncError *error);	typedef void (* disconnect_cb) (OSyncClientProxy proxy, void userdata, OS yncError *error);
	typedef void (* read_cb) (OSyncClientProxy proxy, void userdata, OSyncErr or *error);	typedef void (* read_cb) (OSyncClientProxy proxy, void userdata, OSyncErr or *error);
	typedef void (* get_changes_cb) (OSyncClientProxy proxy, void userdata, O SyncError *error);	typedef void (* get_changes_cb) (OSyncClientProxy proxy, void userdata, O SyncError *error);
	typedef void (* change_cb) (OSyncClientProxy proxy, void userdata, OSyncC hange *change);	typedef void (* change_cb) (OSyncClientProxy proxy, void userdata, OSyncC hange *change);
	typedef void (* commit_change_cb) (OSyncClientProxy proxy, void userdata, const char uid, OSyncError error);	typedef void (* commit_change_cb) (OSyncClientProxy proxy, void userdata, const char uid, OSyncError error);
	typedef void (* committed_all_cb) (OSyncClientProxy proxy, void userdata, OSyncError *error);	typedef void (* committed_all_cb) (OSyncClientProxy proxy, void userdata, OSyncError *error);
	typedef void (* sync_done_cb) (OSyncClientProxy proxy, void userdata, OSy ncError *error);	typedef void (* sync_done_cb) (OSyncClientProxy proxy, void userdata, OSy ncError *error);


	OSyncClientProxy osync_client_proxy_new(OSyncFormatEnv formatenv, OSyncMe	OSYNC_EXPORT OSyncClientProxy osync_client_proxy_new(OSyncFormatEnv forma
	mber member, OSyncError *error);	tenv, OSyncMember member, OSyncError *error);
	void osync_client_proxy_ref(OSyncClientProxy *proxy);	OSYNC_EXPORT OSyncClientProxy osync_client_proxy_ref(OSyncClientProxy pro
	void osync_client_proxy_unref(OSyncClientProxy *proxy);	xy);
		OSYNC_EXPORT void osync_client_proxy_unref(OSyncClientProxy *proxy);


	void osync_client_proxy_set_context(OSyncClientProxy proxy, GMainContext	OSYNC_EXPORT void osync_client_proxy_set_context(OSyncClientProxy *proxy, G
	ctx);	MainContext *ctx);
	void osync_client_proxy_set_change_callback(OSyncClientProxy *proxy, change	OSYNC_EXPORT void osync_client_proxy_set_change_callback(OSyncClientProxy *
	_cb cb, void *userdata);	proxy, change_cb cb, void *userdata);
	OSyncMember osync_client_proxy_get_member(OSyncClientProxy proxy);	OSYNC_EXPORT OSyncMember osync_client_proxy_get_member(OSyncClientProxy p
		roxy);


	osync_bool osync_client_proxy_spawn(OSyncClientProxy *proxy, OSyncStartType	OSYNC_EXPORT osync_bool osync_client_proxy_spawn(OSyncClientProxy *proxy, O
	type, const char path, OSyncError *error);	SyncStartType type, const char path, OSyncError *error);
	osync_bool osync_client_proxy_shutdown(OSyncClientProxy *proxy, OSyncError	OSYNC_EXPORT osync_bool osync_client_proxy_shutdown(OSyncClientProxy *proxy
	**error);	, OSyncError **error);


	osync_bool osync_client_proxy_initialize(OSyncClientProxy *proxy, initializ	OSYNC_EXPORT osync_bool osync_client_proxy_initialize(OSyncClientProxy *pro
	e_cb callback, void userdata, const char formatdir, const char *plugindir	xy, initialize_cb callback, void userdata, const char formatdir, const ch
	, const char plugin, const char groupname, const char *configdir, const c	ar plugindir, const char plugin, const char groupname, const char confi
	har config, OSyncError *error);	gdir, const char config, OSyncError *error);
	osync_bool osync_client_proxy_finalize(OSyncClientProxy *proxy, finalize_cb	OSYNC_EXPORT osync_bool osync_client_proxy_finalize(OSyncClientProxy *proxy
	callback, void userdata, OSyncError *error);	, finalize_cb callback, void userdata, OSyncError *error);


	osync_bool osync_client_proxy_discover(OSyncClientProxy *proxy, discover_cb	OSYNC_EXPORT osync_bool osync_client_proxy_discover(OSyncClientProxy *proxy
	callback, void userdata, OSyncError *error);	, discover_cb callback, void userdata, OSyncError *error);
	int osync_client_proxy_num_objtypes(OSyncClientProxy *proxy);	OSYNC_EXPORT int osync_client_proxy_num_objtypes(OSyncClientProxy *proxy);
	OSyncObjTypeSink osync_client_proxy_nth_objtype(OSyncClientProxy proxy, i	OSYNC_EXPORT OSyncObjTypeSink *osync_client_proxy_nth_objtype(OSyncClientPr
	nt nth);	oxy *proxy, int nth);


	osync_bool osync_client_proxy_connect(OSyncClientProxy *proxy, connect_cb c	OSYNC_EXPORT osync_bool osync_client_proxy_connect(OSyncClientProxy *proxy,
	allback, void userdata, const char objtype, osync_bool slowsync, OSyncErr	connect_cb callback, void userdata, const char objtype, osync_bool slows
	or **error);	ync, OSyncError **error);
	osync_bool osync_client_proxy_disconnect(OSyncClientProxy *proxy, disconnec	OSYNC_EXPORT osync_bool osync_client_proxy_disconnect(OSyncClientProxy *pro
	t_cb callback, void userdata, const char objtype, OSyncError **error);	xy, disconnect_cb callback, void userdata, const char objtype, OSyncError
		**error);


	osync_bool osync_client_proxy_read(OSyncClientProxy *proxy, read_cb callbac	OSYNC_EXPORT osync_bool osync_client_proxy_read(OSyncClientProxy *proxy, re
	k, void userdata, OSyncChange change, OSyncError **error);	ad_cb callback, void userdata, OSyncChange change, OSyncError **error);
	osync_bool osync_client_proxy_get_changes(OSyncClientProxy *proxy, get_chan	OSYNC_EXPORT osync_bool osync_client_proxy_get_changes(OSyncClientProxy *pr
	ges_cb callback, void userdata, const char objtype, osync_bool slowsync,	oxy, get_changes_cb callback, void userdata, const char objtype, osync_bo
	OSyncError **error);	ol slowsync, OSyncError **error);
	osync_bool osync_client_proxy_commit_change(OSyncClientProxy *proxy, commit	OSYNC_EXPORT osync_bool osync_client_proxy_commit_change(OSyncClientProxy *
	_change_cb callback, void userdata, OSyncChange change, OSyncError **erro	proxy, commit_change_cb callback, void userdata, OSyncChange change, OSyn
	r);	cError **error);
	osync_bool osync_client_proxy_committed_all(OSyncClientProxy *proxy, commit	OSYNC_EXPORT osync_bool osync_client_proxy_committed_all(OSyncClientProxy *
	ted_all_cb callback, void userdata, const char objtype, OSyncError **erro	proxy, committed_all_cb callback, void userdata, const char objtype, OSyn
	r);	cError **error);


	osync_bool osync_client_proxy_sync_done(OSyncClientProxy proxy, sync_done_ cb callback, void userdata, const char objtype, OSyncError *error);	OSYNC_EXPORT osync_bool osync_client_proxy_sync_done(OSyncClientProxy prox y, sync_done_cb callback, void userdata, const char objtype, OSyncError *error);

	#endif /OSYNC_CLIENT_PROXY_H_/	#endif /OSYNC_CLIENT_PROXY_H_/

End of changes. 8 change blocks.
	41 lines changed or deleted	44 lines changed or added

	opensync_filter.h	opensync_filter.h

	skipping to change at line 36	skipping to change at line 36
	**/	**/
	typedef enum OSyncFilterAction {	typedef enum OSyncFilterAction {
	/** This filter should be ignored */	/** This filter should be ignored */
	OSYNC_FILTER_IGNORE = 0,	OSYNC_FILTER_IGNORE = 0,
	/** The change should be allowed to pass (overrides previous action) */	/** The change should be allowed to pass (overrides previous action) */
	OSYNC_FILTER_ALLOW = 1,	OSYNC_FILTER_ALLOW = 1,
	/** The change should be prevented from passing (overrides previous action) */	/** The change should be prevented from passing (overrides previous action) */
	OSYNC_FILTER_DENY = 2	OSYNC_FILTER_DENY = 2
	} OSyncFilterAction;	} OSyncFilterAction;


	OSYNC_EXPORT typedef osync_bool (* OSyncFilterFunction) (OSyncData data, c onst char config);	typedef osync_bool (* OSyncFilterFunction) (OSyncData data, const char co nfig);

	OSYNC_EXPORT OSyncFilter osync_filter_new(const char objtype, OSyncFilter Action action, OSyncError **error);	OSYNC_EXPORT OSyncFilter osync_filter_new(const char objtype, OSyncFilter Action action, OSyncError **error);
	OSYNC_EXPORT OSyncFilter osync_filter_new_custom(OSyncCustomFilter custom _filter, const char config, OSyncFilterAction action, OSyncError *error);	OSYNC_EXPORT OSyncFilter osync_filter_new_custom(OSyncCustomFilter custom _filter, const char config, OSyncFilterAction action, OSyncError *error);

	OSYNC_EXPORT void osync_filter_ref(OSyncFilter *filter);	OSYNC_EXPORT OSyncFilter osync_filter_ref(OSyncFilter filter);
	OSYNC_EXPORT void osync_filter_unref(OSyncFilter *filter);	OSYNC_EXPORT void osync_filter_unref(OSyncFilter *filter);
	OSYNC_EXPORT void osync_filter_set_config(OSyncFilter filter, const char config);	OSYNC_EXPORT void osync_filter_set_config(OSyncFilter filter, const char config);
	OSYNC_EXPORT const char osync_filter_get_config(OSyncFilter filter);	OSYNC_EXPORT const char osync_filter_get_config(OSyncFilter filter);
	OSYNC_EXPORT const char osync_filter_get_objtype(OSyncFilter filter);	OSYNC_EXPORT const char osync_filter_get_objtype(OSyncFilter filter);
	OSYNC_EXPORT OSyncFilterAction osync_filter_invoke(OSyncFilter filter, OSy ncData data);	OSYNC_EXPORT OSyncFilterAction osync_filter_invoke(OSyncFilter filter, OSy ncData data);

	OSYNC_EXPORT OSyncCustomFilter osync_custom_filter_new(const char objtype , const char objformat, const char name, OSyncFilterFunction hook, OSyncE rror **error);	OSYNC_EXPORT OSyncCustomFilter osync_custom_filter_new(const char objtype , const char objformat, const char name, OSyncFilterFunction hook, OSyncE rror **error);

	OSYNC_EXPORT void osync_custom_filter_ref(OSyncCustomFilter *filter);	OSYNC_EXPORT OSyncCustomFilter osync_custom_filter_ref(OSyncCustomFilter filter);
	OSYNC_EXPORT void osync_custom_filter_unref(OSyncCustomFilter *filter);	OSYNC_EXPORT void osync_custom_filter_unref(OSyncCustomFilter *filter);
	OSYNC_EXPORT osync_bool osync_custom_filter_invoke(OSyncCustomFilter filte r, OSyncData data, const char *config);	OSYNC_EXPORT osync_bool osync_custom_filter_invoke(OSyncCustomFilter filte r, OSyncData data, const char *config);

	#endif //_OPENSYNC_FILTER_H_	#endif //_OPENSYNC_FILTER_H_

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	opensync_group.h	opensync_group.h

	skipping to change at line 42	skipping to change at line 42

	typedef enum {	typedef enum {
	OSYNC_CONFLICT_RESOLUTION_UNKNOWN,	OSYNC_CONFLICT_RESOLUTION_UNKNOWN,
	OSYNC_CONFLICT_RESOLUTION_DUPLICATE,	OSYNC_CONFLICT_RESOLUTION_DUPLICATE,
	OSYNC_CONFLICT_RESOLUTION_IGNORE,	OSYNC_CONFLICT_RESOLUTION_IGNORE,
	OSYNC_CONFLICT_RESOLUTION_NEWER,	OSYNC_CONFLICT_RESOLUTION_NEWER,
	OSYNC_CONFLICT_RESOLUTION_SELECT	OSYNC_CONFLICT_RESOLUTION_SELECT
	} OSyncConflictResolution;	} OSyncConflictResolution;

	OSYNC_EXPORT OSyncGroup osync_group_new(OSyncError *error);	OSYNC_EXPORT OSyncGroup osync_group_new(OSyncError *error);

	OSYNC_EXPORT void osync_group_ref(OSyncGroup *group);	OSYNC_EXPORT OSyncGroup osync_group_ref(OSyncGroup group);
	OSYNC_EXPORT void osync_group_unref(OSyncGroup *group);	OSYNC_EXPORT void osync_group_unref(OSyncGroup *group);

	OSYNC_EXPORT OSyncLockState osync_group_lock(OSyncGroup *group);	OSYNC_EXPORT OSyncLockState osync_group_lock(OSyncGroup *group);
	OSYNC_EXPORT void osync_group_unlock(OSyncGroup *group);	OSYNC_EXPORT void osync_group_unlock(OSyncGroup *group);

	OSYNC_EXPORT void osync_group_set_name(OSyncGroup group, const char name) ;	OSYNC_EXPORT void osync_group_set_name(OSyncGroup group, const char name) ;
	OSYNC_EXPORT const char osync_group_get_name(OSyncGroup group);	OSYNC_EXPORT const char osync_group_get_name(OSyncGroup group);

	OSYNC_EXPORT osync_bool osync_group_save(OSyncGroup group, OSyncError *er ror);	OSYNC_EXPORT osync_bool osync_group_save(OSyncGroup group, OSyncError *er ror);
	OSYNC_EXPORT osync_bool osync_group_delete(OSyncGroup group, OSyncError * error);	OSYNC_EXPORT osync_bool osync_group_delete(OSyncGroup group, OSyncError * error);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync_objformat.h	opensync_objformat.h

	skipping to change at line 35	skipping to change at line 35
	typedef osync_bool (* OSyncFormatCopyFunc) (const char input, unsigned int inpsize, char output, unsigned int outpsize, OSyncError **error);	typedef osync_bool (* OSyncFormatCopyFunc) (const char input, unsigned int inpsize, char output, unsigned int outpsize, OSyncError **error);
	typedef osync_bool (* OSyncFormatDuplicateFunc) (const char uid, const cha r input, unsigned int insize, char newuid, char output, unsigned int * outsize, osync_bool dirty, OSyncError *error);	typedef osync_bool (* OSyncFormatDuplicateFunc) (const char uid, const cha r input, unsigned int insize, char newuid, char output, unsigned int * outsize, osync_bool dirty, OSyncError *error);
	typedef void (* OSyncFormatCreateFunc) (char *data, unsigned int size);	typedef void (* OSyncFormatCreateFunc) (char *data, unsigned int size);
	typedef void (* OSyncFormatDestroyFunc) (char *data, unsigned int size);	typedef void (* OSyncFormatDestroyFunc) (char *data, unsigned int size);
	typedef char ( OSyncFormatPrintFunc) (const char *data, unsigned int size );	typedef char ( OSyncFormatPrintFunc) (const char *data, unsigned int size );
	typedef time_t (* OSyncFormatRevisionFunc) (const char data, unsigned int size, OSyncError *error);	typedef time_t (* OSyncFormatRevisionFunc) (const char data, unsigned int size, OSyncError *error);
	typedef osync_bool (* OSyncFormatMarshalFunc) (const char input, unsigned int inpsize, OSyncMessage message, OSyncError **error);	typedef osync_bool (* OSyncFormatMarshalFunc) (const char input, unsigned int inpsize, OSyncMessage message, OSyncError **error);
	typedef osync_bool (* OSyncFormatDemarshalFunc) (OSyncMessage message, cha r output, unsigned int outpsize, OSyncError **error);	typedef osync_bool (* OSyncFormatDemarshalFunc) (OSyncMessage message, cha r output, unsigned int outpsize, OSyncError **error);

	OSYNC_EXPORT OSyncObjFormat osync_objformat_new(const char name, const ch ar objtype_name, OSyncError *error);	OSYNC_EXPORT OSyncObjFormat osync_objformat_new(const char name, const ch ar objtype_name, OSyncError *error);

	OSYNC_EXPORT void osync_objformat_ref(OSyncObjFormat *format);	OSYNC_EXPORT OSyncObjFormat osync_objformat_ref(OSyncObjFormat format);
	OSYNC_EXPORT void osync_objformat_unref(OSyncObjFormat *format);	OSYNC_EXPORT void osync_objformat_unref(OSyncObjFormat *format);

	OSYNC_EXPORT const char osync_objformat_get_name(OSyncObjFormat format);	OSYNC_EXPORT const char osync_objformat_get_name(OSyncObjFormat format);
	OSYNC_EXPORT const char osync_objformat_get_objtype(OSyncObjFormat format );	OSYNC_EXPORT const char osync_objformat_get_objtype(OSyncObjFormat format );

	OSYNC_EXPORT void osync_objformat_set_compare_func(OSyncObjFormat *format, OSyncFormatCompareFunc cmp_func);	OSYNC_EXPORT void osync_objformat_set_compare_func(OSyncObjFormat *format, OSyncFormatCompareFunc cmp_func);
	OSYNC_EXPORT void osync_objformat_set_destroy_func(OSyncObjFormat *format, OSyncFormatDestroyFunc destroy_func);	OSYNC_EXPORT void osync_objformat_set_destroy_func(OSyncObjFormat *format, OSyncFormatDestroyFunc destroy_func);
	OSYNC_EXPORT void osync_objformat_set_copy_func(OSyncObjFormat *format, OSy ncFormatCopyFunc copy_func);	OSYNC_EXPORT void osync_objformat_set_copy_func(OSyncObjFormat *format, OSy ncFormatCopyFunc copy_func);
	OSYNC_EXPORT void osync_objformat_set_duplicate_func(OSyncObjFormat *format , OSyncFormatDuplicateFunc dupe_func);	OSYNC_EXPORT void osync_objformat_set_duplicate_func(OSyncObjFormat *format , OSyncFormatDuplicateFunc dupe_func);
	OSYNC_EXPORT void osync_objformat_set_create_func(OSyncObjFormat *format, O SyncFormatCreateFunc create_func);	OSYNC_EXPORT void osync_objformat_set_create_func(OSyncObjFormat *format, O SyncFormatCreateFunc create_func);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync_plugin.h	opensync_plugin.h

	skipping to change at line 45	skipping to change at line 45
	/** Plugin has no configuration options */	/** Plugin has no configuration options */
	OSYNC_PLUGIN_NO_CONFIGURATION = 0,	OSYNC_PLUGIN_NO_CONFIGURATION = 0,
	/** Plugin can be configured, but will accept the default config in the initialize function */	/** Plugin can be configured, but will accept the default config in the initialize function */
	OSYNC_PLUGIN_OPTIONAL_CONFIGURATION = 1,	OSYNC_PLUGIN_OPTIONAL_CONFIGURATION = 1,
	/** Plugin must be configured to run correctly */	/** Plugin must be configured to run correctly */
	OSYNC_PLUGIN_NEEDS_CONFIGURATION = 2	OSYNC_PLUGIN_NEEDS_CONFIGURATION = 2
	} OSyncConfigurationType;	} OSyncConfigurationType;

	OSYNC_EXPORT OSyncPlugin osync_plugin_new(OSyncError *error);	OSYNC_EXPORT OSyncPlugin osync_plugin_new(OSyncError *error);
	OSYNC_EXPORT void osync_plugin_unref(OSyncPlugin *plugin);	OSYNC_EXPORT void osync_plugin_unref(OSyncPlugin *plugin);

	OSYNC_EXPORT void osync_plugin_ref(OSyncPlugin *plugin);	OSYNC_EXPORT OSyncPlugin osync_plugin_ref(OSyncPlugin plugin);

	OSYNC_EXPORT const char osync_plugin_get_name(OSyncPlugin plugin);	OSYNC_EXPORT const char osync_plugin_get_name(OSyncPlugin plugin);
	OSYNC_EXPORT void osync_plugin_set_name(OSyncPlugin plugin, const char na me);	OSYNC_EXPORT void osync_plugin_set_name(OSyncPlugin plugin, const char na me);

	OSYNC_EXPORT const char osync_plugin_get_longname(OSyncPlugin plugin);	OSYNC_EXPORT const char osync_plugin_get_longname(OSyncPlugin plugin);
	OSYNC_EXPORT void osync_plugin_set_longname(OSyncPlugin plugin, const char longname);	OSYNC_EXPORT void osync_plugin_set_longname(OSyncPlugin plugin, const char longname);

	OSYNC_EXPORT OSyncConfigurationType osync_plugin_get_config_type(OSyncPlugi n *plugin);	OSYNC_EXPORT OSyncConfigurationType osync_plugin_get_config_type(OSyncPlugi n *plugin);
	OSYNC_EXPORT void osync_plugin_set_config_type(OSyncPlugin *plugin, OSyncCo nfigurationType type);	OSYNC_EXPORT void osync_plugin_set_config_type(OSyncPlugin *plugin, OSyncCo nfigurationType type);


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	opensync_sink.h	opensync_sink.h

	skipping to change at line 47	skipping to change at line 47
	OSyncSinkGetChangesFn get_changes;	OSyncSinkGetChangesFn get_changes;
	OSyncSinkCommitFn commit;	OSyncSinkCommitFn commit;
	OSyncSinkWriteFn write;	OSyncSinkWriteFn write;
	OSyncSinkCommittedAllFn committed_all;	OSyncSinkCommittedAllFn committed_all;
	OSyncSinkReadFn read;	OSyncSinkReadFn read;
	OSyncSinkBatchCommitFn batch_commit;	OSyncSinkBatchCommitFn batch_commit;
	OSyncSinkSyncDoneFn sync_done;	OSyncSinkSyncDoneFn sync_done;
	} OSyncObjTypeSinkFunctions;	} OSyncObjTypeSinkFunctions;

	OSYNC_EXPORT OSyncObjTypeSink osync_objtype_sink_new(const char objtype, OSyncError **error);	OSYNC_EXPORT OSyncObjTypeSink osync_objtype_sink_new(const char objtype, OSyncError **error);

	OSYNC_EXPORT void osync_objtype_sink_ref(OSyncObjTypeSink *sink);	OSYNC_EXPORT OSyncObjTypeSink osync_objtype_sink_ref(OSyncObjTypeSink sin k);
	OSYNC_EXPORT void osync_objtype_sink_unref(OSyncObjTypeSink *sink);	OSYNC_EXPORT void osync_objtype_sink_unref(OSyncObjTypeSink *sink);

	OSYNC_EXPORT const char osync_objtype_sink_get_name(OSyncObjTypeSink sink );	OSYNC_EXPORT const char osync_objtype_sink_get_name(OSyncObjTypeSink sink );
	OSYNC_EXPORT void osync_objtype_sink_set_name(OSyncObjTypeSink sink, const char name);	OSYNC_EXPORT void osync_objtype_sink_set_name(OSyncObjTypeSink sink, const char name);

	OSYNC_EXPORT int osync_objtype_sink_num_objformats(OSyncObjTypeSink *sink);	OSYNC_EXPORT int osync_objtype_sink_num_objformats(OSyncObjTypeSink *sink);
	OSYNC_EXPORT const char osync_objtype_sink_nth_objformat(OSyncObjTypeSink sink, int nth);	OSYNC_EXPORT const char osync_objtype_sink_nth_objformat(OSyncObjTypeSink sink, int nth);
	OSYNC_EXPORT void osync_objtype_sink_add_objformat(OSyncObjTypeSink sink, const char format);	OSYNC_EXPORT void osync_objtype_sink_add_objformat(OSyncObjTypeSink sink, const char format);
	OSYNC_EXPORT void osync_objtype_sink_remove_objformat(OSyncObjTypeSink sin k, const char format);	OSYNC_EXPORT void osync_objtype_sink_remove_objformat(OSyncObjTypeSink sin k, const char format);


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added