list.h

Ir a la documentación de este archivo.

/*
 * Copyright (C) 2012 Sistemas Operativos - UTN FRBA. All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef LIST_H_
#define LIST_H_
 
    #include "node.h"
    #include <stdbool.h>
 
    typedef struct {
        t_link_element *head;
        int elements_count;
    } t_list;
 
    typedef struct {
        t_list *list;
        t_link_element **actual;
        t_link_element **next;
        int index;
    } t_list_iterator;
 
    t_list * list_create(void);
 
    int list_add(t_list* self, void *element);
 
    void list_destroy(t_list* self);
 
    void list_destroy_and_destroy_elements(t_list* self, void(*element_destroyer)(void*));
 
    void list_add_in_index(t_list* self, int index, void *element);
 
    int list_add_sorted(t_list *self, void* data, bool (*comparator)(void*,void*));
 
    void list_add_all(t_list* self, t_list* other);
 
    void *list_get(t_list* self, int index);
 
    void *list_get_minimum(t_list* self, void* (*minimum)(void*, void*));
 
    void *list_get_maximum(t_list* self, void* (*maximum)(void*, void*));
 
    t_list* list_take(t_list* self, int count);
 
    t_list* list_slice(t_list* self, int start, int count);
 
    t_list* list_take_and_remove(t_list* self, int count);
 
    t_list* list_slice_and_remove(t_list* self, int start, int count);
 
    t_list* list_filter(t_list* self, bool(*condition)(void*));
 
    t_list* list_map(t_list* self, void*(*transformer)(void*));
 
    t_list* list_flatten(t_list* self);
 
    void *list_replace(t_list* self, int index, void* element);
 
    void *list_replace_by_condition(t_list* self, bool(*condition)(void*), void* element);
 
    void list_replace_and_destroy_element(t_list* self, int index, void* element, void(*element_destroyer)(void*));
 
    void *list_remove(t_list* self, int index);
 
    bool list_remove_element(t_list* self, void* element);
 
    void list_remove_and_destroy_element(t_list* self, int index, void(*element_destroyer)(void*));
 
    void *list_remove_by_condition(t_list* self, bool(*condition)(void*));
 
    void list_remove_and_destroy_by_condition(t_list* self, bool(*condition)(void*), void(*element_destroyer)(void*));
 
    void list_remove_and_destroy_all_by_condition(t_list *self, bool(*condition)(void*), void(*element_destroyer)(void*));
 
    void list_clean(t_list* self);
 
    void list_clean_and_destroy_elements(t_list *self, void(*element_destroyer)(void*));
 
    void list_iterate(t_list* self, void(*closure)(void*));
 
    void *list_find(t_list* self, bool(*closure)(void*));
 
    int list_size(t_list* self);
 
    bool list_is_empty(t_list* self);
 
    void list_sort(t_list* self, bool (*comparator)(void *, void *));
 
    t_list* list_sorted(t_list* self, bool (*comparator)(void *, void *));
 
    int list_count_satisfying(t_list* self, bool(*condition)(void*));
 
    bool list_any_satisfy(t_list* self, bool(*condition)(void*));
 
    bool list_all_satisfy(t_list* self, bool(*condition)(void*));
 
    t_list* list_duplicate(t_list* self);
 
    void* list_fold(t_list* self, void* seed, void*(*operation)(void*, void*));
 
    void* list_fold1(t_list* self, void* (*operation)(void*, void*));
 
    t_list_iterator* list_iterator_create(t_list* list);
 
    bool list_iterator_has_next(t_list_iterator* iterator);
 
    void* list_iterator_next(t_list_iterator* iterator);
 
    int list_iterator_index(t_list_iterator* iterator);
 
    void list_iterator_add(t_list_iterator* iterator, void *data);
 
    void list_iterator_remove(t_list_iterator* iterator);
 
    void list_iterator_replace(t_list_iterator* iterator, void *data);
 
    void list_iterator_destroy(t_list_iterator* iterator);
 
#endif /*LIST_H_*/