Chained_List.c

Go to the documentation of this file.

/* ############################ MALP License ############################## */
/* # Fri Jan 18 14:00:00 CET 2013                                         # */
/* # Copyright or (C) or Copr. Commissariat a l'Energie Atomique          # */
/* #                                                                      # */
/* # This software is governed by the CeCILL-C license under French law   # */
/* # and abiding by the rules of distribution of free software.  You can  # */
/* # use, modify and/ or redistribute the software under the terms of     # */
/* # the CeCILL-C license as circulated by CEA, CNRS and INRIA at the     # */
/* # following URL http://www.cecill.info.                                # */
/* #                                                                      # */
/* # The fact that you are presently reading this means that you have     # */
/* # had knowledge of the CeCILL-C license and that you accept its        # */
/* # terms.                                                               # */
/* #                                                                      # */
/* # Authors:                                                             # */
/* #   - BESNARD Jean-Baptiste jean-baptiste.besnard@cea.fr               # */
/* #                                                                      # */
/* ######################################################################## */
#include "Chained_List.h"

struct chained_list *chained_list_init(uint32_t size_of_trunk, size_t size_of_payload) {
        return chained_list_alloc_chunk(size_of_trunk, size_of_payload);
}


struct chained_list *chained_list_alloc_next_chunk(struct chained_list *current_chunk) {
        if (current_chunk == NULL)
                return NULL;

        struct chained_list *tmp = chained_list_alloc_chunk(current_chunk->size_of_trunk, current_chunk->size_of_payload);
        tmp->p_prev = current_chunk;

        return tmp;
}



struct chained_list *chained_list_alloc_chunk(uint32_t size_of_trunk, size_t size_of_payload) {
        struct chained_list *tmp = malloc(sizeof(struct chained_list));

        if( !tmp ) {
                printf("Failled to allocate chunk \n");
                return NULL;
        }

        tmp->p_payload = malloc(size_of_trunk * size_of_payload);

        if( !tmp->p_payload ) {
                printf("Failled to alloc chunk \n");
                return NULL;
        }

        tmp->size_of_trunk = size_of_trunk;
        tmp->size_of_payload = size_of_payload;
        tmp->current_offset = 0;
        tmp->p_prev = NULL;

        return tmp;
}


void *chained_list_push(struct chained_list **list, void *p_payload)
{


        if (*list == NULL) {
                fprintf(stderr,"Can't write to uninitialized chained_list in %s:%d\n", __FILE__, __LINE__);
                return NULL;
        }

        if ( (*list)->size_of_trunk <= (*list)->current_offset ) {
                struct chained_list *tmp = chained_list_alloc_next_chunk(*list);

                if( !tmp )
                        return NULL;


                *list = tmp;
        }

        void *push_addr = (char *) (*list)->p_payload + ((*list)->current_offset * (*list)->size_of_payload);

        memcpy( push_addr, (char *) p_payload, (*list)->size_of_payload);

        (*list)->current_offset++;


        return push_addr;
}

void cond_chained_list_merge(struct chained_list **dest, struct chained_list *source, int (*condition) (void *))
{
        if ((*dest)->size_of_payload != source->size_of_payload) {
                fprintf(stderr, "Can't merge chained lists of different types in %s:%d\n", __FILE__, __LINE__);
                return;
        }

        struct chained_list *tmp = source;

        int i = 0;

        while (tmp) {
                for (i = 0; i < tmp->current_offset; i++) {
                        void *current_elem = NULL;

                        current_elem = (struct symbol_descriptor *) ((char *) tmp->p_payload + (i * tmp->size_of_payload));
                        if ((condition) (current_elem))
                                chained_list_push(dest, current_elem);
                }
                tmp = tmp->p_prev;
        }
}



void chained_list_walkthrough(struct chained_list *list, void (*action) (void *))
{
        if( !action )
                return;

        struct chained_list *tmp = list;
        int i = 0;

        while (tmp) {
                for (i = 0; i < tmp->current_offset; i++)
                        (action) ((char *) tmp->p_payload + (i * tmp->size_of_payload));

                tmp = tmp->p_prev;
        }
}



void chained_list_walkthrough_arg(struct chained_list *list,
                                  void (*action) (void *, void *), void *arg)
{
        struct chained_list *tmp = list;
        int i = 0;
        while (tmp) {
                for (i = 0; i < tmp->current_offset; i++)
                        (action) ((char *) tmp->p_payload +
                                  (i * tmp->size_of_payload), arg);
                tmp = tmp->p_prev;
        }
}





int chained_list_count(struct chained_list *list)
{
        struct chained_list *tmp = list;
        int count = 0;
        while (tmp) {

                // printf("CLCount cout : %d tmp : %p \n", count, tmp);
                count += tmp->current_offset;
                tmp = tmp->p_prev;
        }

        // printf("Count returning %d \n", count);
        return count;
}


void chained_list_release(struct chained_list **list)
{
        struct chained_list *tmp = *list;
        struct chained_list *p_prev = NULL;

        while (tmp) {
                p_prev = tmp->p_prev;
                free(tmp->p_payload);
                free(tmp);
                tmp = p_prev;
        }

        *list = NULL;
}




void *chained_list_get_elem( struct chained_list *list, int (*test_func)(void *, void *), void *value )
{
        struct chained_list *tmp = list;
        int i = 0;
        void *elem = NULL;

        while (tmp) {
                for (i = 0; i < tmp->current_offset; i++) {
                        elem = (char *) tmp->p_payload + (i * tmp->size_of_payload);

                        if( test_func ) {
                                if( (test_func) (elem, value) ) {
                                        return elem;
                                }
                        } else {
                                if( *((uint64_t *)elem) == *((uint64_t *)value) ) {
                                        return elem;
                                }
                        }

                }
                tmp = tmp->p_prev;
        }

        return NULL;
}

//void print_int(void *p_payload)
//{
//    int *i = p_payload;
//    printf("> %d \n", *i);
//}

// int main()
// {
// int i = 0;
// struct chained_list *list = NULL;
// chained_list_push( &list, &i);
// list = chained_list_init( 10, sizeof(int) );
//
// for (i = 0 ; i < 210 ; i++ )
// chained_list_push( &list, &i);
//
// chained_list_walkthrough( list, print_int );
//
// int *pt = NULL;
// for( i = 0 ; i < 210 ; i++)
// {
// pt = (int *)chained_list_get_nth( list , i);
// printf("+> %d \n", *pt);
// }
// chained_list_release( &list );
//
// return 0;
// }