/Users/maurits/Documents/studie/afstuderen/biosphere/common/list.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: feb 13, 2007
 * 
 * Function:
 * A general purpose list implementation.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */

#include "list.h"
#include "alloc.h"

#include <assert.h>
#include <apr_pools.h>

#define INITIAL_LIST_SIZE       16


bs_list *new_list(apr_pool_t *mp)
{
        apr_status_t rv;
        apr_pool_t *pool;
        bs_list *list = NULL;
        
        /* Create a subpool for this list and its data: */
        rv = apr_pool_create(&pool, mp);
        if (rv != APR_SUCCESS) return NULL;
        
        /* Initialize data members: */
    list                        = apr_pcalloc(pool, sizeof(bs_list));
    list->size      = 0;
    list->allocated = INITIAL_LIST_SIZE;
    list->pool          = pool;
    list->data      = apr_pcalloc(pool, sizeof(void * [INITIAL_LIST_SIZE]));
    
    return list;
}


void delete_list(bs_list *list)
{
    if (list != NULL) {
        apr_pool_destroy(list->pool);
    }
}


void list_remove(bs_list *l, unsigned index)
{
        unsigned i;
        assert(l != NULL && index < l->size);
        
        for (i = index + 1; i < l->size; i++) {
                l->data[i - 1] = l->data[i];
        }
        l->size--;
}


void list_append(bs_list *list, void *data)
{
        assert(list != NULL);
        
    if (list->size == list->allocated) {
        list->allocated *= 2;
        list->data = pool_realloc(list->data,
                        list->size,
                        sizeof(void *) * list->allocated,
                        list->pool);
    }

    list->data[list->size++] = data;
}


void list_insert(bs_list *l, unsigned index, void *data)
{
        assert(l != NULL);
        if (index >= l->size) list_append(l, data);
        else {
                unsigned i;
                
                /* Reserve some space if necessary: */
                if (l->size == l->allocated) {
                l->allocated *= 2;
                l->data = pool_realloc(l->data, l->size,
                                sizeof(void *) * l->allocated, l->pool);
        }
        
        /* Insert: */
        for (i = l->size; i > index; i--) l->data[i] = l->data[i - 1];
        l->data[index] = data;
        }
}


void list_merge(bs_list *list_1, bs_list *list_2)
{
    int i;
    assert(list_1 != NULL && list_2 != NULL);

    for (i = 0; i < list_2->size; i++)
        list_append(list_1, list_2->data [i]);

    delete_list(list_2);
}


inline unsigned list_size(const bs_list *list)
{
        assert(list != NULL);
    return list->size;
}


inline void *list_index(const bs_list *list, unsigned index)
{
    assert(list != NULL && index < list->size);
    return list->data[index];
}

---