transmission/libtransmission/ptrarray.c

/*
 * This file Copyright (C) Mnemosyne LLC
 *
 * This file is licensed by the GPL version 2. Works owned by the
 * Transmission project are granted a special exemption to clause 2(b)
 * so that the bulk of its code can remain under the MIT license.
 * This exemption does not extend to derived works not owned by
 * the Transmission project.
 *
 * $Id$
 */

#include <assert.h>
#include <stdlib.h> /* tr_renew() -> realloc() */
#include <string.h> /* memmove */

#include "ptrarray.h"
#include "utils.h"

#define FLOOR 32

const tr_ptrArray TR_PTR_ARRAY_INIT = { NULL, 0, 0 };

void
tr_ptrArrayDestruct( tr_ptrArray * p, PtrArrayForeachFunc func )
{
    assert( p );
    assert( p->items || !p->n_items );

    if( func )
        tr_ptrArrayForeach( p, func );

    tr_free( p->items );

    memset( p, ~0, sizeof( tr_ptrArray ) );
}

void
tr_ptrArrayForeach( tr_ptrArray *       t,
                    PtrArrayForeachFunc func )
{
    int i;

    assert( t );
    assert( t->items || !t->n_items );
    assert( func );

    for( i = 0; i < t->n_items; ++i )
        func( t->items[i] );
}

void**
tr_ptrArrayPeek( tr_ptrArray * t,
                 int *         size )
{
    *size = t->n_items;
    return t->items;
}

int
tr_ptrArrayInsert( tr_ptrArray * t,
                   void        * ptr,
                   int           pos )
{
    if( t->n_items >= t->n_alloc )
    {
        t->n_alloc = MAX( FLOOR, t->n_alloc * 2 );
        t->items = tr_renew( void*, t->items, t->n_alloc );
    }

    if( pos < 0 || pos > t->n_items )
        pos = t->n_items;
    else
        memmove( t->items + pos + 1,
                 t->items + pos,
                 sizeof( void* ) * ( t->n_items - pos ) );

    t->items[pos] = ptr;
    t->n_items++;
    return pos;
}

void*
tr_ptrArrayPop( tr_ptrArray* t )
{
    void * ret = NULL;

    if( t->n_items )
        ret = t->items[--t->n_items];

    return ret;
}

void
tr_ptrArrayErase( tr_ptrArray * t,
                  int           begin,
                  int           end )
{
    assert( begin >= 0 );
    if( end < 0 ) end = t->n_items;
    assert( begin < end );
    assert( end <= t->n_items );

    memmove( t->items + begin,
             t->items + end,
             sizeof( void* ) * ( t->n_items - end ) );

    t->n_items -= ( end - begin );
}

/**
***
**/

int
tr_ptrArrayLowerBound( const tr_ptrArray  * t,
                       const void         * ptr,
                       int                  compare( const void *, const void * ),
                       bool               * exact_match )
{
    int pos = -1;
    bool match = false;

    if( t->n_items == 0 )
    {
        pos = 0;
    }
    else
    {
        int first = 0;
        int last = t->n_items - 1;

        for( ;; )
        {
            const int half = (last - first) / 2;
            const int c = compare( t->items[first + half], ptr );

            if( c < 0 ) {
                const int new_first = first + half + 1;
                if( new_first > last ) {
                    pos = new_first;
                    break;
                }
                first = new_first;
            }
            else if( c > 0 ) {
                const int new_last = first + half - 1;
                if( new_last < first ) {
                    pos = first;
                    break;
                }
                last = new_last;
            }
            else {
                match = true;
                pos = first + half;
                break;
            }
        }
    }

    if( exact_match )
        *exact_match = match;
    return pos;
}

static void
assertSortedAndUnique( const tr_ptrArray * t UNUSED,
                       int compare(const void*, const void*) UNUSED )
{
#ifndef NDEBUG
    int i;

    for( i = 0; i < t->n_items - 2; ++i )
        assert( compare( t->items[i], t->items[i + 1] ) < 0 );
#endif
}

int
tr_ptrArrayInsertSorted( tr_ptrArray * t,
                         void *        ptr,
                         int           compare(const void*, const void*) )
{
    int pos;
    int ret;

    assertSortedAndUnique( t, compare );

    pos = tr_ptrArrayLowerBound( t, ptr, compare, NULL );
    ret = tr_ptrArrayInsert( t, ptr, pos );

    assertSortedAndUnique( t, compare );
    return ret;
}

void*
tr_ptrArrayFindSorted( tr_ptrArray * t,
                       const void *  ptr,
                       int           compare(const void*, const void*) )
{
    bool match = false;
    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
    return match ? t->items[pos] : NULL;
}

void*
tr_ptrArrayRemoveSorted( tr_ptrArray * t,
                         const void  * ptr,
                         int           compare(const void*, const void*) )
{
    bool match;
    void * ret = NULL;
    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
    assertSortedAndUnique( t, compare );

    if( match )
    {
        ret = t->items[pos];
        assert( compare( ret, ptr ) == 0 );
        tr_ptrArrayErase( t, pos, pos + 1 );
    }
    assertSortedAndUnique( t, compare );
    assert( ( ret == NULL ) || ( compare( ret, ptr ) == 0 ) );
    return ret;
}