RtosList.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------
#include "RtosList.hpp"
#include "RtosListIterable.hpp"
#include "RtosInclude.hpp"

RtosList::RtosList() {
    mFirst = 0;
    mLast = 0;
}

void RtosList::insertAtBeginning(RtosListIterable& iterable) {
    iterable.mNext = mFirst;
    if (mFirst) {
        mFirst->mPrev = &iterable;
    }
    else {
        mLast = &iterable;
    }
    iterable.mPrev = 0;
    iterable.mListOwner = this;
    mFirst = &iterable;
}

void RtosList::insertAtEnd(RtosListIterable& iterable) {
    iterable.mPrev = mLast;
    if (mLast) {
        mLast->mNext = &iterable;
    }
    else {
        mFirst = &iterable;
    }
    iterable.mNext = 0;
    iterable.mListOwner = this;
    mLast = &iterable;
}

void RtosList::insertSorted(RtosListIterable& iterable) {
    RtosListIterable *next = mFirst;

    //Iterate through the list until the right position
    for (uint32_t sortValue = iterable.mSortValue; next && (next->mSortValue <= sortValue); next = next->mNext) {
    }

    if (!next) { //End of the list or empty list
        insertAtEnd(iterable);
    }
    else { //Insert the item
        iterable.mPrev = next->mPrev;
        iterable.mNext = next;
        next->mPrev = &iterable;

        if (!iterable.mPrev) { //First item in the list
            mFirst = &iterable;
        }
        else {
            iterable.mPrev->mNext = &iterable;
        }
    }
    iterable.mListOwner = this;
}

void RtosList::insertSorted(RtosListIterable& iterable, uint32_t current) {
    RtosListIterable *next = mFirst;

    //Is value overflow?
    if (iterable.mSortValue < current) {
        //Iterate through the list until the right position
        for (uint32_t sortValue = iterable.mSortValue; next && ((next->mSortValue <= sortValue) || (next->mSortValue >= current)); next = next->mNext) {
        }
    }
    else {
        //Iterate through the list until the right position
        for (uint32_t sortValue = iterable.mSortValue; next && (next->mSortValue <= sortValue) && (next->mSortValue >= current); next = next->mNext) {
        }
    }

    if (!next) { //End of the list or empty list
        insertAtEnd(iterable);
    }
    else { //Insert the item
        iterable.mPrev = next->mPrev;
        iterable.mNext = next;
        next->mPrev = &iterable;

        if (!iterable.mPrev) { //First item in the list
            mFirst = &iterable;
        }
        else {
            iterable.mPrev->mNext = &iterable;
        }
    }
    iterable.mListOwner = this;
}

void RtosList::remove(RtosListIterable& iterable) {
    RtosListIterable* prev = iterable.mPrev;
    RtosListIterable* next = iterable.mNext;

    if (!prev) { //first item in the list
        if (!next) { //only item in the list
            mFirst = 0;
            mLast = 0;
        }
        else {
            mFirst = next;
            next->mPrev = 0;
        }
    }
    else if (!next) { //last item in the list
        mLast = prev;
        prev->mNext = 0;
    }
    else { //in the middle of the list
        prev->mNext = next;
        next->mPrev = prev;
    }

    iterable.mPrev = 0;
    iterable.mNext = 0;
    iterable.mListOwner = 0;
}

bool RtosList::isInside(RtosListIterable& iterable) {
    RtosListIterable* iterator;
    for (iterator = mFirst; iterator; iterator = iterator->mNext) {
        if (iterator == &iterable) {
            return true;
        }
    }
    return false;
}

RtosListIterable* RtosList::getFirst() {
    if (!mFirst) {
        return 0;
    } //

    RtosListIterable* iterable = mFirst;

    if (!iterable->mNext) { //Last item in the list
        mFirst = 0;
        mLast = 0;
    }
    else {
        mFirst = iterable->mNext;
        mFirst->mPrev = 0;
    }

    iterable->mPrev = 0;
    iterable->mNext = 0;
    iterable->mListOwner = 0;

    return iterable;
}