Ignore:
Timestamp:
Dec 5, 2012, 5:29:46 PM (8 years ago)
Author:
jordan
Message:

Follow more common whitespace style conventions in the C code (libtransmission, daemon, utils, cli, gtk).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/ptrarray.c

    r12606 r13625  
    33 *
    44 * This file is licensed by the GPL version 2. Works owned by the
    5  * Transmission project are granted a special exemption to clause 2(b)
     5 * Transmission project are granted a special exemption to clause 2 (b)
    66 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
     
    1212
    1313#include <assert.h>
    14 #include <stdlib.h> /* tr_renew() -> realloc() */
     14#include <stdlib.h> /* tr_renew () -> realloc () */
    1515#include <string.h> /* memmove */
    1616
     
    2323
    2424void
    25 tr_ptrArrayDestruct( tr_ptrArray * p, PtrArrayForeachFunc func )
    26 {
    27     assert( p );
    28     assert( p->items || !p->n_items );
    29 
    30     if( func )
    31         tr_ptrArrayForeach( p, func );
    32 
    33     tr_free( p->items );
    34 
    35     memset( p, ~0, sizeof( tr_ptrArray ) );
     25tr_ptrArrayDestruct (tr_ptrArray * p, PtrArrayForeachFunc func)
     26{
     27    assert (p);
     28    assert (p->items || !p->n_items);
     29
     30    if (func)
     31        tr_ptrArrayForeach (p, func);
     32
     33    tr_free (p->items);
     34
     35    memset (p, ~0, sizeof (tr_ptrArray));
    3636}
    3737
    3838void
    39 tr_ptrArrayForeach( tr_ptrArray *       t,
    40                     PtrArrayForeachFunc func )
     39tr_ptrArrayForeach (tr_ptrArray *       t,
     40                    PtrArrayForeachFunc func)
    4141{
    4242    int i;
    4343
    44     assert( t );
    45     assert( t->items || !t->n_items );
    46     assert( func );
    47 
    48     for( i = 0; i < t->n_items; ++i )
    49         func( t->items[i] );
     44    assert (t);
     45    assert (t->items || !t->n_items);
     46    assert (func);
     47
     48    for (i = 0; i < t->n_items; ++i)
     49        func (t->items[i]);
    5050}
    5151
    5252void**
    53 tr_ptrArrayPeek( tr_ptrArray * t,
    54                  int *         size )
     53tr_ptrArrayPeek (tr_ptrArray * t,
     54                 int *         size)
    5555{
    5656    *size = t->n_items;
     
    5959
    6060int
    61 tr_ptrArrayInsert( tr_ptrArray * t,
     61tr_ptrArrayInsert (tr_ptrArray * t,
    6262                   void        * ptr,
    63                    int           pos )
    64 {
    65     if( t->n_items >= t->n_alloc )
    66     {
    67         t->n_alloc = MAX( FLOOR, t->n_alloc * 2 );
    68         t->items = tr_renew( void*, t->items, t->n_alloc );
    69     }
    70 
    71     if( pos < 0 || pos > t->n_items )
     63                   int           pos)
     64{
     65    if (t->n_items >= t->n_alloc)
     66    {
     67        t->n_alloc = MAX (FLOOR, t->n_alloc * 2);
     68        t->items = tr_renew (void*, t->items, t->n_alloc);
     69    }
     70
     71    if (pos < 0 || pos > t->n_items)
    7272        pos = t->n_items;
    7373    else
    74         memmove( t->items + pos + 1,
     74        memmove (t->items + pos + 1,
    7575                 t->items + pos,
    76                  sizeof( void* ) * ( t->n_items - pos ) );
     76                 sizeof (void*) * (t->n_items - pos));
    7777
    7878    t->items[pos] = ptr;
     
    8282
    8383void*
    84 tr_ptrArrayPop( tr_ptrArray* t )
     84tr_ptrArrayPop (tr_ptrArray* t)
    8585{
    8686    void * ret = NULL;
    8787
    88     if( t->n_items )
     88    if (t->n_items)
    8989        ret = t->items[--t->n_items];
    9090
     
    9393
    9494void
    95 tr_ptrArrayErase( tr_ptrArray * t,
     95tr_ptrArrayErase (tr_ptrArray * t,
    9696                  int           begin,
    97                   int           end )
    98 {
    99     assert( begin >= 0 );
    100     if( end < 0 ) end = t->n_items;
    101     assert( begin < end );
    102     assert( end <= t->n_items );
    103 
    104     memmove( t->items + begin,
     97                  int           end)
     98{
     99    assert (begin >= 0);
     100    if (end < 0) end = t->n_items;
     101    assert (begin < end);
     102    assert (end <= t->n_items);
     103
     104    memmove (t->items + begin,
    105105             t->items + end,
    106              sizeof( void* ) * ( t->n_items - end ) );
    107 
    108     t->n_items -= ( end - begin );
     106             sizeof (void*) * (t->n_items - end));
     107
     108    t->n_items -= (end - begin);
    109109}
    110110
     
    114114
    115115int
    116 tr_ptrArrayLowerBound( const tr_ptrArray  * t,
     116tr_ptrArrayLowerBound (const tr_ptrArray  * t,
    117117                       const void         * ptr,
    118                        int                  compare( const void *, const void * ),
    119                        bool               * exact_match )
     118                       int                  compare (const void *, const void *),
     119                       bool               * exact_match)
    120120{
    121121    int pos = -1;
    122122    bool match = false;
    123123
    124     if( t->n_items == 0 )
     124    if (t->n_items == 0)
    125125    {
    126126        pos = 0;
     
    131131        int last = t->n_items - 1;
    132132
    133         for( ;; )
     133        for (;;)
    134134        {
    135135            const int half = (last - first) / 2;
    136             const int c = compare( t->items[first + half], ptr );
    137 
    138             if( c < 0 ) {
     136            const int c = compare (t->items[first + half], ptr);
     137
     138            if (c < 0) {
    139139                const int new_first = first + half + 1;
    140                 if( new_first > last ) {
     140                if (new_first > last) {
    141141                    pos = new_first;
    142142                    break;
     
    144144                first = new_first;
    145145            }
    146             else if( c > 0 ) {
     146            else if (c > 0) {
    147147                const int new_last = first + half - 1;
    148                 if( new_last < first ) {
     148                if (new_last < first) {
    149149                    pos = first;
    150150                    break;
     
    160160    }
    161161
    162     if( exact_match )
     162    if (exact_match)
    163163        *exact_match = match;
    164164    return pos;
     
    166166
    167167static void
    168 assertSortedAndUnique( const tr_ptrArray * t UNUSED,
    169                        int compare(const void*, const void*) UNUSED )
     168assertSortedAndUnique (const tr_ptrArray * t UNUSED,
     169                       int compare (const void*, const void*) UNUSED)
    170170{
    171171#ifndef NDEBUG
    172172    int i;
    173173
    174     for( i = 0; i < t->n_items - 2; ++i )
    175         assert( compare( t->items[i], t->items[i + 1] ) < 0 );
     174    for (i = 0; i < t->n_items - 2; ++i)
     175        assert (compare (t->items[i], t->items[i + 1]) < 0);
    176176#endif
    177177}
    178178
    179179int
    180 tr_ptrArrayInsertSorted( tr_ptrArray * t,
     180tr_ptrArrayInsertSorted (tr_ptrArray * t,
    181181                         void *        ptr,
    182                          int           compare(const void*, const void*) )
     182                         int           compare (const void*, const void*))
    183183{
    184184    int pos;
    185185    int ret;
    186186
    187     assertSortedAndUnique( t, compare );
    188 
    189     pos = tr_ptrArrayLowerBound( t, ptr, compare, NULL );
    190     ret = tr_ptrArrayInsert( t, ptr, pos );
    191 
    192     assertSortedAndUnique( t, compare );
     187    assertSortedAndUnique (t, compare);
     188
     189    pos = tr_ptrArrayLowerBound (t, ptr, compare, NULL);
     190    ret = tr_ptrArrayInsert (t, ptr, pos);
     191
     192    assertSortedAndUnique (t, compare);
    193193    return ret;
    194194}
    195195
    196196void*
    197 tr_ptrArrayFindSorted( tr_ptrArray * t,
     197tr_ptrArrayFindSorted (tr_ptrArray * t,
    198198                       const void *  ptr,
    199                        int           compare(const void*, const void*) )
     199                       int           compare (const void*, const void*))
    200200{
    201201    bool match = false;
    202     const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
     202    const int pos = tr_ptrArrayLowerBound (t, ptr, compare, &match);
    203203    return match ? t->items[pos] : NULL;
    204204}
    205205
    206206void*
    207 tr_ptrArrayRemoveSorted( tr_ptrArray * t,
     207tr_ptrArrayRemoveSorted (tr_ptrArray * t,
    208208                         const void  * ptr,
    209                          int           compare(const void*, const void*) )
     209                         int           compare (const void*, const void*))
    210210{
    211211    bool match;
    212212    void * ret = NULL;
    213     const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
    214     assertSortedAndUnique( t, compare );
    215 
    216     if( match )
     213    const int pos = tr_ptrArrayLowerBound (t, ptr, compare, &match);
     214    assertSortedAndUnique (t, compare);
     215
     216    if (match)
    217217    {
    218218        ret = t->items[pos];
    219         assert( compare( ret, ptr ) == 0 );
    220         tr_ptrArrayErase( t, pos, pos + 1 );
    221     }
    222     assertSortedAndUnique( t, compare );
    223     assert( ( ret == NULL ) || ( compare( ret, ptr ) == 0 ) );
     219        assert (compare (ret, ptr) == 0);
     220        tr_ptrArrayErase (t, pos, pos + 1);
     221    }
     222    assertSortedAndUnique (t, compare);
     223    assert ((ret == NULL) || (compare (ret, ptr) == 0));
    224224    return ret;
    225225}
Note: See TracChangeset for help on using the changeset viewer.