/************************************************
* Queue storage, element address is not fixed, 
* the current pointer to the latest element
*
* create zoufuzhou 20191001
*
************************************************/

#ifndef _MEM_TABLE_CACHE_HPP_
#define _MEM_TABLE_CACHE_HPP_
 

#include <glob/GlobMem.h>

template <typename T> class CMemTable
{
    private:
			long* p_size;
			T* p_ptr;
			long maxsize;
    public:
			CMemTable(const string& tableName,long maxsize)
			{
				this->maxsize = maxsize;
				char* ptr = (char*)GlobMem::GetInstancePtr()->GetTablePtr(tableName);
				if(ptr == NULL) 
				{
					p_ptr = NULL;
					p_size = NULL;
					return;
				}
				p_size = (long*)ptr;
			  if((*p_size) > maxsize) (*p_size) = maxsize;
			  else if((*p_size) < 0) (*p_size) = 0;
				p_ptr = (T*)(ptr+sizeof(long));
			};

			~CMemTable(){};

			T* operator()(void)
			{
				return p_ptr;
			};

			T* operator[](int i)
			{
				if(p_ptr == NULL)return NULL;
				return p_ptr+i;
			};

			void push(T* t)
			{
				if(p_ptr == NULL)return;
				if( maxsize == 1)
				{
					memcpy(p_ptr,t,sizeof(T));
					(*p_size) = maxsize;
				}
				else if ((*p_size) < maxsize)
				{
					memmove(p_ptr+1,p_ptr,sizeof(T)*(*p_size));
					memcpy(p_ptr,t,sizeof(T));
					(*p_size)++;
				}
				else
				{
					memmove(&p_ptr[1],p_ptr,sizeof(T)*(maxsize-1));
					memcpy(p_ptr,t,sizeof(T));
					(*p_size) = maxsize;
				}
			};

			long count(void)
			{
				if(p_size == NULL)return 0;
				return *p_size;
			};

			void clear(void)
			{
				if(p_size == NULL)return 0;
			 (*p_size) = 0;
			};
};
#endif