template<class T>

Corrade::Containers::LinkedList class

Basic usage

class Object: public LinkedListItem<Object> {
    // ...
};

Object a, b, c;

LinkedList<Object> list;
list.insert(&a);
list.insert(&b);
list.insert(&c);

list.cut(&b);

Traversing through the list can be done using range-based for:

for(Object& o: list) {
    // ...
}

Or, if you need more flexibility, like in the following code. It is also possible to go in reverse order using last() and LinkedListItem::previous().

for(Object* i = list.first(); i; i = i->next()) {
    // ...
}

Making advantage of pointer to the list

Each node stores pointer to the list, which you can take advantage of. For example, if you have group of some objects and want to access the group from each object, you can reuse the LinkedListItem::list() pointer, which will be cast to type you specify as List template parameter of LinkedListItem class:

class ObjectGroup: public LinkedList<Object> {
    // ...
};

class Object: public LinkedListItem<Object, ObjectGroup> {
    public:
        ObjectGroup* group() { return list(); }

    // ...
};

Using private inheritance

You might want to subclass LinkedList and LinkedListItem privately and for example provide wrapper functions with more descriptive names. In that case you need to friend both LinkedList and LinkedListItem in both your subclasses.

class ObjectGroup: private LinkedList<Object> {
    friend LinkedList<Object>;
    friend LinkedListItem<Object, ObjectGroup>;

    public:
        Object* firstObject() { return first(); }
        Object* lastObject() { return last(); }

    // ...
};

class Object: private LinkedListItem<Object, ObjectGroup> {
    friend LinkedList<Object>;
    friend LinkedListItem<Object, ObjectGroup>;

    public:
        ObjectGroup* group() { return list(); }
        Object* previousObject() { return previous(); }
        Object* nextObject() { return next(); }

    // ...
};

Constructors, destructors, conversion operators

LinkedList() explicit constexpr noexcept

Default constructor.

LinkedList(const LinkedList<T>&) deleted

Copying is not allowed.

LinkedList(LinkedList<T>&& other) noexcept

Move constructor.

~LinkedList()

Destructor.

Public functions

auto operator=(const LinkedList<T>&) -> LinkedList<T>& deleted

Copying is not allowed.

auto operator=(LinkedList<T>&& other) -> LinkedList<T>&

Move assignment.

auto first() -> T*

First item or nullptr, if the list is empty.

auto first() const -> const T* constexpr

auto last() -> T*

Last item or nullptr, if the list is empty.

auto last() const -> const T* constexpr

auto isEmpty() const -> bool constexpr

Whether the list is empty.

void insert(T* item, T* before = nullptr)

Insert item.

void cut(T* item)

Cut item out.

void move(T* item, T* before)

Move item before another.

void erase(T* item)

Erase item.

void clear()

Clear the list.

Function documentation

if(item != before) {
    list.cut(item);
    list.move(item, before);
}

list.cut(item);
delete item;