Ticket #975: opensync_list_pattern.2.diff

File opensync_list_pattern.2.diff, 19.8 KB (added by bricks, 3 years ago)

  • wrapper/opensync-plugin.i

     
    120120        } 
    121121 
    122122        int num_plugins() { 
    123                 return osync_plugin_env_num_plugins(self); 
     123                OSyncList *plugins = osync_plugin_env_get_plugins(self); 
     124                return osync_list_length(plugins); 
    124125        } 
    125126 
    126127        Plugin *nth_plugin(int nth) { 
    127                 Plugin *plugin = osync_plugin_env_nth_plugin(self, nth); 
     128                OSyncList *plugins = osync_plugin_env_get_plugins(self); 
     129                 
     130                Plugin *plugin = (OSyncPlugin*)osync_list_nth_data(plugins, nth); 
    128131                if (plugin) 
    129132                        osync_plugin_ref(plugin); 
    130133                return plugin; 
    … …  
    190193                osync_plugin_info_add_objtype(self, sink); 
    191194        } 
    192195 
    193         int num_objtypes() { 
    194                 return osync_plugin_info_num_objtypes(self); 
     196        unsigned int num_objtypes() { 
     197                OSyncList *objtypesinks = osync_plugin_info_get_objtypes(self); 
     198                unsigned int num = osync_list_length(objtypesinks); 
     199                osync_list_free(objtypesinks); 
     200                return num; 
    195201        } 
    196202 
    197203        ObjTypeSink *nth_objtype(int nth) { 
    198                 ObjTypeSink *ret = osync_plugin_info_nth_objtype(self, nth); 
     204                /* TODO: return a list structure of phython */ 
     205                OSyncList *objtypesinks = osync_plugin_info_get_objtypes(self); 
     206                ObjTypeSink *ret = (ObjTypeSink*)osync_list_nth_data(objtypesinks, nth); 
    199207                if (ret) 
    200208                        osync_objtype_sink_ref(ret); 
     209                osync_list_free(objtypesinks); 
    201210                return ret; 
    202211        } 
    203212 

  • opensync/plugin/opensync_plugin_env_internals.h

     
    5050 */ 
    5151OSYNC_TEST_EXPORT osync_bool osync_plugin_env_plugin_is_usable(OSyncPluginEnv *env, const char *pluginname, OSyncError **error); 
    5252 
     53/** @brief Returns the number of loaded plugins 
     54 *  
     55 * TODO: This function isn't necessary anymore and can possibly be removed 
     56 *  
     57 * Returns the number of loaded plugins. 0 if used before initialization 
     58 *  
     59 * @param env Pointer to a OSyncPluginEnv environment 
     60 * @returns Number of plugins 
     61 *  
     62 */ 
     63OSYNC_TEST_EXPORT unsigned int osync_plugin_env_num_plugins(OSyncPluginEnv *env); 
     64 
    5365/*@}*/ 
    5466 
    5567#endif /* _OPENSYNC_PLUGIN_ENV_INTERNALS_H_ */ 

  • opensync/plugin/opensync_plugin_env.c

     
    214214        return osync_list_length(env->plugins); 
    215215} 
    216216 
    217 OSyncPlugin *osync_plugin_env_nth_plugin(OSyncPluginEnv *env, unsigned int nth) 
     217OSyncList *osync_plugin_env_get_plugins(OSyncPluginEnv *env) 
    218218{ 
    219         return (OSyncPlugin *)osync_list_nth_data(env->plugins, nth); 
     219        return osync_list_copy(env->plugins); 
    220220} 
    221221 
    222222osync_bool osync_plugin_env_plugin_is_usable(OSyncPluginEnv *env, const char *pluginname, OSyncError **error) 

  • opensync/plugin/opensync_plugin_info.c

     
    2727 
    2828#include "opensync-merger.h" 
    2929#include "opensync-version.h" 
     30#include "opensync_list.h" 
    3031 
    3132OSyncPluginInfo *osync_plugin_info_new(OSyncError **error) 
    3233{ 
    … …  
    171172        osync_objtype_sink_ref(sink); 
    172173} 
    173174 
    174 unsigned int osync_plugin_info_num_objtypes(OSyncPluginInfo *info) 
    175 { 
     175OSyncList *osync_plugin_info_get_objtypes(OSyncPluginInfo *info) { 
    176176        osync_assert(info); 
    177         return osync_list_length(info->objtypes); 
     177        return osync_list_copy(info->objtypes); 
    178178} 
    179179 
    180 OSyncObjTypeSink *osync_plugin_info_nth_objtype(OSyncPluginInfo *info, unsigned int nth) 
    181 { 
    182         osync_assert(info); 
    183         return osync_list_nth_data(info->objtypes, nth); 
    184 } 
    185  
    186180OSyncObjTypeSink *osync_plugin_info_get_main_sink(OSyncPluginInfo *info) 
    187181{ 
    188182        osync_assert(info); 

  • opensync/plugin/opensync_plugin_env.h

     
    101101 */ 
    102102OSYNC_EXPORT OSyncPlugin *osync_plugin_env_find_plugin(OSyncPluginEnv *env, const char *name); 
    103103 
    104 /** @brief Returns the number of loaded plugins 
     104/* @brief Get all plugins which are registered in the Plugin Env 
    105105 *  
    106  * Returns the number of loaded plugins. 0 if used before initialization 
    107  *  
    108  * @param env Pointer to a OSyncPluginEnv environment 
    109  * @returns Number of plugins 
    110  *  
     106 * @param env Pointer to a OSyncPluginEnv 
     107 * @return A shallow copy of the internal plugin list 
    111108 */ 
    112 OSYNC_EXPORT unsigned int osync_plugin_env_num_plugins(OSyncPluginEnv *env); 
     109OSYNC_EXPORT OSyncList *osync_plugin_env_get_plugins(OSyncPluginEnv *env); 
    113110 
    114 /** @brief Returns pointer to nth plugin 
    115  *  
    116  * Returns pointer to nth plugin 
    117  *  
    118  * @param env Pointer to a OSyncPluginEnv environment 
    119  * @param nth Which plugin to return 
    120  * @returns Pointer to plugin 
    121  *  
    122  */ 
    123 OSYNC_EXPORT OSyncPlugin *osync_plugin_env_nth_plugin(OSyncPluginEnv *env, unsigned int nth); 
    124  
    125111/*@}*/ 
    126112 
    127113#endif /* _OPENSYNC_PLUGIN_ENV_H_ */ 

  • opensync/plugin/opensync_plugin_info.h

     
    110110 */ 
    111111OSYNC_EXPORT void osync_plugin_info_add_objtype(OSyncPluginInfo *info, OSyncObjTypeSink *sink); 
    112112 
    113 /** @brief Returns the number of added object types (sinks) 
     113/** 
     114 * @brief Returns all Objtype Sinks as a list 
    114115 *  
    115  * @param info Pointer to the plugin info object 
    116  * @returns the number of object types in the plugin info 
    117  *  
     116 * @param Pointer to a OSyncPluginInfo 
     117 * @return A shallow copy of the internal objtype list 
    118118 */ 
    119 OSYNC_EXPORT unsigned int osync_plugin_info_num_objtypes(OSyncPluginInfo *info); 
     119OSYNC_EXPORT OSyncList *osync_plugin_info_get_objtypes(OSyncPluginInfo *info); 
    120120 
    121 /** @brief Returns the nth added object type (sink) 
    122  *  
    123  * @param info Pointer to the plugin info object 
    124  * @param nth the index of the object type (sink) to return 
    125  * @returns the object type (sink) at the specified index 
    126  *  
    127  */ 
    128 OSYNC_EXPORT OSyncObjTypeSink *osync_plugin_info_nth_objtype(OSyncPluginInfo *info, unsigned int nth); 
    129  
    130  
    131121/** @brief Returns the Main Sink  
    132122 *  
    133123 * @param info Pointer to the plugin info object 

  • opensync/client/opensync_client.c

     
    3030#include "opensync-helper.h" 
    3131#include "helper/opensync_hashtable_internals.h" 
    3232 
     33#include "common/opensync_list.h" 
     34 
    3335#include "opensync-ipc.h" 
    3436#include "ipc/opensync_serializer_internals.h" 
    3537#include "ipc/opensync_message_internals.h" 
    … …  
    575577        const char *objtype = NULL; 
    576578        const char *preferred_format = NULL; 
    577579        OSyncList *o = NULL; 
     580        OSyncList *objtypesinks = NULL; 
     581        OSyncList *list; 
    578582        OSyncObjFormatSink *format_sink = NULL; 
    579         unsigned int n, num_sinks; 
    580583        osync_bool couldinit; 
    581584         
    582585        osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, client, message, error); 
    … …  
    698701                goto error; 
    699702        } 
    700703 
    701         num_sinks = osync_plugin_info_num_objtypes(client->plugin_info); 
    702         for (n = 0; n < num_sinks; n++) { 
    703  
    704                 sink = osync_plugin_info_nth_objtype(client->plugin_info, n); 
     704        objtypesinks = osync_plugin_info_get_objtypes(client->plugin_info); 
     705        list = objtypesinks; 
     706        while (list) { 
     707                sink = (OSyncObjTypeSink*)list->data; 
    705708                if (!osync_objtype_sink_load_anchor(sink, client->plugin_info, error)) { 
    706709                        goto error_finalize; 
    707710                } 
    … …  
    709712                if (!osync_objtype_sink_load_hashtable(sink, client->plugin_info, error)) { 
    710713                        goto error_finalize; 
    711714                } 
    712  
     715                list = list->next; 
    713716        } 
     717        osync_list_free(objtypesinks); 
    714718 
    715719        main_sink = osync_plugin_info_get_main_sink(client->plugin_info); 
    716720        if (main_sink) { 
    … …  
    745749 error_free_message: 
    746750        osync_message_unref(reply); 
    747751 error_finalize: 
     752        osync_list_free(objtypesinks); 
    748753        osync_plugin_finalize(client->plugin, client->plugin_data); 
    749754 error: 
    750755        osync_free(enginepipe); 
    … …  
    816821static osync_bool _osync_client_handle_discover(OSyncClient *client, OSyncMessage *message, OSyncError **error) 
    817822{ 
    818823        OSyncMessage *reply = NULL; 
    819         unsigned int i = 0; 
    820824        OSyncPluginConfig *config = NULL; 
    821825        OSyncList *res = NULL; 
    822         unsigned int numobjs = 0; 
    823826        unsigned int avail = 0; 
    824827        OSyncObjTypeSink *sink = NULL; 
    825828        OSyncVersion *version = NULL; 
    … …  
    828831        int size = 0; 
    829832        unsigned int num_res = 0; 
    830833        OSyncPluginResource *resource = NULL; 
     834        OSyncList *objtypesinks = NULL; 
     835        OSyncList *list; 
    831836 
    832837        config = osync_plugin_info_get_config(client->plugin_info); 
    833838        res = osync_plugin_config_get_resources(config); 
    … …  
    846851        else 
    847852                osync_message_write_int(reply, 0); 
    848853 
    849         numobjs = osync_plugin_info_num_objtypes(client->plugin_info); 
    850         for (i = 0; i < numobjs; i++) { 
    851                 sink = osync_plugin_info_nth_objtype(client->plugin_info, i); 
     854        objtypesinks = osync_plugin_info_get_objtypes(client->plugin_info); 
     855        list = objtypesinks; 
     856        while(list) { 
     857                sink = (OSyncObjTypeSink*)list->data; 
    852858                if (osync_objtype_sink_is_available(sink)) { 
    853859                        avail++; 
    854860                } 
     861                list = list->next; 
    855862        } 
    856863 
    857864        osync_message_write_uint(reply, avail); 
    858865         
    859         for (i = 0; i < numobjs; i++) { 
    860                 sink = osync_plugin_info_nth_objtype(client->plugin_info, i); 
     866        list = objtypesinks; 
     867        while(list) { 
     868                sink = (OSyncObjTypeSink*)list->data; 
    861869                if (osync_objtype_sink_is_available(sink)) { 
    862870                        if (!osync_marshal_objtype_sink(reply, sink, error)) 
    863871                                goto error_free_message; 
    864872                } 
     873                list = list->next; 
    865874        } 
    866  
     875        osync_list_free(objtypesinks); 
     876         
    867877        version = osync_plugin_info_get_version(client->plugin_info); 
    868878        if (version) { 
    869879                osync_message_write_int(reply, 1); 
    … …  
    909919        return TRUE; 
    910920         
    911921 error_free_message: 
     922        osync_list_free(objtypesinks); 
    912923        osync_message_unref(reply); 
    913924 error: 
    914925        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); 

  • tools/osyncplugin.c

     
    448448 
    449449static void *plugin_initialize(OSyncError **error) 
    450450{ 
    451         unsigned int n, num_sinks = osync_plugin_info_num_objtypes(plugin_info); 
     451        OSyncList *list; 
     452        OSyncList *objtypesinks = NULL; 
    452453        void *plugin_data; 
    453454        osync_bool couldinit; 
    454455        couldinit = osync_plugin_initialize(plugin, &(plugin_data), plugin_info, error); 
    455456 
     457        objtypesinks = osync_plugin_info_get_objtypes(plugin_info); 
     458        list = objtypesinks; 
     459        while(list) { 
     460                OSyncObjTypeSink *sink = (OSyncObjTypeSink*)list->data; 
     461                if (!osync_objtype_sink_load_anchor(sink, plugin_info, error))  
     462                        goto error; 
    456463 
    457         for (n = 0; n < num_sinks; n++) { 
    458                 OSyncObjTypeSink *sink = osync_plugin_info_nth_objtype(plugin_info, n); 
    459  
    460                 if (!osync_objtype_sink_load_anchor(sink, plugin_info, error)) 
    461                         return NULL; 
    462  
    463464                if (!osync_objtype_sink_load_hashtable(sink, plugin_info, error)) 
    464                         return NULL; 
     465                        goto error; 
     466                 
     467                list = list->next; 
    465468        } 
     469        osync_list_free(objtypesinks); 
    466470 
    467471        return plugin_data; 
     472error: 
     473        osync_list_free(objtypesinks); 
     474        return NULL; 
    468475} 
    469476 
    470477static void finalize_plugin(void **plugin_data) 
    … …  
    598605 
    599606static osync_bool get_changes(Command *cmd, SyncType type, OSyncError **error) 
    600607{ 
    601         int num, i; 
    602608        OSyncObjTypeSink *sink = NULL; 
     609        OSyncList *list; 
     610        OSyncList *objtypesinks = NULL; 
    603611        const char *objtype = cmd->arg; 
    604612 
    605613        if (objtype) { 
    … …  
    613621 
    614622        } else { 
    615623                /* all available objtypes */ 
    616                 num = osync_plugin_info_num_objtypes(plugin_info); 
    617                 for (i=0; i < num; i++) { 
    618                         sink = osync_plugin_info_nth_objtype(plugin_info, i); 
     624                objtypesinks = osync_plugin_info_get_objtypes(plugin_info); 
     625                list = objtypesinks; 
     626                while(list) { 
     627                        sink = (OSyncObjTypeSink*)list->data; 
    619628 
    620629                        cmd->sink = sink; 
    621630                        if (!get_changes_sink(cmd, sink, type, error)) 
    622631                                goto error; 
     632                        list = list->next; 
    623633                } 
    624  
    625634                /* last but not least - the main sink */ 
    626635                if (get_main_sink()) 
    627                  
    628636                        if (!get_changes_sink(cmd, get_main_sink(), type, error)) 
    629637                                goto error; 
     638                 
     639                osync_list_free(objtypesinks); 
    630640        } 
    631641 
    632642        return TRUE; 
    633643 
    634644 error: 
     645        osync_list_free(objtypesinks); 
    635646        return FALSE; 
    636647} 
    637648 
    … …  
    699710 
    700711static osync_bool connect_plugin(Command *cmd, OSyncError **error) 
    701712{        
    702         unsigned int i, num; 
    703713        OSyncObjTypeSink *sink = NULL; 
     714        OSyncList *objtypesinks = NULL; 
     715        OSyncList *list; 
    704716        const char *objtype = cmd->arg; 
    705717 
    706718        if (objtype) { 
    … …  
    711723                if (!connect_sink(cmd, sink, error)) 
    712724                        goto error; 
    713725        } else { 
    714                 num = osync_plugin_info_num_objtypes(plugin_info); 
    715                 for (i=0; i < num; i++) { 
    716                         sink = osync_plugin_info_nth_objtype(plugin_info, i); 
     726                objtypesinks = osync_plugin_info_get_objtypes(plugin_info); 
     727                list = objtypesinks; 
     728                while(list) { 
     729                        sink = (OSyncObjTypeSink*)list->data; 
    717730 
    718731                        if (!connect_sink(cmd, sink, error)) 
    719732                                goto error; 
     733                        list = list->next; 
    720734                } 
    721735 
    722736                /* last but not least - the main sink */ 
    723737                if (get_main_sink()) 
    724738                        if (!connect_sink(cmd, get_main_sink(), error)) 
    725739                                goto error; 
     740                 
     741                osync_list_free(objtypesinks); 
    726742        } 
    727743 
    728744        return TRUE; 
    729745 error: 
     746        osync_list_free(objtypesinks); 
    730747        return FALSE; 
    731748} 
    732749 
    … …  
    790807 
    791808static osync_bool disconnect(Command *cmd, OSyncError **error) 
    792809{ 
    793          
    794         int i, num; 
     810        OSyncList *list; 
     811        OSyncList *objtypesinks = NULL; 
    795812        OSyncObjTypeSink *sink = NULL; 
    796813        const char *objtype = cmd->arg; 
    797814 
    … …  
    803820                if (!disconnect_sink(cmd, sink, error)) 
    804821                        goto error; 
    805822        } else { 
    806                 num = osync_plugin_info_num_objtypes(plugin_info); 
    807                 for (i=0; i < num; i++) { 
    808                         sink = osync_plugin_info_nth_objtype(plugin_info, i); 
     823                objtypesinks = osync_plugin_info_get_objtypes(plugin_info); 
     824                list = objtypesinks; 
     825                while(list) { 
     826                        sink = (OSyncObjTypeSink*)list->data; 
    809827 
    810828                        if (!disconnect_sink(cmd, sink, error)) 
    811829                                goto error; 
     830                        list = list->next; 
    812831                } 
    813832 
    814833                /* last but not least - the main sink */ 
    815834                if (get_main_sink()) 
    816835                        if (!disconnect_sink(cmd, get_main_sink(), error)) 
    817836                                goto error; 
     837                 
     838                osync_list_free(objtypesinks); 
    818839        } 
    819840 
    820841        return TRUE; 
    821842 error: 
     843        osync_list_free(objtypesinks); 
    822844        return FALSE; 
    823845} 
    824846 
    … …  
    882904 
    883905static osync_bool commit(Command *cmd, OSyncChange *change, OSyncError **error) 
    884906{ 
    885         int i, num; 
     907        OSyncList *list; 
     908        OSyncList *objtypesinks = NULL; 
    886909        OSyncObjTypeSink *sink = NULL; 
    887910        const char *objtype = cmd->arg; 
    888911 
    … …  
    896919                if (!commit_sink(cmd, sink, change, error)) 
    897920                        goto error; 
    898921        } else { 
    899                 num = osync_plugin_info_num_objtypes(plugin_info); 
    900                 for (i=0; i < num; i++) { 
    901                         sink = osync_plugin_info_nth_objtype(plugin_info, i); 
     922                objtypesinks = osync_plugin_info_get_objtypes(plugin_info); 
     923                list = objtypesinks; 
     924                while(list){ 
     925                        sink = (OSyncObjTypeSink*)list->data; 
    902926 
    903927                        if (!commit_sink(cmd, sink, change, error)) 
    904928                                goto error; 
     929                        list = list->next; 
    905930                } 
    906931 
    907932                /* last but not least - the main sink */ 
    908933                if (get_main_sink()) 
    909934                        if (!commit_sink(cmd, get_main_sink(), change, error)) 
    910935                                goto error; 
     936                 
     937                osync_list_free(objtypesinks); 
    911938        } 
    912939         
    913940        return TRUE; 
    914941 error: 
     942        osync_list_free(objtypesinks); 
    915943        return FALSE; 
    916944} 
    917945 
    … …  
    9981026static osync_bool syncdone(Command *cmd, OSyncError **error) 
    9991027{ 
    10001028         
    1001         int i, num; 
     1029        OSyncList *objtypesinks = NULL; 
     1030        OSyncList *list; 
    10021031        OSyncObjTypeSink *sink = NULL; 
    10031032        const char *objtype = cmd->arg; 
    10041033 
    … …  
    10101039                if (!syncdone_sink(cmd, sink, error)) 
    10111040                        goto error; 
    10121041        } else { 
    1013                 num = osync_plugin_info_num_objtypes(plugin_info); 
    1014                 for (i=0; i < num; i++) { 
    1015                         sink = osync_plugin_info_nth_objtype(plugin_info, i); 
     1042                objtypesinks = osync_plugin_info_get_objtypes(plugin_info); 
     1043                list = objtypesinks; 
     1044                while(list) { 
     1045                        sink = (OSyncObjTypeSink*)list->data; 
    10161046 
    10171047                        if (!syncdone_sink(cmd, sink, error)) 
    10181048                                goto error; 
     1049                         
     1050                        list = list->next; 
    10191051                } 
    10201052 
    10211053                /* last but not least - the main sink */ 
    10221054                if (get_main_sink()) 
    10231055                        if (!syncdone_sink(cmd, get_main_sink(), error)) 
    10241056                                goto error; 
     1057                 
     1058                osync_list_free(objtypesinks); 
    10251059        } 
    10261060 
    10271061        return TRUE; 
    10281062 error: 
     1063        osync_list_free(objtypesinks); 
    10291064        return FALSE; 
    10301065} 
    10311066 
    … …  
    10811116 
    10821117static osync_bool committedall(Command *cmd, OSyncError **error) 
    10831118{ 
    1084         int i, num; 
     1119        OSyncList *list; 
     1120        OSyncList *objtypesinks = NULL; 
    10851121        OSyncObjTypeSink *sink = NULL; 
    10861122        const char *objtype = cmd->arg; 
    10871123 
    … …  
    10931129                if (!committedall_sink(cmd, sink, error)) 
    10941130                        goto error; 
    10951131        } else { 
    1096                 num = osync_plugin_info_num_objtypes(plugin_info); 
    1097                 for (i=0; i < num; i++) { 
    1098                         sink = osync_plugin_info_nth_objtype(plugin_info, i); 
     1132                objtypesinks = osync_plugin_info_get_objtypes(plugin_info); 
     1133                list = objtypesinks; 
     1134                while(list) { 
     1135                        sink = (OSyncObjTypeSink*)list->data; 
    10991136 
    11001137                        if (!committedall_sink(cmd, sink, error)) 
    11011138                                goto error; 
     1139                         
     1140                        list = list->next; 
    11021141                } 
    11031142 
    11041143                /* last but not least - the main sink */ 
    11051144                if (get_main_sink()) 
    11061145                        if (!committedall_sink(cmd, get_main_sink(), error)) 
    11071146                                goto error; 
     1147                 
     1148                osync_list_free(objtypesinks); 
    11081149        } 
    11091150 
    11101151        return TRUE; 
    11111152 error: 
     1153        osync_list_free(objtypesinks); 
    11121154        return FALSE; 
    11131155} 
    11141156 
    … …  
    12161258} 
    12171259 
    12181260static osync_bool plugin_list(OSyncError **error) { 
    1219         int num; 
    1220         int i; 
     1261        OSyncList *plugins; 
     1262        OSyncList *list; 
    12211263         
    12221264        assert(!plugin_env); 
    12231265 
    … …  
    12331275        if (!osync_plugin_env_load(plugin_env, pluginpath, error)) 
    12341276                goto error_free_formatenv; 
    12351277 
    1236         num= osync_plugin_env_num_plugins(plugin_env); 
    1237         for(i= 0; i < num; i++) { 
    1238                 OSyncPlugin* plugin= osync_plugin_env_nth_plugin(plugin_env, i); 
     1278        plugins = osync_plugin_env_get_plugins(plugin_env); 
     1279        list = plugins; 
     1280        while(list) { 
     1281                OSyncPlugin* plugin = (OSyncPlugin*)list->data; 
    12391282                fprintf (stdout, "Name:        %s\n", osync_plugin_get_name(plugin)); 
    1240                 fprintf (stdout, "Description: %s\n", osync_plugin_get_description(plugin));             
    1241         }  
     1283                fprintf (stdout, "Description: %s\n", osync_plugin_get_description(plugin)); 
     1284                list = list->next; 
     1285        } 
     1286        osync_list_free(plugins); 
    12421287        return TRUE; 
    12431288         
    12441289 error_free_formatenv: 

  • tests/mock-plugin/mock_sync.c

     
    607607        /* Now we register the objtypes that we can sync. This plugin is special. It can 
    608608         * synchronize any objtype we configure it to sync and where a conversion 
    609609         * path to the file format can be found */ 
    610         int i, numobjs = osync_plugin_info_num_objtypes(info); 
    611         for (i = 0; i < numobjs; i++) { 
     610        OSyncList *objtypesinks = osync_plugin_info_get_objtypes(info); 
     611        OSyncList *list = objtypesinks; 
     612        while(list) { 
    612613                MockDir *dir = osync_try_malloc0(sizeof(MockDir), error); 
    613614                osync_assert(dir); 
    614615 
    615616                dir->committed_all = TRUE; 
    616617 
    617                 OSyncObjTypeSink *sink = osync_plugin_info_nth_objtype(info, i); 
     618                OSyncObjTypeSink *sink = (OSyncObjTypeSink*)list->data; 
    618619                osync_assert(sink); 
     620                list = list->next; 
    619621 
    620622                const char *objtype = osync_objtype_sink_get_name(sink); 
    621623                dir->res = osync_plugin_config_find_active_resource(config, objtype); 
    … …  
    723725#endif 
    724726                env->directories = g_list_append(env->directories, dir); 
    725727        } 
    726  
     728        osync_list_free(objtypesinks); 
    727729        osync_trace(TRACE_EXIT, "%s: %p", __func__, env); 
    728730        return (void *)env; 
    729731} 

  • tests/engine-tests/check_engine_error.c

     
    130130 
    131131        mock_env *env = osync_try_malloc0(sizeof(mock_env), error); 
    132132        osync_assert(env); 
    133  
    134         OSyncObjTypeSink *sink = osync_plugin_info_nth_objtype(info, 0); 
     133        OSyncList *objtypesinks = osync_plugin_info_get_objtypes(info); 
     134        OSyncObjTypeSink *sink = (OSyncObjTypeSink*)objtypesinks->data; 
    135135        osync_assert(sink); 
    136136         
    137137        OSyncObjFormatSink *formatsink = osync_objformat_sink_new("mockformat1", error); 
    … …  
    147147        osync_plugin_info_add_objtype(info, sink); 
    148148        osync_objtype_sink_unref(sink); 
    149149 
     150        osync_list_free(objtypesinks); 
    150151        osync_trace(TRACE_EXIT, "%s: %p", __func__, env); 
    151152        return (void *)env; 
    152153}