fifoqueue.h

SMS gateway. SMS protocol for CHINA mobile, unicom, lingtong. Using mysql to exchange message.

//////////////////////////////////////////////////////////////
//															//
//		Queue template class,for Unix													//
//															//
//////////////////////////////////////////////////////////////
#ifndef __FIFOQueue_H__
#define __FIFOQueue_H__

#include <semaphore.h>

#define BLOCK_WAITTIME  300

template<class Type>
class FIFOQueue  
{
public:

	bool Get(Type &Item);
	bool Wait_Get(Type &Item);
	bool Put(Type &Item);
	bool Wait_Put(Type &Item);
	int GetLen();
	bool IsFull();
	bool IsEmpty();
	FIFOQueue(int size);
	virtual ~FIFOQueue();
    bool SetMaxSize(int); /*设置队列最大容量*/
    int GetPercent();     /*获取队列当前使用百分比*/
    int GetMaxSize();	  /*获得队列的最大长度*/

private:

	int m_Front;
	int m_Rear;
	int m_MaxSize;
	//HANDLE m_ReadSem,m_WriteSem,m_ReadMut,m_WriteMut;
  	sem_t	m_ReadSem,m_WriteSem,m_ReadMut,m_WriteMut;
	Type ** Elements;
	
};


template<class Type>FIFOQueue<Type>::FIFOQueue(int size)
{
	m_Front=0;
	m_Rear=0;
	m_MaxSize=size;
    Elements = new Type*[size];
	sem_init(&m_ReadMut, 0, 1);
	sem_init(&m_WriteMut, 0, 1);
	sem_init(&m_WriteSem, 0, size);
	sem_init(&m_ReadSem, 0, 0);
}


template<class Type>FIFOQueue<Type>::~FIFOQueue()
{
	delete [] Elements;
	sem_destroy(&m_ReadMut);
	sem_destroy(&m_WriteMut);
	sem_destroy(&m_WriteSem);
	sem_destroy(&m_ReadSem);
}

template<class Type>bool FIFOQueue<Type>::IsEmpty()
{
	if(m_Front == m_Rear)
		return true;
	return false;	
}

template<class Type>bool FIFOQueue<Type>::SetMaxSize(int size)
{
	int m_OldMaxSize = m_MaxSize;
	Type ** oldElements;

	//如果队列小于原来的尺寸，不允许修改
	if(size<=m_MaxSize)
		return false ;
		
	sem_wait(&m_ReadMut);
	sem_wait(&m_WriteMut);
	
	m_MaxSize=size;
	oldElements = Elements ;
    Elements = new Type*[size];
    for(int i = 0;i < m_OldMaxSize ; i++)
    	*(Elements[i]) = *(oldElements[i]);

    for(int j = m_OldMaxSize;j < m_MaxSize ; j++)
    	sem_post(&m_WriteSem);
	delete [] oldElements;
	
	sem_post(&m_WriteMut);
	sem_post(&m_ReadMut);
        
	return true;
}

template<class Type>int FIFOQueue<Type>::GetPercent()
{
	int iPercent;
    iPercent = (m_Rear - m_Front + m_MaxSize) % m_MaxSize;
    iPercent = (iPercent*100)/m_MaxSize;
	return iPercent; 
}

template<class Type>int FIFOQueue<Type>::GetMaxSize()
{
	return m_MaxSize;  	
}


template<class Type>bool FIFOQueue<Type>::IsFull()
{
	if((m_Rear+1) % m_MaxSize == m_Front)
		return true;
	return false;
}

template<class Type>int FIFOQueue<Type>::GetLen()
{
	int iLen;
    iLen = (m_Rear - m_Front + m_MaxSize) % m_MaxSize;
	return iLen;
}

template<class Type>bool FIFOQueue<Type>::Put(Type &Item)
{		
	if(sem_trywait(&m_WriteSem)!=0){
		return false;//time out,queue is full,can't insert element
	}
	sem_wait(&m_WriteMut);

	m_Rear = (m_Rear + 1) % m_MaxSize;
	Elements[m_Rear] = new Type;
	*(Elements[m_Rear]) = Item;

	sem_post(&m_WriteMut);
	sem_post(&m_ReadSem);	/* 1 more stored item */

	return true;
}

template<class Type>bool FIFOQueue<Type>::Wait_Put(Type &Item)
{		
	sem_wait(&m_WriteSem);	//阻塞等待插入单元
	sem_wait(&m_WriteMut);

	m_Rear = (m_Rear + 1) % m_MaxSize;
	Elements[m_Rear] = new Type;
	*(Elements[m_Rear]) = Item;

	sem_post(&m_WriteMut);
	sem_post(&m_ReadSem);	/* 1 more stored item */

	return true;
}

template<class Type>bool FIFOQueue<Type>::Get(Type &Item)
{	
	if(sem_trywait(&m_ReadSem)!=0){
		return false;//time out,queue is empty,can't get element
	}

	sem_wait(&m_ReadMut);
	
	m_Front = (m_Front + 1) % m_MaxSize;
	Item = *(Elements[m_Front]);
	delete Elements[m_Front];

	sem_post(&m_ReadMut);
	sem_post(&m_WriteSem);	/* 1 more empty slot */

	return true;
}

template<class Type>bool FIFOQueue<Type>::Wait_Get(Type &Item)
{	
	sem_wait(&m_ReadSem);  //阻塞等待获得单元
	sem_wait(&m_ReadMut);
	
	m_Front = (m_Front + 1) % m_MaxSize;
	Item = *(Elements[m_Front]);
	delete Elements[m_Front];

	sem_post(&m_ReadMut);
	sem_post(&m_WriteSem);	/* 1 more empty slot */

	return true;
}


#endif // __FIFOQueue_H__