genode/base/include/util/list.h
Norman Feske 21462cdbd2 base: Add const qualifiers to 'util/list.h'
This patch adds support for iterating through a const list. This allows
users of lists to be more rigid with regard to constness. Furthermore,
the patch adds the function 'List::insert_at' for inserting an element
at a specified position. By adding this function, we can remove code
duplication in nitpicker.
2013-09-18 14:58:55 +02:00

137 lines
2.7 KiB
C++

/*
* \brief Single connected list
* \author Norman Feske
* \date 2006-08-02
*/
/*
* Copyright (C) 2006-2013 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
#ifndef _INCLUDE__UTIL__LIST_H_
#define _INCLUDE__UTIL__LIST_H_
namespace Genode {
/*
* \param LT list element type
*/
template <typename LT>
class List
{
private:
LT *_first;
public:
class Element
{
protected:
friend class List;
LT mutable *_next;
public:
Element(): _next(0) { }
/**
* Return next element in list
*/
LT *next() const { return _next; }
};
public:
/**
* Constructor
*
* Start with an empty list.
*/
List() : _first(0) { }
/**
* Return first list element
*/
LT *first() { return _first; }
LT const *first() const { return _first; }
/**
* Insert element after specified element into list
*
* \param le list element to insert
* \param at target position (preceding list element)
*/
void insert(LT const *le, LT const *at = 0)
{
/* insert at beginning of the list */
if (at == 0) {
le->Element::_next = _first;
_first = const_cast<LT *>(le);
} else {
le->Element::_next = at->Element::_next;
at->Element::_next = const_cast<LT *>(le);
}
}
/**
* Remove element from list
*/
void remove(LT const *le)
{
if (!_first) return;
/* if specified element is the first of the list */
if (le == _first) {
_first = le->Element::_next;
} else {
/* search specified element in the list */
Element *e = _first;
while (e->_next && (e->_next != le))
e = e->_next;
/* element is not member of the list */
if (!e->_next) return;
/* e->_next is the element to remove, skip it in list */
e->Element::_next = e->Element::_next->Element::_next;
}
le->Element::_next = 0;
}
};
/**
* Helper for using member variables as list elements
*
* \param T type of compound object to be organized in a list
*
* This helper allow the creation of lists that use member variables to
* connect their elements. This way, the organized type does not need to
* publicly inherit 'List<LT>::Element'. Furthermore objects can easily
* be organized in multiple lists by embedding multiple 'List_element'
* member variables.
*/
template <typename T>
class List_element : public List<List_element<T> >::Element
{
T *_object;
public:
List_element(T *object) : _object(object) { }
T *object() const { return _object; }
};
}
#endif /* _INCLUDE__UTIL__LIST_H_ */