# ilist

The ilist is a template library modeled after the STL list. Instead of allocating a container for the elements, it uses base classes for the elements. This way much less alloc an free operations are needed, which saves a lot of cpu time and memory. Also when iterating thru the list one indirection less is needed. It uses the istd namespace.

## File information

File | common/ilib/ilist.h
Classes | list listElement
class list members | list ~list front empty back push_front push_back pop_front pop_back insertBefore insertBehind swap sort
class listElement members | listElement ~listElement goNext goPrev remove getList compare swap
Examples |

# Classes

## list

    template <class T> class list {
        ...
    };

The list itself consisting of a head and tail pointer to a class T.

## listElement

    template <class T> class listElement {
        ...
    };

Used as a base class for elements. This contains the forward and backward linking pointer and a pointer to the list itself.

# class list members

## list

    list()

constructor, clears the list

## ~list

    ~list()

destructor, removes all elements from the list

## front

    const T * front()

returns front (head) of list.

## empty

    bool empty()

## back

    const T * back()

returns back (tail) of list.

## push_front

    void push_front(T * e)

Add an element to the front (head) of the list.

## push_back

    void push_back(T * e)

Add an element to the back (tail) of the list.

## pop_front

    T * pop_front()

Remove an element from the front (head) of the list.

## pop_back

    T * pop_back()

Remove an element from the back (tail) of the list.

## insertBefore

    void insertBefore(T * e, T * before)

Insert the element e before the element identified by 'before' in the list.

## insertBehind

    void insertBehind(T * e, T * behind)

Insert the element e behind the element identified by 'behind' in the list.

## swap

    void swap(T * a, T * b)

Swaps the values of the two given listElement objects. The swap function of listElement must be overwritten, also the pointers a and b passed to swap must point to a valid object.

## sort

    void sort(T * start = NULL, T * end = NULL)

Sorts the list by using quicksort. The sort will be done between start and end. If start is NULL, the start of the list will be used, and if end is NULL, the end of the list. So by calling sort() withouth parameters, the sorting will be done for the whole list. During sorting, the function will call listElement::compare() and listElement::swap(). So both of them must be implemented to not end up with an assertion.

# class listElement members

## listElement

    listElement()

## ~listElement

    virtual ~listElement()

The destructor of a list element removes the element from the list.

## goNext

    const T * goNext()

Returns the next element in the list.

## goPrev

    const T * goPrev()

Returns the previous element in the list.

## remove

    void remove()

Removes the element from the list.

## getList

    const list * getList()

Returns the list, in which this element is linked.

## compare

    virtual int compare(T * e)

Will be called from list::sort() to know how to handle the item and the one passed to compare. The function need to return a value less than 0, if this is < e, zero if this is equal to e or a value greater than 0 if this is > e. If you don't whant to call list::sort, there is no need to override this function.

## swap

    virtual void swap(T * with)

Will be called from list::sort() or list::swap() to swap the instance of the listElement object with the one passed. The implementation of the function is responsible to switch all fields of this and with. If you don't whant to call list::sort() or list::swap(), there is no need to override this function.

# Examples

        // use the ilist base class
    class sample : public istd::listElement<sample> {

    }
     ...
        // defining the list
    istd::list<sample> samples;
     ...
        // iterating thru the list
    for(class sample * s = samples.front(); s; s=s->goNext()) {
        ...
    }