NQResponseWaitQueue.cpp

Go to the documentation of this file.

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


//
// CNQResponseWaitQueue constructor
//
//  initialization and memory allocation 
//
CNQResponseWaitQueue::CNQResponseWaitQueue() : CNQLockMechanism() 
{
    INT32 maxsize = NQ_RESPONSEWAITQUEUE_MAX_SIZE; // # entries 
    m_iQueueMaxSize = maxsize;

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

    m_iLastError = ERR_RWQ_NONE;

    for (int i=0;i<maxsize;i++)
    {
        m_pQueueValue[i].enabled = 0;
        m_iQueueNextElement[i] = -1;
    }

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


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

//
// convenience
//

bool CNQResponseWaitQueue::push_back( const NQ_WAITFORRESPONSE &obj)
{
    UINT32 drop_lasterr;

    return push_back(obj, drop_lasterr);
}

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

    return remove_elem(requestid, drop_lasterr);
}

bool CNQResponseWaitQueue::find_elem( UINT16 requestid, NQ_WAITFORRESPONSE &obj)
{
    UINT32 drop_lasterr;

    return find_elem(requestid, obj, drop_lasterr);
}

bool CNQResponseWaitQueue::find_and_remove_elem( UINT16 requestid, NQ_WAITFORRESPONSE &obj)
{
    UINT32 drop_lasterr;

    bool ret = find_and_remove_elem(requestid, obj, drop_lasterr); // SW! Aug 17, 2007
    return ret;
}

//
// convenience END
//

//
// CNQResponseWaitQueue::push_back()
//
bool CNQResponseWaitQueue::push_back ( const NQ_WAITFORRESPONSE& obj, UINT32 &lasterr )
{
    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_RWQ_LOCK;
        return false;
    }
    
    bool retval = false;
            
    // if queue full: dont append anything else
    if (m_iQueueNumElements >= m_iQueueMaxSize) 
    {
        assert( m_iQueueNumElements == m_iQueueMaxSize );
        m_iLastError = lasterr = ERR_RWQ_FULL;
    }
    else
    {
        INT32 free_index = -1;

        for (INT32 cur=0;cur<m_iQueueMaxSize;cur++)
        {
            if (m_pQueueValue[cur].enabled == 0) 
            {
                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].enabled == 0 );
            m_pQueueValue[free_index].enabled = 1;
            m_pQueueValue[free_index].wfr = obj;

            m_iQueueNextElement[free_index] = -1;
            m_iQueueNumElements++;
        }
        else
        {
            m_iQueueNextElement[m_iQueueLastElement] = free_index;
            assert( m_pQueueValue[free_index].enabled == 0 );
            m_pQueueValue[free_index].enabled = 1;
            m_pQueueValue[free_index].wfr = obj;
            
            m_iQueueNextElement[free_index] = -1;
            m_iQueueLastElement = free_index;
            m_iQueueNumElements++;
        }
            
        m_iLastError = lasterr = ERR_RWQ_NONE;
        retval = true;
    }
            
    unlock();

    return retval;
}

//
// CNQResponseWaitQueue::remove_elem()
//
bool CNQResponseWaitQueue::remove_elem( UINT16 requestid, UINT32 &lasterr  )
{
    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_RWQ_LOCK;
        return false;
    }

    
    INT32 found_index = m_iQueueFirstElement;
    INT32 last_index = -1;
    bool del = false;
    bool retval = false;

    while( found_index != -1)
    {
        assert( m_pQueueValue[found_index].enabled != 0);

        if (m_pQueueValue[found_index].wfr.requestid == requestid) 
        {
            if (last_index == -1)
            {
                INT32 removeidx = m_iQueueFirstElement;

                m_pQueueValue[removeidx].enabled = 0;
                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].enabled = 0;
                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_RWQ_NONE;
    }
    else m_iLastError = lasterr = ERR_RWQ_NOTFOUND;


    unlock();

    return retval;
}


//
// CNQResponseWaitQueue::find_elem()
//
bool CNQResponseWaitQueue::find_elem( UINT16 requestid, NQ_WAITFORRESPONSE& obj, UINT32 &lasterr  )
{
    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_RWQ_LOCK;
        return false;
    }

    INT32 it = m_iQueueFirstElement;
    bool retval = false;

    m_iLastError = lasterr = ERR_RWQ_NOTFOUND;

    if (m_iQueueNumElements > 0) 
    {
        while( it != -1)
        {
            assert( m_pQueueValue[it].enabled != 0);
            if (m_pQueueValue[it].wfr.requestid == requestid) 
            {
                obj = m_pQueueValue[it].wfr;
                retval = true;
                m_iLastError = lasterr = ERR_RWQ_NONE;
                break;
            }
        
            it = m_iQueueNextElement[it];
        }
    }
    
    unlock();

    return retval;
}

//
// CNQResponseWaitQueue::find_and_remove_elem()
//
bool CNQResponseWaitQueue::find_and_remove_elem( UINT16 requestid, NQ_WAITFORRESPONSE& obj, UINT32 &lasterr )
{
    if (!lock()) 
    {
        m_iLastError = lasterr = ERR_RWQ_LOCK;
        return false;
    }
    
    INT32 found_index = m_iQueueFirstElement;
    INT32 last_index = -1;
    bool del = false;
    bool retval = false;

    while( found_index != -1)
    {
        assert( m_pQueueValue[found_index].enabled != 0);

        if (m_pQueueValue[found_index].wfr.requestid == requestid) 
        {
            if (last_index == -1)
            {
                INT32 removeidx = m_iQueueFirstElement;
                
                m_pQueueValue[removeidx].enabled = 0;
                obj = m_pQueueValue[removeidx].wfr;
                
                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].enabled = 0;
                obj = m_pQueueValue[removeidx].wfr;
                
                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;

    if (del == true)
    {
        retval = true;
        m_iLastError = lasterr = ERR_RWQ_NONE;
    }
    else m_iLastError = lasterr = ERR_RWQ_NOTFOUND;

    
    unlock();

    return retval;
}

UINT32 CNQResponseWaitQueue::size()
{
    return( m_iQueueNumElements );
}

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

---