xx

// CCRingVectorIterator.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>

using namespace std;

#include "CRingVectorIterator.h"
#include "CRingVector.h"

CRingVector<int>				g_cRingVector(5);
CRingVectorIterator<int>		g_cRingVectorIt(g_cRingVector, 2);

int _tmain(int argc, _TCHAR* argv[])
{
	g_cRingVector.push_back(1);
	g_cRingVector.push_back(2);
	g_cRingVector.push_back(3);
	g_cRingVector.push_back(4);
	g_cRingVector.push_back(5);
	cout << *g_cRingVectorIt << endl;
	cout << *(++g_cRingVectorIt) << endl;
	return 0;
}

#pragma once

//template <typename T>
//class CCRingVectorIterator<T>;

template <typename T>
class CRingVector
{
//public:
//	friend class CCRingVectorIterator<T>;

public:
	CRingVector(size_t capacity)
		: m_uiCapacity(capacity)
		//, m_pDataFront(new int[5]) //TODO:new T[capacity]
		//, m_pDataRear(m_pDataFront+m_uiCapacity)
		//, m_uiSize(0)
		//, m_pConsummerStart(m_pDataFront)
		//, m_pProducerStart(m_pDataFront)
	{
		m_pDataFront = new int[5]; //TODO:new T[capacity]
		m_pDataRear = m_pDataFront+m_uiCapacity;
		m_uiSize = 0;
		m_pConsummerStart = m_pDataFront;
		m_pProducerStart = m_pDataFront;
	}

	~CRingVector()
	{
		delete m_pDataFront;
	}

	void push_back(const T& data)
	{
		if (m_uiSize && m_pConsummerStart == m_pProducerStart) {
			cout << "out of flow,then not insert." << endl;
			return ;
		} else {
			*m_pProducerStart = data;
			m_pProducerStart = NextInsertPosition();
			//lock();
			m_uiSize++;
			//unlock();
		}
	}

	bool IsEmpty()
	{
		return (m_uiSize==0);
	}


public://private:
	///返回插入位置
	T* NextInsertPosition()
	{
		T* pNextInsertPos = ((m_pProducerStart+1) == m_pDataRear ? m_pDataFront : (m_pProducerStart+1));
		return pNextInsertPos;
	}

public://private:
	T*				m_pDataFront;
	T*				m_pDataRear;

	size_t					m_uiSize;
	size_t					m_uiCapacity;

	///消费者消费起始位置
	T*						m_pConsummerStart;
	///生产者插入位置
	T*						m_pProducerStart;
};

#pragma once

#include "CRingVector.h"

template <typename T>
class CRingVectorIterator
{
public:
	CRingVectorIterator(CRingVector<T>& v, size_t len) 
		: m_RingVector(v)
	{
		m_pStart = m_RingVector.m_pConsummerStart;
		m_pCurrent = m_RingVector.m_pConsummerStart;
		m_bBreak = false;
		m_uiLen = len;


		//lock();
		m_uiCount++;
		if (m_RingVector.IsEmpty()) {
			cout << "There is no datas" << endl;
		}

		///防止超过消费能力
		if (m_uiLen > m_RingVector.m_uiSize) {
			m_uiLen = m_RingVector.m_uiSize;
		}

		if (m_pStart+len <= m_RingVector.m_pDataRear) {	///没有超过数组的最后一个
			m_pEnd = m_pStart + m_uiLen;
		} else {										///超过
			m_bBreak = true;
			m_pEnd = (m_RingVector.m_pDataRear-m_pStart)+m_RingVector.m_pDataFront;
		}
	}

	CRingVectorIterator(const CRingVectorIterator& it)
	{
		m_RingVector = it.m_RingVector;
		m_pCurrent = it.m_pCurrent;
		m_pStart = it.m_pStart;
		m_pEnd = it.m_pEnd;
		m_uiLen = it.m_uiLen;
	}

	~CRingVectorIterator()
	{
		m_uiCount--;
		if (!m_uiCount) {
			m_RingVector.m_pConsummerStart = m_pEnd;
			//TODO:modify size
			m_RingVector.m_uiSize -= m_uiLen;
		}
	}

	CRingVectorIterator& operator++()
	{
		T*		pNext = FindNext(1);
		if (!pNext) {
			cout << "超出了范围，不设置任何" << endl;
		} else {
			m_pCurrent = pNext;
		}
		return *this;
	}

	T					operator*()
	{
		return *m_pCurrent;
	}

	T* operator+(size_t len)
	{

	}

private:
	bool	IsOutOfRange(const T* p) const 
	{
		bool bRet = false;

		if (!m_bBreak) {
			bRet = (p >= m_pStart && p < m_pEnd) ? false :true;
		} else {
			bRet = (p >= m_pEnd && p < m_pStart) ? true : false;
		}
		return bRet;
	}

	T*		FindNext(int i) const 
	{
		T*			pNext = m_pCurrent+i;
		if (m_bBreak) {
			if (pNext < m_RingVector.m_pDataFront) {
				pNext = m_RingVector.m_pDataRear - (m_RingVector.m_pDataFront-pNext);
			} else if (pNext >= m_RingVector.m_pDataRear) {
				pNext = pNext-m_RingVector.m_pDataRear+m_RingVector.m_pDataFront;
			}
			if (IsOutOfRange(pNext))
				pNext = NULL;
		} else {
			if (IsOutOfRange(pNext)) 
				pNext = NULL;
		}
		return pNext;
	}
private:
	CRingVector<T>&				m_RingVector;

	T*							m_pCurrent;

	T*							m_pStart;
	bool						m_bBreak;
	T*							m_pEnd;
	size_t						m_uiLen;

	static size_t				m_uiCount;
};

template <typename T>
size_t CRingVectorIterator<T>::m_uiCount = 0;