NQPacketQueue.cpp

Go to the documentation of this file.

#define __NQ_INTERNAL_SW__

#include "PlatformSW.h"
#include "NQDeclarations.h"
#include "NQPacketQueue.h"
#include <assert.h>


//
// CNQPacketQueue constructor
//
//  initialization and memory allocation 
//
CNQPacketQueue::CNQPacketQueue() : CNQLockMechanism() 
{
    INT32 maxsize = NQ_DEFAULT_PACKETQUEUE_SIZE;
    m_iQueueMaxSize = maxsize;
    m_iLastError = ERR_PQ_NONE;

    m_pQueueValue = new VOIDP[maxsize];
    m_iQueueNextElement = new INT32[maxsize];

    for (INT32 i=0;i<maxsize;i++)
    {
        m_pQueueValue[i] = NULL;
        m_iQueueNextElement[i] = -1;
    }

    m_iQueueFirstElement = -1;
    m_iQueueLastElement = -1;
    m_iQueueNumElements = 0;
}

//
// CNQPacketQueue destructor
//
//  mandatory deinitialization (free up memory)
//
CNQPacketQueue::~CNQPacketQueue() 
{
    delete [] m_pQueueValue;
    delete [] m_iQueueNextElement;
}

//
// Convenience functions
//

bool CNQPacketQueue::setQueueMaxsize( INT32 maxsize )
{
    UINT32 drop_lasterr;

    return setQueueMaxsize(maxsize, drop_lasterr);
}

bool CNQPacketQueue::pop_front( CNQMessage **obj )
{
    UINT32 drop_lasterr;

    return pop_front(obj, drop_lasterr);
}

bool CNQPacketQueue::push_back( const CNQMessage* obj)
{
    UINT32 drop_lasterr;

    return push_back(obj, drop_lasterr);
}

bool CNQPacketQueue::remove_elem( UINT16 requestid)
{
    UINT32 drop_lasterr;

    return remove_elem(requestid, drop_lasterr);
}

bool CNQPacketQueue::find_elem( UINT16 requestid, CNQMessage ** obj)
{
    UINT32 drop_lasterr;

    return find_elem(requestid, obj, drop_lasterr);
}

bool CNQPacketQueue::find_and_remove_elem( UINT16 requestid, CNQMessage **obj)
{
    UINT32 drop_lasterr;

    return find_and_remove_elem(requestid, obj, drop_lasterr);
}

bool CNQPacketQueue::find_elem_ack_and_signal( const CNQMessage &aAckPacket)
{
    UINT32 drop_lasterr;

    return find_elem_ack_and_signal( aAckPacket, drop_lasterr);
}

bool CNQPacketQueue::find_and_remove_passed_elem( CNQMessage *obj)
{
    UINT32 drop_lasterr;

    return find_and_remove_passed_elem( obj, drop_lasterr);
}

//
// Convenience functions END

//
// CNQPacketQueue::setQueueMaxsize()
bool CNQPacketQueue::setQueueMaxsize( INT32 maxsize, UINT32 &lasterr )
{
    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }

    delete [] m_pQueueValue;
    delete [] m_iQueueNextElement;

    m_iQueueMaxSize = maxsize;
    m_pQueueValue = new VOIDP[maxsize];
    m_iQueueNextElement = new INT32[maxsize];

    for (INT32 i=0;i<maxsize;i++)
    {
        m_pQueueValue[i] = NULL;
        m_iQueueNextElement[i] = -1;
    }

    m_iQueueFirstElement = -1;
    m_iQueueLastElement = -1;
    m_iQueueNumElements = 0;

    unlock();

    m_iLastError = lasterr = ERR_PQ_NONE;
    return true;
}


//
// CNQPacketQueue::pop_front()
//
bool CNQPacketQueue::pop_front( CNQMessage **obj, UINT32 &lasterr )
{
    bool retval = false;

    if (obj == NULL) 
    {
        m_iLastError = lasterr = ERR_PQ_BADPARAM;
        return false;
    }

    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }

    if (m_iQueueNumElements != 0)
    {
        INT32 removeidx = m_iQueueFirstElement;

        *obj = (CNQMessage *) m_pQueueValue[removeidx];
        
        m_pQueueValue[removeidx] = NULL;
        m_iQueueFirstElement = m_iQueueNextElement[removeidx];
        m_iQueueNumElements--;

        if (m_iQueueNumElements == 0)
        {
            assert( m_iQueueFirstElement == -1 );
            m_iQueueLastElement = -1;
        }

        retval = true;
    }
            
    unlock();

    m_iLastError = lasterr = ERR_PQ_NONE;
    return retval;
}

