Changeset 3300

Show
Ignore:
Timestamp:
04/27/08 15:52:30 (5 months ago)
Author:
dgollub
Message:

Quick hashtable API port.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • plugins/gnokii-sync/src/gnokii_calendar.c

    r3164 r3300  
    355355        gnokii_environment *env = (gnokii_environment *) plugindata; 
    356356 
    357         // reset reports internal hashtable list, to discover deleted entries 
    358         osync_hashtable_reset_reports(sinkenv->hashtable); 
    359  
    360357        // check for slowsync and prepare the "event" hashtable if needed 
    361358        if (osync_objtype_sink_get_slowsync(sink)) {             
    …… 
    373370 
    374371                calnote = gnokii_calendar_get_calnote(i, caldata, env->state, error_note); 
    375                  
    376372                if (calnote == NULL) 
    377373                        break; 
    378374 
    379                 // prepare UID with gnokii-calendar-<memory location> 
     375                OSyncChange *change = osync_change_new(&error); 
     376 
     377                /* prepare UID with gnokii-calendar-<memory location> */ 
    380378                uid = g_strdup_printf ("gnokii-calendar-%i", calnote->location); 
    381                 osync_hashtable_report(sinkenv->hashtable, uid); 
     379                osync_change_set_uid(change, uid); 
     380                g_free(uid); 
    382381 
    383382                hash = gnokii_calendar_hash(calnote); 
    384                 OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, uid, hash); 
     383                osync_change_set_hash(change, hash);     
     384                g_free(hash); 
     385 
     386                OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, change); 
     387                osync_change_set_changetype(change, type); 
     388 
     389                /* Once hash and uid is set to change object - report it! 
     390                   Otherwise the hashtable will declare it as deleted. */ 
     391                //osync_hashtable_report(sinkenv->hashtable, change); 
     392                osync_hashtable_update_change(sinkenv->hashtable, change); 
    385393 
    386394                if (type == OSYNC_CHANGE_TYPE_UNMODIFIED) { 
    387                         g_free(hash); 
    388                         g_free(uid); 
     395                        /* Nothing to do. */ 
    389396                        g_free(calnote); 
    390397                        continue; 
    391398                } 
    392399 
    393                 osync_hashtable_update_hash(sinkenv->hashtable, type, uid, hash); 
    394  
    395                 OSyncChange *change = osync_change_new(&error); 
    396  
    397                 osync_change_set_uid(change, uid); 
    398                 osync_change_set_hash(change, hash);     
    399                 osync_change_set_changetype(change, type); 
    400  
    401                 // set data 
     400                /* set data */ 
    402401                osync_trace(TRACE_INTERNAL, "objformat: %p", sinkenv->objformat); 
    403402                OSyncData *odata = osync_data_new((char *) calnote, sizeof(gn_calnote), sinkenv->objformat, &error); 
    …… 
    406405                        osync_context_report_osyncwarning(ctx, error); 
    407406                        osync_error_unref(&error); 
    408                         g_free(hash); 
    409                         g_free(uid); 
    410                         g_free(calnote); 
    411407                        continue; 
    412408                } 
    …… 
    421417 
    422418                osync_change_unref(change); 
    423  
    424                 g_free(hash); 
    425                 g_free(uid); 
     419                g_free(calnote); 
    426420        } 
    427421 
    …… 
    429423 
    430424        assert(sinkenv->hashtable); 
    431         char **uids = osync_hashtable_get_deleted(sinkenv->hashtable); 
    432         for (i = 0; uids[i]; i++) { 
     425        OSyncList *u, *uids = osync_hashtable_get_deleted(sinkenv->hashtable); 
     426        for (u = uids; u; u = u->next) { 
    433427                OSyncChange *change = osync_change_new(&error); 
    434428                if (!change) { 
    435                         g_free(uids[i]); 
    436429                        osync_context_report_osyncwarning(ctx, error); 
    437430                        osync_error_unref(&error); 
    …… 
    439432                } 
    440433 
    441                 osync_change_set_uid(change, uids[i]); 
     434                const char *uid = u->data; 
     435 
     436                osync_change_set_uid(change, uid); 
    442437                osync_change_set_changetype(change, OSYNC_CHANGE_TYPE_DELETED); 
    443438 
    444439                OSyncData *odata = osync_data_new(NULL, 0, sinkenv->objformat, &error); 
    445440                if (!odata) { 
    446                         g_free(uids[i]); 
    447441                        osync_change_unref(change); 
    448442                        osync_context_report_osyncwarning(ctx, error); 
    …… 
    455449                osync_data_unref(odata); 
    456450 
     451                osync_hashtable_update_change(sinkenv->hashtable, change); 
     452 
    457453                osync_context_report_change(ctx, change); 
    458454 
    459                 osync_hashtable_update_hash(sinkenv->hashtable, osync_change_get_changetype(change), osync_change_get_uid(change), NULL); 
    460  
    461455                osync_change_unref(change); 
    462                 g_free(uids[i]); 
    463456        } 
    464         g_free(uids); 
    465  
    466457 
    467458        g_free(caldata); 
    …… 
    538529 
    539530                        /////////// WORKAROUND for "dirty" modify /////////// 
    540                         /* 
    541  
    542                         // fake a delete change to remove the old hash 
    543                         OSyncChange *delete_change = osync_change_new(&error); 
    544  
    545                         // the old uid will be set for this "fake" change 
    546                         osync_change_set_uid(delete_change, osync_change_get_uid(change)); 
    547                         osync_change_set_changetype(delete_change, OSYNC_CHANGE_TYPE_DELETED); 
    548                         osync_hashtable_update_hash(sinkenv->hashtable, OSYNC_CHANGE_TYPE_DELETED, osync_change_get_uid(change), delete_change); 
    549                         */ 
    550  
    551                         osync_hashtable_delete(sinkenv->hashtable, osync_change_get_uid(change)); 
     531                        osync_change_set_changetype(change, OSYNC_CHANGE_TYPE_DELETED); 
     532                        osync_hashtable_update_change(sinkenv->hashtable, change); 
    552533 
    553534                        // update the old UID with the followed UID for the hashtable 
    …… 
    555536                        uid = gnokii_calendar_memory_uid(calnote->location); 
    556537                        osync_change_set_uid(change, uid); 
    557  
     538                        g_free(uid); 
    558539 
    559540                        // set modified changetype for calendar entry  
    …… 
    563544                        hash = gnokii_calendar_hash(calnote); 
    564545                        osync_change_set_hash(change, hash); 
    565  
    566                         osync_hashtable_write(sinkenv->hashtable, uid, hash); 
    567  
    568546                        g_free(hash); 
    569                         g_free(uid); 
     547 
     548                        //osync_hashtable_update_change(sinkenv->hashtable, change); 
    570549 
    571550                        /* 
    …… 
    587566                                
    588567        // update hashtable 
    589         osync_hashtable_update_hash(sinkenv->hashtable, osync_change_get_changetype(change), osync_change_get_uid(change), osync_change_get_hash(change)); 
     568        osync_hashtable_update_change(sinkenv->hashtable, change); 
    590569 
    591570        osync_trace(TRACE_EXIT, "%s", __func__); 

  • plugins/gnokii-sync/src/gnokii_contact.c

    r3164 r3300  
    398398        osync_trace(TRACE_INTERNAL, "sinkenv: %p", sinkenv); 
    399399 
    400         // reset reports internal hashtable list, to discover deleted entries 
    401         osync_hashtable_reset_reports(sinkenv->hashtable); 
    402  
    403400        // check for slowsync and prepare the "contact" hashtable if needed 
    404401        if (osync_objtype_sink_get_slowsync(sink)) {             
    …… 
    459456                                continue; 
    460457 
    461                         // prepare UID with gnokii-contact-<memory type>-<memory location> 
     458                        OSyncChange *change = osync_change_new(&error); 
     459 
     460                        /* prepare UID with gnokii-contact-<memory type>-<memory location> */ 
    462461                        uid = gnokii_contact_uid(contact); 
    463                         osync_hashtable_report(sinkenv->hashtable, uid); 
    464  
     462                        osync_change_set_uid(change, uid); 
     463                        g_free(uid); 
     464 
     465                        /* set hash */ 
    465466                        hash = gnokii_contact_hash(contact); 
    466                         OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, uid, hash); 
     467                        osync_change_set_hash(change, hash);     
     468                        g_free(hash); 
     469 
     470                        /* Once UID and HASH got set - report it! */ 
     471                        //osync_hashtable_report(sinkenv->hashtable, change); 
     472 
     473                        OSyncChangeType type = osync_hashtable_get_changetype(sinkenv->hashtable, change); 
     474                        osync_change_set_changetype(change, type); 
     475 
     476                        osync_hashtable_update_change(sinkenv->hashtable, change); 
    467477 
    468478                        if (type == OSYNC_CHANGE_TYPE_UNMODIFIED) { 
    469                                 g_free(hash); 
    470                                 g_free(uid); 
     479                                /* Nothing to do. */ 
    471480                                g_free(contact); 
    472481                                continue; 
    473482                        } 
    474483 
    475                         osync_hashtable_update_hash(sinkenv->hashtable, type, uid, hash); 
    476  
    477                         OSyncChange *change = osync_change_new(&error); 
    478  
    479  
    480                         osync_change_set_uid(change, uid); 
    481                         osync_change_set_hash(change, hash);     
    482                         osync_change_set_changetype(change, type); 
    483  
    484                         // set data 
     484                        /* set data */ 
    485485                        osync_trace(TRACE_INTERNAL, "objformat: %p", sinkenv->objformat); 
    486486                        OSyncData *odata = osync_data_new((char *) contact, sizeof(gn_phonebook_entry), sinkenv->objformat, &error); 
    …… 
    489489                                osync_context_report_osyncwarning(ctx, error); 
    490490                                osync_error_unref(&error); 
    491                                 g_free(hash); 
    492                                 g_free(uid); 
    493                                 g_free(contact); 
    494491                                continue; 
    495492                        } 
    …… 
    505502 
    506503                        osync_change_unref(change); 
    507  
    508                         g_free(hash); 
    509                         g_free(uid); 
    510504                } 
    511505        } 
    …… 
    514508 
    515509        int i; 
    516         char **uids = osync_hashtable_get_deleted(sinkenv->hashtable); 
    517         for (i = 0; uids[i]; i++) { 
     510        OSyncList *u, *uids = osync_hashtable_get_deleted(sinkenv->hashtable); 
     511        for (u = uids; u; u = u->next) { 
    518512                OSyncChange *change = osync_change_new(&error); 
    519513                if (!change) { 
    520                         g_free(uids[i]); 
    521514                        osync_context_report_osyncwarning(ctx, error); 
    522515                        osync_error_unref(&error); 
    …… 
    524517                } 
    525518 
    526                 osync_change_set_uid(change, uids[i]); 
     519                const char *uid = u->data; 
     520 
     521                osync_change_set_uid(change, uid); 
    527522                osync_change_set_changetype(change, OSYNC_CHANGE_TYPE_DELETED); 
    528523 
    529524                OSyncData *odata = osync_data_new(NULL, 0, sinkenv->objformat, &error); 
    530525                if (!odata) { 
    531                         g_free(uids[i]); 
    532526                        osync_change_unref(change); 
    533527                        osync_context_report_osyncwarning(ctx, error); 
    …… 
    542536                osync_context_report_change(ctx, change); 
    543537 
    544                 osync_hashtable_update_hash(sinkenv->hashtable, osync_change_get_changetype(change), osync_change_get_uid(change), NULL); 
     538                osync_hashtable_update_change(sinkenv->hashtable, change); 
    545539 
    546540                osync_change_unref(change); 
    547                 g_free(uids[i]); 
    548541        } 
    549         g_free(uids); 
    550542 
    551543        osync_context_report_success(ctx); 
    …… 
    628620 
    629621        // update hashtable 
    630         osync_hashtable_update_hash(sinkenv->hashtable, osync_change_get_changetype(change), osync_change_get_uid(change), osync_change_get_hash(change)); 
     622        osync_hashtable_update_change(sinkenv->hashtable, change); 
    631623 
    632624 

  • plugins/gnokii-sync/src/gnokii_sync.c

    r3068 r3300  
    2929                // close the hashtable 
    3030                if (sinkenv->hashtable) { 
    31                         osync_hashtable_free(sinkenv->hashtable); 
     31                        osync_hashtable_unref(sinkenv->hashtable); 
    3232                } 
    3333 
    …… 
    8282        osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, ctx); 
    8383 
    84 //      gnokii_environment *env = (gnokii_environment *) data; 
    85          
    86         // forget reported changes 
    87         // osync_hashtable_forget(env->hashtable); 
     84        OSyncError *error = NULL; 
     85 
     86        //gnokii_environment *env = (gnokii_environment *) data; 
     87        OSyncObjTypeSink *sink = osync_plugin_info_get_sink(info); 
     88        gnokii_sinkenv *sinkenv = osync_objtype_sink_get_userdata(sink); 
     89 
     90        // commit changes to persistent hahstable  
     91        if (!osync_hashtable_save(sinkenv->hashtable, &error)) 
     92                goto error; 
    8893         
    8994        // answer the call 
    …… 
    9196 
    9297        osync_trace(TRACE_EXIT, "%s", __func__); 
     98        return; 
     99 
     100error: 
     101        osync_context_report_osyncerror(ctx, error); 
     102        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(&error)); 
     103        osync_error_unref(&error); 
    93104} 
    94105 
    …… 
    105116        if (!gnokii_comm_disconnect(env->state)) { 
    106117                osync_context_report_error(ctx, OSYNC_ERROR_GENERIC, "disconnect failed"); 
    107                 free_gnokiienv(env); 
    108118                return; 
    109119        } 
    …… 
    123133        // free everything 
    124134        free_gnokiienv(env); 
    125  
    126135 
    127136        osync_trace(TRACE_EXIT, "%s", __func__); 
    …… 
    222231        contact_sinkenv->hashtable = osync_hashtable_new(tablepath, "contact", error); 
    223232         
    224         //TODO: throw error. 
    225         //if (!contact_sinkenv->hashtable) 
    226         //      goto error; 
    227  
     233        if (!contact_sinkenv->hashtable) 
     234                goto error; 
     235 
     236        if (!osync_hashtable_load(contact_sinkenv->hashtable, error)) 
     237                goto error; 
    228238 
    229239        // init the event sink 
    …… 
    246256        event_sinkenv->hashtable = osync_hashtable_new(tablepath, "event", error); 
    247257 
     258        if (!event_sinkenv->hashtable) 
     259                goto error; 
     260 
     261        if (!osync_hashtable_load(event_sinkenv->hashtable, error)) 
     262                goto error; 
     263 
    248264        env->sinks = g_list_append(env->sinks, event_sinkenv); 
    249265         
    …… 
    257273 
    258274        return (void *)env; 
     275 
     276error: 
     277        osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); 
     278        return NULL; 
    259279} 
    260280