transmission/libtransmission/list.c

208 lines
4.0 KiB
C
Raw Normal View History

/*
* 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.
2007-08-18 17:19:49 +00:00
*
* $Id$
*/
#include "transmission.h"
#include "list.h"
#include "utils.h"
static const tr_list TR_LIST_CLEAR = { NULL, NULL, NULL };
static tr_list * recycled_nodes = NULL;
static tr_list*
node_alloc( void )
{
tr_list * ret;
if( recycled_nodes == NULL )
ret = tr_new( tr_list, 1 );
else {
ret = recycled_nodes;
recycled_nodes = recycled_nodes->next;
}
*ret = TR_LIST_CLEAR;
return ret;
}
static void
node_free( tr_list* node )
{
if( node != NULL )
{
*node = TR_LIST_CLEAR;
node->next = recycled_nodes;
recycled_nodes = node;
}
}
/***
****
***/
void
tr_list_free( tr_list** list,
TrListForeachFunc data_free_func )
{
while( *list )
{
tr_list *node = *list;
*list = ( *list )->next;
2008-08-01 16:43:22 +00:00
if( data_free_func )
data_free_func( node->data );
node_free( node );
}
}
void
tr_list_prepend( tr_list ** list,
void * data )
{
tr_list * node = node_alloc ( );
node->data = data;
node->next = *list;
if( *list )
( *list )->prev = node;
*list = node;
}
void
tr_list_append( tr_list ** list,
void * data )
{
tr_list * node = node_alloc( );
node->data = data;
if( !*list )
*list = node;
else
{
tr_list * l = *list;
while( l->next )
l = l->next;
l->next = node;
node->prev = l;
}
}
static tr_list*
tr_list_find_data( tr_list * list,
const void * data )
{
for( ; list; list = list->next )
if( list->data == data )
return list;
return NULL;
}
static void*
tr_list_remove_node( tr_list ** list,
tr_list * node )
{
void * data;
tr_list * prev = node ? node->prev : NULL;
tr_list * next = node ? node->next : NULL;
if( prev ) prev->next = next;
if( next ) next->prev = prev;
if( *list == node ) *list = next;
data = node ? node->data : NULL;
node_free( node );
return data;
}
void*
tr_list_pop_front( tr_list ** list )
{
void * ret = NULL;
2008-08-01 16:43:22 +00:00
if( *list )
{
ret = ( *list )->data;
tr_list_remove_node( list, *list );
}
return ret;
}
void*
tr_list_remove_data( tr_list ** list,
const void * data )
{
return tr_list_remove_node( list, tr_list_find_data( *list, data ) );
}
void*
tr_list_remove( tr_list ** list,
const void * b,
TrListCompareFunc compare_func )
{
return tr_list_remove_node( list, tr_list_find( *list, b, compare_func ) );
}
tr_list*
tr_list_find( tr_list * list,
const void * b,
TrListCompareFunc func )
{
for( ; list; list = list->next )
if( !func( list->data, b ) )
return list;
return NULL;
}
void
tr_list_insert_sorted( tr_list ** list,
void * data,
TrListCompareFunc compare )
{
/* find l, the node that we'll insert this data before */
tr_list * l;
for( l = *list; l != NULL; l = l->next )
{
const int c = (compare)( data, l->data );
if( c <= 0 )
break;
}
if( l == NULL )
tr_list_append( list, data );
else if( l == *list )
tr_list_prepend( list, data );
else {
tr_list * node = node_alloc( );
node->data = data;
node->prev = l->prev;
node->next = l;
node->prev->next = node;
node->next->prev = node;
}
}
int
tr_list_size( const tr_list * list )
{
int size = 0;
while( list )
{
++size;
list = list->next;
}
return size;
}