//
// CNQPacketQueue::push_back()
//
bool CNQPacketQueue::push_back ( const CNQMessage *obj, UINT32 &lasterr )
{
    bool retval = false;

    if (obj == NULL) 
    {
        m_iLastError = lasterr = ERR_PQ_BADPARAM;
        return false;
    }

    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }
    
    // if queue full: dont append anything else
    if (m_iQueueNumElements >= m_iQueueMaxSize) 
    {
        assert( m_iQueueNumElements == m_iQueueMaxSize );
        m_iLastError = lasterr = ERR_PQ_FULL;
    }
    else
    {
        INT32 free_index = -1;

        for (INT32 cur=0;cur<m_iQueueMaxSize;cur++)
        {
            if (m_pQueueValue[cur] == NULL) 
            {
                free_index = cur;
                break;
            }
        }

        assert( free_index != -1 );
        
        if (m_iQueueLastElement == -1)
        {
            // queue is empty
            m_iQueueFirstElement = free_index;
            m_iQueueLastElement = free_index;
            assert( m_pQueueValue[free_index] == NULL );
            m_pQueueValue[free_index] = (VOIDP) obj;
            m_iQueueNextElement[free_index] = -1;
            m_iQueueNumElements++;
        }
        else
        {
            m_iQueueNextElement[m_iQueueLastElement] = free_index;
            assert( m_pQueueValue[free_index] == NULL );
            m_pQueueValue[free_index] = (VOIDP) obj;
            m_iQueueNextElement[free_index] = -1;
            m_iQueueLastElement = free_index;
            m_iQueueNumElements++;
        }
            
        m_iLastError = lasterr = ERR_PQ_NONE;
        retval = true;
    }
            
    unlock();

    return retval;
}

//
// CNQPacketQueue::remove_elem()
//
bool CNQPacketQueue::remove_elem( UINT16 requestid, UINT32 &lasterr )
{
    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }
    
    INT32 found_index = m_iQueueFirstElement;
    INT32 last_index = -1;
    bool del = false;
    bool retval = false;

    while( found_index != -1)
    {
        CNQMessage *obj = (CNQMessage *) m_pQueueValue[found_index];
        
        if (obj->internalRequestID == requestid) 
        {
            if (last_index == -1)
            {
                INT32 removeidx = m_iQueueFirstElement;

                m_pQueueValue[removeidx] = NULL;
                m_iQueueFirstElement = m_iQueueNextElement[removeidx];
                m_iQueueNumElements--;

                if (m_iQueueNumElements == 0)
                {
                    assert( m_iQueueFirstElement == -1 );
                    m_iQueueLastElement = -1;
                }

                del = true;
            }
            else
            {
                INT32 removeidx = found_index;

                m_pQueueValue[removeidx] = NULL;
                m_iQueueNextElement[last_index] = m_iQueueNextElement[removeidx];
                m_iQueueNumElements--;

                if (m_iQueueNextElement[last_index] == -1)
                {
                    m_iQueueLastElement = last_index;
                }

                del = true;

            }
        }
        
        if (del == true) break;

        last_index = found_index;
        found_index = m_iQueueNextElement[found_index];
    }

    if (del == true)
    {
        retval = true;
        m_iLastError = lasterr = ERR_PQ_NONE;
    }
    else m_iLastError = lasterr = ERR_PQ_NOTFOUND;
        
    unlock();
    
    return retval;
}


// traverse elements, find and return element

//
// There is no buffer reference counting when returning element - this can lead to BAD situations.
// I have decided to leave that this way as this method is not used at the moment. SW! Aug 28, 2007
//


//
// CNQPacketQueue::find_elem()
//
bool CNQPacketQueue::find_elem( UINT16 requestid, CNQMessage **obj, UINT32 &lasterr )
{
    if (obj == NULL) 
    {
        m_iLastError = lasterr = ERR_PQ_BADPARAM;
        return false;
    }

    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }
    
    INT32 it = m_iQueueFirstElement;
    bool retval = false;

    m_iLastError = lasterr = ERR_PQ_NOTFOUND;

    if (m_iQueueNumElements > 0)
    {
        while( it != -1)
        {
            CNQMessage *intobj = (CNQMessage *) m_pQueueValue[it];
            if (intobj->internalRequestID == requestid) 
            {
                *obj = intobj;
                retval = true;
                m_iLastError = lasterr = ERR_PQ_NONE;
                break;
            }
        
            it = m_iQueueNextElement[it];
        }
    }

    unlock();

    return retval;
}

