Momentum-Apps/src/util/list.c

#include "list.h"
#include "helpers.h"

List *list_make() {
    List *list = malloc(sizeof(List));
    if (list != NULL) {
        list->head = NULL;
        list->tail = NULL;
        list->count = 0;
    } else {
        FURI_LOG_W("LIST", "Failed to create list");
    }
    return list;
}

void list_free(List *list) {
    if (list == NULL) return;

    ListItem *start = list->head;
    while (start) {
        ListItem *next = start->next;
        free(start->data);
        free(start);
        start = next;
    }
    free(list);
}

void list_free_data(List *list) {
    if (list == NULL) return;

    ListItem *start = list->head;
    while (start) {
        ListItem *next = start->next;
        free(start->data);
        free(start);
        start = next;
    }

    list->head = NULL;
    list->tail = NULL;
    list->count = 0;
}

void list_clear(List *list) {
    if (list == NULL) return;
    ListItem *start = list->head;
    while (start) {
        ListItem *next = start->next;
        free(start);
        start = next;
    }
    list->head = NULL;
    list->tail = NULL;
    list->count = 0;
}

void list_push_back(void *data, List *list) {
    if (list == NULL) {
        FURI_LOG_W("LIST", "List not initialized, cannot push data");
        return;
    }
    ListItem *newItem = malloc(sizeof(ListItem));
    if (newItem != NULL) {
        newItem->data = data;
        newItem->next = NULL;
        newItem->prev = list->tail;

        if (list->tail == NULL) {
            list->head = newItem;
            list->tail = newItem;
        } else {
            list->tail->next = newItem;
            list->tail = newItem;
        }
        list->count++;
    }
}

void list_push_front(void *data, List *list) {
    if (list == NULL) {
        FURI_LOG_W("LIST", "List not initialized, cannot push data");
        return;
    }
    ListItem *newItem = malloc(sizeof(ListItem));
    if (newItem != NULL) {
        newItem->data = data;
        newItem->next = list->head;
        if (list->head == NULL) {
            list->head = newItem;
            list->tail = newItem;
        } else {
            list->head->prev = newItem;
            list->head = newItem;
        }
        list->count++;
    }
}

void *list_pop_back(List *list) {
    if (!check_pointer(list)) {
        FURI_LOG_W("LIST", "List not initialized, cannot pop data");
        return NULL;
    }

    if (!check_pointer(list->tail)) {
        FURI_LOG_W("LIST", "List empty, cannot pop");
        return NULL;
    }
    void *data = list->tail->data;
    check_pointer(data);
    ListItem *prev = list->tail->prev;
    check_pointer(prev);
    if (prev) {
        prev->next = NULL;
    } else {
        list->head = NULL;
    }
    free(list->tail);
    list->tail = prev;
    list->count--;
    return data;
}

void *list_pop_front(List *list) {
    if (!check_pointer(list)) {
        FURI_LOG_W("LIST", "List not initialized, cannot pop data");
        return NULL;
    }
    if (!check_pointer(list->head)) {
        FURI_LOG_W("LIST", "List empty, cannot pop");
        return NULL;
    }
    void *data = list->head->data;
    check_pointer(data);
    ListItem *next = list->head->next;
    if (next) {
        next->prev = NULL;
    } else {
        list->tail = NULL;
    }
    free(list->head);
    list->head = next;
    list->count--;
    return data;
}

void *list_pop_at(size_t index, List *list) {
    if (!check_pointer(list)) {
        FURI_LOG_W("LIST", "List not initialized, cannot pop data");
        return NULL;
    }
    if (index >= list->count) {
        FURI_LOG_W("LIST", "Out of range, cannot pop");
        return NULL;
    }
    if (index == 0) {
        return list_pop_front(list);
    }
    if (index == list->count - 1) {
        return list_pop_back(list);
    }
    ListItem *current = list->head;
    check_pointer(current);
    for (size_t i = 0; i < index; i++) {
        current = current->next;
    }
    check_pointer(current);
    void *data = current->data;
    check_pointer(data);
    current->prev->next = current->next;
    current->next->prev = current->prev;
    free(current);
    list->count--;
    return data;
}

void list_remove_item(void *data, List *list) {
    if (list == NULL) {
        return;
    }
    ListItem *current = list->head;
    while (current != NULL) {
        if (current->data == data) {
            if (current->prev != NULL) {
                current->prev->next = current->next;
            } else {
                list->head = current->next;
            }
            if (current->next != NULL) {
                current->next->prev = current->prev;
            } else {
                list->tail = current->prev;
            }
            free(current);
            list->count--;
            break;
        }
        current = current->next;
    }
}

void list_remove_at(size_t index, List *list) {
    if (list == NULL) {
        return;
    }
    void *d = list_pop_at(index, list);
    free(d);
}


List *list_splice(size_t index, size_t count, List *list) {
    if (list == NULL) {
        FURI_LOG_W("LIST", "List not initialized, cannot splice");
        return NULL;
    }
    List *newList = list_make();
    if (index >= list->count || count == 0) {
        return newList;
    }
    if (index == 0 && count >= list->count) {
        newList->head = list->head;
        newList->tail = list->tail;
        newList->count = list->count;
        list->head = NULL;
        list->tail = NULL;
        list->count = 0;
        return newList;
    }

    ListItem *start = list->head;
    for (size_t i = 0; i < index; i++) {
        start = start->next;
    }

    size_t c = count;
    if (c > list->count) c = list->count - index;

    ListItem *end = start;
    for (size_t i = 1; i < c && end->next; i++) {
        end = end->next;
        if (end->next == NULL) c = i;
    }

    newList->head = start;
    newList->tail = end;
    newList->count = c;

    if (end->next != NULL) {
        end->next->prev = start->prev;
    } else {
        list->tail = start->prev;
    }

    if (start->prev != NULL) {
        start->prev->next = end->next;
    } else {
        list->head = end->next;
    }

    start->prev = NULL;
    end->next = NULL;
    list->count -= c;
    return newList;
}

void *list_peek_front(List *list) {
    if (list == NULL || list->head == NULL) {
        return NULL;
    }
    return list->head->data;
}

ListItem *list_get_index(List *list, size_t index){
    check_pointer(list);
    ListItem *curr = list->head;
    check_pointer(curr);
    if(index > list->count || !curr) return NULL;
    for (size_t i = 0; i < index; i++) {
        if (!curr) return NULL;
        curr = curr->next;
    }
    return curr;
}


void *list_peek_index(List *list, size_t index) {
    ListItem *curr = list_get_index(list,index);
    check_pointer(curr);
    if(curr) {
        check_pointer(curr->data);
        return curr->data;
    }
    return NULL;
}

void *list_peek_back(List *list) {
    if (!list || !list->tail) {
        return NULL;
    }
    check_pointer(list->tail->data);
    return list->tail->data;
}