CodeRepository/Common/GCycleQueue.cpp

#include "GCycleQueue.h"

GCycleQueue::GCycleQueue()
		: m_nFrameSize(0)
        , m_nQueueSize(0)
{
    m_ptrFrameQueue = nullptr;

	m_nFront = 0;
    m_nTail = 0;
}

GCycleQueue::~GCycleQueue()
{
	DestroyQueue();
}

/*
 *初始化队列
 */
bool	GCycleQueue::InitQueue(int nFrameSize, int nQueueSize)
{
	DestroyQueue();

    QMutexLocker lock(&m_mutex);

    if(nFrameSize <= 0)
    {
        return false;
    }

    m_nQueueSize = (nQueueSize > 0) ? (nQueueSize) : (DEFAULT_QUEUE_SIZE);		//循环队列，有一个数据块为空，用于存储队列指针
    const_cast<int&>(m_nFrameSize) = nFrameSize;

    m_ptrFrameQueue = new unsigned char[m_nQueueSize * m_nFrameSize + 4096];
	
    if(nullptr == m_ptrFrameQueue)
	{
		return false;
	}

    memset(m_ptrFrameQueue, 0, m_nFrameSize * m_nQueueSize);

	return true;
}

/*
 *数据插入队列尾部
 */
bool	GCycleQueue::PushBack(unsigned char* pFrameData, int nFrameSize,int& nRes)
{
    if (m_nFrameSize < nFrameSize)
	{
		return false;
    }

    if(nullptr == pFrameData)
    {
        return false;
    }

    QMutexLocker lock(&m_mutex);

    nRes = 0;

	//如果队尾与队首相同，说明队列已满，队首指针后移一位
	if ((m_nTail + 1) % m_nQueueSize == m_nFront)
	{
		m_nFront++;
		m_nFront %= m_nQueueSize;
        nRes = 1;
	}

	//数据入队
    memcpy(m_ptrFrameQueue + m_nTail * m_nFrameSize, pFrameData, nFrameSize);

	m_nTail++;
	m_nTail %= m_nQueueSize;

	return true;
}

/*
 *从队列头部获取数据
 */
bool	GCycleQueue::GetFront(unsigned char* pFrameData, int& nFrameSize)
{
    if (IsEmpty())
	{
		return false;
    }

    QMutexLocker lock(&m_mutex);

	nFrameSize = m_nFrameSize;

    memcpy(pFrameData, m_ptrFrameQueue + m_nFront * m_nFrameSize, nFrameSize);
//    memcpy(pFrameData, m_ptrFrameQueue[m_nFront], nFrameSize);

	m_nFront++;
	m_nFront %= m_nQueueSize;

	return true;
}

/*
 *从队列尾部获取数据，并初始队列指针
 */
bool	GCycleQueue::GetBack(unsigned char* pFrameData, int& nFrameSize)
{
    if (IsEmpty())
    {
        return false;
    }

    QMutexLocker lock(&m_mutex);

    nFrameSize = m_nFrameSize;
    int iTemp = m_nTail - 1;
    iTemp = iTemp < 0?m_nQueueSize - 1:iTemp;

    memcpy(pFrameData, m_ptrFrameQueue + iTemp * m_nFrameSize, nFrameSize);

    m_nFront = 0;
    m_nTail = 0;

    return true;
}

/*
 *判断队列是否为空
 */
bool	GCycleQueue::IsEmpty()
{
    return (0 == Size() );
}

/*
 *清空队列
 */
void	GCycleQueue::Clear()
{
    QMutexLocker lock(&m_mutex);

	m_nFront = 0;
	m_nTail = 0;
}

/*
 *获取队列大小(有效数据个数)
 */
int		GCycleQueue::Size()
{
	int nSize = 0;

     QMutexLocker lock(&m_mutex);

	if (m_nTail > m_nFront)
	{
		nSize = m_nTail - m_nFront;
	}
	else if (m_nTail < m_nFront)
	{
		nSize = m_nQueueSize + m_nTail - m_nFront;
	}
	else
	{
		nSize = 0;
	}

	return nSize;
}

/*
 *销毁队列
 */
void	GCycleQueue::DestroyQueue()
{
    QMutexLocker lock(&m_mutex);

    if (nullptr != m_ptrFrameQueue)
	{
		delete [] m_ptrFrameQueue;
        m_ptrFrameQueue = nullptr;
	}

	m_nFront = 0;
	m_nTail = 0;
}