list.h

Go to the documentation of this file.

/*  list.h
 *
 *  Copyright (C) 2023 abxh
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *  See the file LICENSE included with this distribution for more
 *  information. */
 
#pragma once
 
#include "container_of.h" // container_of
 
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
 
struct list_node {
    struct list_node *prev_ptr; 
    struct list_node *next_ptr; 
};
 
#define list_node_entry(ptr, type, member) container_of(ptr, type, member)
 
 
// Add a node between two (known) nodes.
static inline void internal_list_node_add_between(struct list_node *node_ptr, struct list_node *before_ptr,
                                                  struct list_node *after_ptr);
 
// Attach two nodes together, so anything in between is ignored.
static inline void internal_list_node_attach(struct list_node *prev_ptr, struct list_node *next_ptr);
 
 
static inline void list_node_init(struct list_node *node_ptr)
{
    assert(node_ptr != NULL);
 
    node_ptr->prev_ptr = node_ptr->next_ptr = node_ptr;
}
 
static inline bool list_node_is_first(const struct list_node *node_ptr, const struct list_node *head_ptr)
{
    assert(node_ptr != NULL);
    assert(head_ptr != NULL);
 
    return node_ptr->prev_ptr == head_ptr;
}
 
static inline bool list_node_is_last(const struct list_node *node_ptr, const struct list_node *tail_ptr)
{
    assert(node_ptr != NULL);
    assert(tail_ptr != NULL);
 
    return node_ptr->next_ptr == tail_ptr;
}
 
static inline bool list_node_is_head(const struct list_node *node_ptr, const struct list_node *head_ptr)
{
    assert(node_ptr != NULL);
    assert(head_ptr != NULL);
 
    return node_ptr == head_ptr;
}
 
static inline bool list_node_is_tail(const struct list_node *node_ptr, const struct list_node *tail_ptr)
{
    assert(node_ptr != NULL);
    assert(tail_ptr != NULL);
 
    return node_ptr == tail_ptr;
}
 
static inline void list_node_add_after(struct list_node *node_ptr, struct list_node *prev_ptr)
{
    assert(node_ptr != NULL);
    assert(prev_ptr != NULL);
 
    internal_list_node_add_between(node_ptr, prev_ptr, prev_ptr->next_ptr);
}
 
static inline void list_node_add_before(struct list_node *node_ptr, struct list_node *next_ptr)
{
    assert(node_ptr != NULL);
    assert(next_ptr != NULL);
 
    internal_list_node_add_between(node_ptr, next_ptr->prev_ptr, next_ptr);
}
 
static inline struct list_node *list_node_remove(struct list_node *node_ptr)
{
    assert(node_ptr != NULL);
    assert(node_ptr->prev_ptr != node_ptr);
    assert(node_ptr->next_ptr != node_ptr);
 
    internal_list_node_attach(node_ptr->prev_ptr, node_ptr->next_ptr);
    list_node_init(node_ptr);
 
    return node_ptr;
}
 
static inline void list_node_replace(struct list_node *old_ptr, struct list_node *new_ptr)
{
    assert(old_ptr != NULL);
    assert(new_ptr != NULL);
    assert(old_ptr != new_ptr);
    assert(old_ptr->prev_ptr != old_ptr);
    assert(old_ptr->next_ptr != old_ptr);
 
    internal_list_node_add_between(new_ptr, old_ptr->prev_ptr, old_ptr->next_ptr);
    list_node_init(old_ptr);
}
 
 
static inline void internal_list_node_add_between(struct list_node *node_ptr, struct list_node *before_ptr,
                                                  struct list_node *after_ptr)
{
    assert(node_ptr != NULL);
    assert(before_ptr != NULL);
    assert(after_ptr != NULL);
 
    before_ptr->next_ptr = node_ptr;
    node_ptr->prev_ptr = before_ptr;
 
    after_ptr->prev_ptr = node_ptr;
    node_ptr->next_ptr = after_ptr;
}
 
static inline void internal_list_node_attach(struct list_node *prev_ptr, struct list_node *next_ptr)
{
    assert(prev_ptr != NULL);
    assert(next_ptr != NULL);
 
    prev_ptr->next_ptr = next_ptr;
    next_ptr->prev_ptr = prev_ptr;
}
 
 
// vim: ft=c