#ifndef _SOCKET_RECEIVECACHE_HPP_
#define _SOCKET_RECEIVECACHE_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_WINSOCK_HPP_
#include <common/winsock.hpp>
#endif
#ifndef _COMMON_GLOBALDATA_HPP_
#include <common/gdata.hpp>
#endif

class ReceiveCache
{	
public:
  ReceiveCache(void);
	ReceiveCache(const ReceiveCache &someReceiveCache);
	virtual ~ReceiveCache();
	SOCKET socket(void)const;
	void socket(SOCKET socket);
	void reset(void);
  WORD hasData(BOOL acquireData=TRUE);
  WORD isReady(WORD waitForData=TRUE)const;
 	WORD receive(char &charData,BOOL waitForData=TRUE);
  WORD receive(char *pBuffer,DWORD lengthBuffer,DWORD &itemCount,BOOL waitForData=TRUE);
private:
  enum {CacheSize=16384,WaitTime=1};  
	ReceiveCache &operator=(const ReceiveCache &someReceiveCache);
  WORD cacheData(void);
	int itemsInCache(void)const;
	void itemsInCache(int itemsInCache);
	DWORD cursor(void)const;
	void cursor(DWORD cursor);

	GlobalData<BYTE> mReceiveCache;
	DWORD mCursor;
	int mItemsInCache;
  SOCKET mSocket;  
};

inline
ReceiveCache::ReceiveCache(void)
: mCursor(0), mItemsInCache(0), mSocket(INVALID_SOCKET)
{
  mReceiveCache.size(CacheSize);
}

inline
ReceiveCache::ReceiveCache(const ReceiveCache &someReceiveCache)
{
  *this=someReceiveCache;
}

inline
ReceiveCache::~ReceiveCache()
{
}

inline
ReceiveCache &ReceiveCache::operator=(const ReceiveCache &someReceiveCache)
{
  mReceiveCache=someReceiveCache.mReceiveCache;
	mCursor=someReceiveCache.mCursor;
	mItemsInCache=someReceiveCache.mItemsInCache;
	mSocket=someReceiveCache.mSocket;
	return *this;
}

inline
SOCKET ReceiveCache::socket(void)const
{
  return mSocket;
}

inline
void ReceiveCache::socket(SOCKET socket)
{
  mSocket=socket;
	cursor(0);
	itemsInCache(0);
}

inline
int ReceiveCache::itemsInCache(void)const
{
  return mItemsInCache;
}

inline
void ReceiveCache::itemsInCache(int itemsInCache)
{
  mItemsInCache=itemsInCache;
}

inline
DWORD ReceiveCache::cursor(void)const
{
  return mCursor;
}

inline
void ReceiveCache::cursor(DWORD cursor)
{
  mCursor=cursor;
}

inline
void ReceiveCache::reset(void)
{
  socket(INVALID_SOCKET);
	cursor(0);
	itemsInCache(0);
}
#endif