Luna/luna/include/luna/LinkedList.h

#pragma once
#include <luna/Option.h>

template <typename T> inline Option<T*> nonnull_or_error(T* ptr)
{
    if (ptr == nullptr) return {};
    else
        return ptr;
}

template <typename T> class DoublyLinkedList;

template <typename T> class DoublyLinkedListNode
{
    using SelfType = DoublyLinkedListNode<T>;

  private:
    SelfType* m_next_node;
    SelfType* m_last_node;

    void set_next(SelfType* next)
    {
        m_next_node = next;
    }

    void set_last(SelfType* last)
    {
        m_last_node = last;
    }

    SelfType* get_next()
    {
        return m_next_node;
    }

    SelfType* get_last()
    {
        return m_last_node;
    }

    void detach_from_list()
    {
        m_next_node->m_last_node = m_last_node;
        m_last_node->m_next_node = m_next_node;
    }

    void add_to_list(SelfType* end_node)
    {
        end_node->m_next_node = this;
        this->m_last_node = end_node;
    }

    friend class DoublyLinkedList<T>;
};

template <typename T> class DoublyLinkedList
{
    using Node = DoublyLinkedListNode<T>;

  public:
    void append(T* ptr)
    {
        Node* const node = extract_node(ptr);
        if (!m_start_node) m_start_node = node;
        if (m_end_node) node->add_to_list(m_end_node);
        else
        {
            node->set_next(nullptr);
            node->set_last(nullptr);
        }
        m_end_node = node;

        m_count++;
    }

    void append_after(T* base, T* ptr)
    {
        Node* const new_node = extract_node(ptr);
        Node* const base_node = extract_node(base);

        if (m_end_node == base_node) m_end_node = new_node;

        new_node->set_next(base_node->get_next());
        base_node->set_next(new_node);
        new_node->set_last(base_node);

        m_count++;
    }

    T* remove(T* ptr)
    {
        Node* const node = extract_node(ptr);

        if (node == m_end_node) m_end_node = node->get_last();
        if (node == m_start_node) m_start_node = node->get_next();

        node->detach_from_list();

        m_count--;

        return ptr;
    }

    Option<T*> first()
    {
        return nonnull_or_error((T*)m_start_node);
    }

    T* expect_first()
    {
        return first().value();
    }

    Option<T*> last()
    {
        return nonnull_or_error((T*)m_end_node);
    }

    T* expect_last()
    {
        return last().value();
    }

    Option<T*> next(T* item)
    {
        return nonnull_or_error((T*)extract_node(item)->get_next());
    }

    Option<T*> previous(T* item)
    {
        return nonnull_or_error((T*)extract_node(item)->get_last());
    }

    template <typename Callback> void for_each(Callback callback)
    {
        for (Node* node = m_start_node; node; node = node->get_next()) { callback((T*)node); }
    }

    template <typename Callback> void for_each_reversed(Callback callback)
    {
        for (Node* node = m_end_node; node; node = node->get_last()) { callback((T*)node); }
    }

    template <typename Callback> void for_each_after(T* start, Callback callback)
    {
        for (Node* node = extract_node(start)->m_next_node; node; node = node->get_next()) { callback((T*)node); }
    }

    template <typename Callback> void for_each_before(T* end, Callback callback)
    {
        for (Node* node = extract_node(end)->m_last_node; node; node = node->get_last()) { callback((T*)node); }
    }

    usize count()
    {
        return m_count;
    }

  private:
    Node* m_start_node = nullptr;
    Node* m_end_node = nullptr;

    Node* extract_node(T* item)
    {
        return (Node*)item;
    }

    usize m_count = 0;
};