bytequeue.cpp

EVC下的串口测试工具

#include "StdAfx.h"
#include "ByteQueue.h"

CByteQueue::CByteQueue(int cnt)
{
	if(cnt > 1)
	{
		m_count = cnt;
		m_data = new BYTE[m_count];
	}
	else
	{
		m_count = 0;
		m_data = NULL;
	}
	m_head = 0;
	m_tale = 0;

	hNotEmpty = CreateEvent(NULL, TRUE, FALSE, NULL);
	hNotFull = CreateEvent(NULL, TRUE, TRUE, NULL);
	if( hNotEmpty == INVALID_HANDLE_VALUE ||
		hNotFull == INVALID_HANDLE_VALUE )
		AfxMessageBox(TEXT("ERROR : Create Queue Event Handle Fail.\r\n"));
}

CByteQueue::~CByteQueue(void)
{
	if(m_data != NULL)
		delete[] m_data;
	CloseHandle(hNotEmpty);
	CloseHandle(hNotFull);
}

int CByteQueue::GetCount(void)
{
	return m_count;
}

BOOL CByteQueue::PushByte(BYTE data)
{
	if(IsFull())
		return FALSE;

	m_head = (m_head+1)%m_count;
	m_data[m_head] = data;
	m_count++;
	SetEvent(hNotEmpty);
	if(IsFull())
		ResetEvent(hNotFull);
	return TRUE;
}

BOOL CByteQueue::PopByte(BYTE *data)
{
	if(IsEmpty())
		return FALSE;
	
	*data = m_data[m_tale];
	m_tale = (m_tale+1)%m_count;
	m_count--;
	SetEvent(hNotFull);
	if(IsEmpty())
		ResetEvent(hNotEmpty);
	return TRUE;
}

BOOL CByteQueue::PopMultyByte(BYTE *data, DWORD size, DWORD *popSize)
{
	int index;

	if( (data == NULL) || (size ==0) )
	{
		if(popSize != NULL)
			*popSize = 0;
		return FALSE;
	}

	for(index = 0; index<size; index++)
		if(this->PopByte(m_data+index) == FALSE)
			break;

	if(popSize != NULL)
		*popSize = index;
	return TRUE;
}

void CByteQueue::Clear()
{
	m_count = 0;
	m_head = 0;
	m_tale = 0;

	ResetEvent(hNotEmpty);
	SetEvent(hNotFull);
}

int CByteQueue::ResetQueue(int cnt)
{
	if(m_data != NULL)
		delete[] m_data;

	if(cnt > 1)
	{
		m_count = cnt;
		m_data = new BYTE[m_count];
	}
	else
	{
		m_count = 0;
		m_data = NULL;
	}
	m_head = 0;
	m_tale = 0;

	return m_count;
}

BOOL CByteQueue::IsEmpty()
{
	if(m_data == NULL)
		return FALSE;

	return (m_head == m_tale);
}

BOOL CByteQueue::IsFull()
{
	if(m_data == NULL)
		return TRUE;

	return ( ((m_head+1)%m_count) == m_tale);
}

DWORD CByteQueue::WaitForData(DWORD time)
{
	return WaitForSingleObject(hNotEmpty, time);
}

DWORD CByteQueue::WaitForSpace(DWORD time)
{
	return WaitForSingleObject(hNotFull, time);
}