Queue.h

Go to the documentation of this file.

// Queue.h

// Implements the cQueue class representing a thread safe queue

#pragma once

/*
Items can be added multiple times to a queue, there are two functions for
adding, EnqueueItem() and EnqueueItemIfNotPresent(). The first one always
enqueues the specified item, the second one checks if the item is already
present and only queues it if it isn't.

Usage:
To create a queue of type T, instantiate a cQueue<T> object. You can also
modify the behavior of the queue when deleting items and when adding items
that are already in the queue by providing a second parameter, a class that
implements the functions Delete() and Combine(). An example is given in
cQueueFuncs and is used as the default behavior. */

template <class T>
struct cQueueFuncs
{
public:

    static void Delete(T) {}

    static void Combine(T & a_existing, const T & a_new)
    {
        UNUSED(a_existing);
        UNUSED(a_new);
    }
};





template <class ItemType, class Funcs = cQueueFuncs<ItemType> >
class cQueue
{
    // The actual storage type for the queue
    typedef typename std::list<ItemType> QueueType;

    // Make iterator an alias for the QueueType's iterator
    typedef typename QueueType::iterator iterator;

public:
    cQueue() {}
    ~cQueue() {}


    void EnqueueItem(ItemType a_Item)
    {
        cCSLock Lock(m_CS);
        m_Contents.push_back(a_Item);
        m_evtAdded.Set();
    }


    void EnqueueItemIfNotPresent(ItemType a_Item)
    {
        cCSLock Lock(m_CS);

        for (iterator itr = m_Contents.begin(); itr != m_Contents.end(); ++itr)
        {
            if ((*itr) == a_Item)
            {
                Funcs::Combine(*itr, a_Item);
                return;
            }
        }
        m_Contents.push_back(a_Item);
        m_evtAdded.Set();
    }


    bool TryDequeueItem(ItemType & item)
    {
        cCSLock Lock(m_CS);
        if (m_Contents.empty())
        {
            return false;
        }
        item = m_Contents.front();
        m_Contents.pop_front();
        m_evtRemoved.Set();
        return true;
    }


    ItemType DequeueItem(void)
    {
        cCSLock Lock(m_CS);
        while (m_Contents.empty())
        {
            cCSUnlock Unlock(Lock);
            m_evtAdded.Wait();
        }
        ItemType item = m_Contents.front();
        m_Contents.pop_front();
        m_evtRemoved.Set();
        return item;
    }


    void BlockTillEmpty(void)
    {
        cCSLock Lock(m_CS);
        while (!m_Contents.empty())
        {
            cCSUnlock Unlock(Lock);
            m_evtRemoved.Wait();
        }
    }


    void Clear(void)
    {
        cCSLock Lock(m_CS);
        while (!m_Contents.empty())
        {
            Funcs::Delete(m_Contents.front());
            m_Contents.pop_front();
        }
    }


    size_t Size(void)
    {
        cCSLock Lock(m_CS);
        return m_Contents.size();
    }


    bool Remove(ItemType a_Item)
    {
        cCSLock Lock(m_CS);
        for (iterator itr = m_Contents.begin(); itr != m_Contents.end(); ++itr)
        {
            if ((*itr) == a_Item)
            {
                m_Contents.erase(itr);
                m_evtRemoved.Set();
                return true;
            }
        }
        return false;
    }


    template <class Predicate>
    void RemoveIf(Predicate a_Predicate)
    {
        cCSLock Lock(m_CS);
        for (auto itr = m_Contents.begin(); itr != m_Contents.end();)
        {
            if (a_Predicate(*itr))
            {
                auto itr2 = itr;
                ++itr2;
                m_Contents.erase(itr);
                m_evtRemoved.Set();
                itr = itr2;
            }
            else
            {
                ++itr;
            }
        }  // for itr - m_Contents[]
    }

private:
    QueueType m_Contents;

    cCriticalSection m_CS;

    cEvent m_evtAdded;

    cEvent m_evtRemoved;
};