//
// CNQPacketQueue::find_elem_ack_and_signal() 
//
bool CNQPacketQueue::find_elem_ack_and_signal( const CNQMessage &ack_packet, UINT32 &lasterr )
{
    if (ack_packet.isAckPacket() == false)
    {
        m_iLastError = lasterr = ERR_PQ_BADPARAM;
        return false;
    }

    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }
    
    INT32 it = m_iQueueFirstElement;
    bool retval = false;

    m_iLastError = lasterr = ERR_PQ_NOTFOUND;

    if (m_iQueueNumElements > 0)
    {
        while( it != -1)
        {
            CNQMessage *intobj = (CNQMessage *) m_pQueueValue[it];
            if (intobj->matchAckPacket( ack_packet ) == true ) 
            {
                bool signalAckSemaphoreSuccessful = platformSignalSemaphore( intobj->notifySemaphoreOnReceiveAck );
                assert( signalAckSemaphoreSuccessful == true );
                signalAckSemaphoreSuccessful=signalAckSemaphoreSuccessful; // make compiler happy

                retval = true;
                m_iLastError = lasterr = ERR_PQ_NONE;
                break;
            }
        
            it = m_iQueueNextElement[it];
        }
    }

    unlock();

    return retval;
}


//
// CNQPacketQueue::find_and_remove_passed_elem() 
//
bool CNQPacketQueue::find_and_remove_passed_elem( CNQMessage *obj, UINT32 &lasterr )
{
    if (obj == NULL) 
    {
        m_iLastError = lasterr = ERR_PQ_BADPARAM;
        return false;
    }

    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }
    
    INT32 found_index = m_iQueueFirstElement;
    INT32 last_index = -1;
    bool del = false;
    bool retval = false;

    while( found_index != -1)
    {
        CNQMessage *intobj = (CNQMessage *) m_pQueueValue[found_index];
        
        if (intobj == obj) 
        {
            if (last_index == -1)
            {
                INT32 removeidx = m_iQueueFirstElement;
                
                m_pQueueValue[removeidx] = NULL;
                m_iQueueFirstElement = m_iQueueNextElement[removeidx];
                m_iQueueNumElements--;

                if (m_iQueueNumElements == 0)
                {
                    assert( m_iQueueFirstElement == -1 );
                    m_iQueueLastElement = -1;
                }

                del = true;
            }
            else
            {
                INT32 removeidx = found_index;

                m_pQueueValue[removeidx] = NULL;
                m_iQueueNextElement[last_index] = m_iQueueNextElement[removeidx];
                m_iQueueNumElements--;

                if (m_iQueueNextElement[last_index] == -1)
                {
                    m_iQueueLastElement = last_index;
                }

                del = true;

            }
        }
        
        if (del == true) break;

        last_index = found_index;
        found_index = m_iQueueNextElement[found_index];
    }

    if (del == true)
    {
        retval = true;
        m_iLastError = lasterr = ERR_PQ_NONE;
    }
    else m_iLastError = lasterr = ERR_PQ_NOTFOUND;
        
    unlock();
    
    return retval;

}

//
// CNQPacketQueue::find_and_remove_elem()
//
bool CNQPacketQueue::find_and_remove_elem( UINT16 requestid, CNQMessage **obj, UINT32 &lasterr )
{
    if (obj == NULL) 
    {
        m_iLastError = lasterr = ERR_PQ_BADPARAM;
        return false;
    }

    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_PQ_LOCK;
        return false;
    }
    
    INT32 found_index = m_iQueueFirstElement;
    INT32 last_index = -1;
    bool del = false;
    bool retval = false;

    while( found_index != -1)
    {
        CNQMessage *intobj = (CNQMessage *) m_pQueueValue[found_index];
        
        if (intobj->internalRequestID == requestid) 
        {
            if (last_index == -1)
            {
                INT32 removeidx = m_iQueueFirstElement;
                *obj = intobj;
                m_pQueueValue[removeidx] = NULL;
                m_iQueueFirstElement = m_iQueueNextElement[removeidx];
                m_iQueueNumElements--;

                if (m_iQueueNumElements == 0)
                {
                    assert( m_iQueueFirstElement == -1 );
                    m_iQueueLastElement = -1;
                }

                del = true;
            }
            else
            {
                INT32 removeidx = found_index;

                *obj = intobj;
                m_pQueueValue[removeidx] = NULL;
                m_iQueueNextElement[last_index] = m_iQueueNextElement[removeidx];
                m_iQueueNumElements--;

                if (m_iQueueNextElement[last_index] == -1)
                {
                    m_iQueueLastElement = last_index;
                }

                del = true;

            }
        }
        
        if (del == true) break;

        last_index = found_index;
        found_index = m_iQueueNextElement[found_index];
    }

    if (del == true)
    {
        retval = true;
        m_iLastError = lasterr = ERR_PQ_NONE;
    }
    else m_iLastError = lasterr = ERR_PQ_NOTFOUND;
        
    unlock();
    
    return retval;

}


//
// CNQPacketQueue::size()
//
int CNQPacketQueue::size()
{
    return (m_iQueueNumElements);
}

UINT32 CNQPacketQueue::getLastError()
{
    // be very careful: concurrent threads
    return( m_iLastError );
}

---