双缓存静态循环队列（二）

// CritcalS.h: interface for the CCritcalS class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CRITCALS_H__4875D14E_4C88_4E3C_AF59_4F085B8FFBBA__INCLUDED_)
#define AFX_CRITCALS_H__4875D14E_4C88_4E3C_AF59_4F085B8FFBBA__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


class CCritcalS  
{
public:
    void Free();
    void Lock();
    CCritcalS();
    virtual ~CCritcalS();

private:    
    CRITICAL_SECTION m_critcal;
    BOOL m_IsLock;
};

#endif // !defined(AFX_CRITCALS_H__4875D14E_4C88_4E3C_AF59_4F085B8FFBBA__INCLUDED_)

// CritcalS.cpp: implementation of the CCritcalS class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "OverlapRoutine.h"
#include "CritcalS.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CCritcalS::CCritcalS()
{
    InitializeCriticalSection(&this->m_critcal);
    m_IsLock = FALSE;
}

CCritcalS::~CCritcalS()
{

}

void CCritcalS::Lock()
{
    EnterCriticalSection(&this->m_critcal);
    if(this->m_IsLock)
    {
        ASSERT(0);
    }

    this->m_IsLock = TRUE;
}

void CCritcalS::Free()
{
    this->m_IsLock = FALSE;
    LeaveCriticalSection(&this->m_critcal);
}

// BufQueue.h: interface for the CBufQueue class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_BUFQUEUE_H__667975DA_4709_4F1C_A6F5_F07587C86E0E__INCLUDED_)
#define AFX_BUFQUEUE_H__667975DA_4709_4F1C_A6F5_F07587C86E0E__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "CritcalS.h"

// 静态FIFO循环队列,服务器端作为读写缓存
#define MAX_CMP(x,y) x>=y?x:y
#define MIN_CMP(x,y) x<=y?x:y
const QUEUESIZE = 1024*32;   //队列大小

class CBufQueue  
{
public:
    int Read(char *pBuf, int readBytes);
    int GetfreeSize();
    int GetdataSize();
    int Write(const char *pBuf, int writeBytes);
    CBufQueue();
    virtual ~CBufQueue();
private:
    void next(int &index);
    char pop();
    void push(char data);

    char m_charArray[QUEUESIZE];
    int m_indexH;  // 对列头  第一个数据位的索引值
    int m_indexT;  // 队列尾  第一个空闲位的索引值

    CCritcalS m_critcal;
};

#endif // !defined(AFX_BUFQUEUE_H__667975DA_4709_4F1C_A6F5_F07587C86E0E__INCLUDED_)

// 静态循环队算法
/*

1)永远保留一个空闲位置: 只有队列为空时:m_indexH等于m_indexTT;
                        满队列的容量为: QUEUESIZE-1

2)初始空队列状态: m_indexH = 0
                  m_indexT = 0

3)CUR为当前索引位置,则NEXT索引位计算公式: NEXT = (CUR+1)% QUEUESIZE

4)队列数据容量SIZE计算: if(m_indexT>=m_indexH)
                           SIZE = m_indexT - m_indexH

                        if(m_indexT<m_indexH)
                           SIZE = m_indexT - m_indexH + QUEUESIZE

5)在插入数据时，当数据容量等于QUEUESIZE-1时判断队列满 (禁止插入)

*/

// BufQueue.cpp: implementation of the CBufQueue class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "OverlapRoutine.h"
#include "BufQueue.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBufQueue::CBufQueue()
{
    this->m_indexH = 0;
    this->m_indexT = 0;
}

CBufQueue::~CBufQueue()
{

}

int CBufQueue::Write(const char *pBuf, int writeBytes)
{    
    m_critcal.Lock();
     
    int sum = this->GetfreeSize();
    int    tSize = MIN_CMP(writeBytes,sum);
    for(int i=0;i<tSize;i++)
    {
        this->push(pBuf[i]);
    }
    m_critcal.Free();

    return tSize;
}

int CBufQueue::Read(char *pBuf, int readBytes)
{
    m_critcal.Lock();
    
    int sum = this->GetdataSize();
    int tSize = MIN_CMP(readBytes,sum);
    for(int i=0;i<tSize;i++)
    {
        pBuf[i] = this->pop();
    }
    m_critcal.Free();

    return tSize;

}

// 队尾入队，由外层函数做队满判断
void CBufQueue::push(char data)
{
    this->m_charArray[this->m_indexT] = data;  // 
    next(this->m_indexT);
}

// 对头出队，有外层函数作队空判断
char CBufQueue::pop()
{
    char res =     this->m_charArray[this->m_indexH];
    next(this->m_indexH);

    return res;
}

// 获得队列数据容量
int CBufQueue::GetdataSize()
{
    if(m_indexT>=m_indexH)
    {
        return (m_indexT - m_indexH);
    }else
    {
        return (m_indexT - m_indexH + QUEUESIZE);
    }
}

// 获得队列空闲容量
int CBufQueue::GetfreeSize()
{
    return (QUEUESIZE-this->GetdataSize() - 1);
}

// 索引下滑计算
void CBufQueue::next(int &index)
{
    index = (index+1)% QUEUESIZE;
}