fifo.h

Socket异步通信,线程,双端队列 网络实时通信。

  }
  Tx GetValX()
  {
    return CFifoX<Tx>::GetValX();
  }

  void SetValY(Ty  Y)
  {
    if(!this)  { return;}
    m_Y      = Y;
  }
  Ty GetValY()
  {
    return m_Y;
  }

  Tx* GetpValX()
  {
    if(!this)  { return 0;}
    return &m_X;
  }
  Ty* GetpValY()
  {
    if(!this)  { return 0;}
    return &m_Y;
  }
  void GetpValue(Tx*& pX,Ty*& pY)
  {
    if(!this)  { return;}
    pX      = &m_X;
    pY      = &m_Y;
  }
  void GetpValue(Tx*& pX,Ty*& pY,int& nSize)
  {
    GetpValue(pX,pY);
    CFifo::GetValue(nSize);
  }
  void GetValue(Tx& X,Ty& Y)
  {
    if(!this)  { return;}
    X      = m_X;
    Y      = m_Y;
  }
  void GetValue(Tx& X,Ty& Y,int& nSize)
  {
    GetValue(X,Y);
    CFifo::GetValue(nSize);
  }

  void SetValue(Tx  X)
  {
    if(!this)  { return;}
    m_X      = X;
  }
  void SetValue(Tx  X,Ty  Y)
  {
    if(!this)  { return;}
    m_X      = X;
    m_Y      = Y;
  }
  void SetValue(Tx  X,Ty  Y,int  nSize)
  {
    SetValue(X,Y);
    CFifo::SetValue(nSize);
  }

};


template<class Tx,class Ty>
class CFifoXY : public CFifo
{
protected:
	CFifo* m_r[2];
	Tx m_X;
	Ty m_Y;

	CFifo**  get_r() //获取子树指针；
	{
		if(!this) return 0;
		return m_r;
	}
public:
	//缺省构造器内未对所有成员变量初始化,
	//需要释放指针时为防止调用pClearX或pClearY函数出错,
	//需要对调用点的成员变量进行设置0值或new分配的对象;
	CFifoXY() : CFifo(0)
	{
		m_r[0] = 0;
		m_r[1] = 0;
		//m_X = X;	//缺省参数有可能类型不匹配;
		//m_Y = Y;	//缺省参数有可能类型不匹配;
	}
	CFifoXY(Tx X,Ty Y) : CFifo(0)
	{
		m_r[0] = 0;
		m_r[1] = 0;
		m_X = X;
		m_Y = Y;
	}
	~CFifoXY()
	{
		try
		{
		}
		catch(...)
		{
		}

		Clear();
	}

	//两查找函数等效,比较静态函数和非静态函数区别!!静态函数传入调用点!只要在递归的过程中有返回,函数返回;
	CFifoXY* Find(int& h,const Tx X,const Ty Y,bool bXorY = true) //初始传入深度0；
	{
		if( bXorY&&m_X==X || !bXorY&&m_Y==Y )  return this;
		if( m_nSize>0 )
		{
			CFifoXY* o2 = GetFirst();
			for(int i=0;i<m_nSize;i++)
			{
				h++;
				CFifoXY* ol = o2->Find(h,X,Y,bXorY);
				if(ol)  return ol;  //不能以ol和o2 相等做判断!(最终递归返回不同于当前深度)
				h--;
				o2 = o2->Next();
			}
		}
		return 0;
	}
	static  CFifoXY* Find(CFifoXY* o1,const Tx X,const Ty Y,bool bXorY = true)
	{ 
		if( bXorY&&o1->m_X==X || !bXorY&&o1->m_Y==Y )	return o1;
		if(o1->GetSize())
		{
			CFifoXY* o2 = o1->GetFirst();
			for(int i1=0;i1<o1->GetSize();i1++)
			{
				CFifoXY* ol = Find(o2,X,Y,bXorY);
				if(ol)  return ol;  //不能以ol和o2相等做判断!(最终递归返回不同于当前深度)
				o2 = o2->Next();
			}
		}
		return 0;  
	}

	static void Cpy(CFifoXY*  Source,CFifoXY* Dest)
	{ //从根节点开始；
		if(Source==0||Dest==0)	return;
		Dest->SetValX( *Source->GetpValX() );
		Dest->SetValY( *Source->GetpValY() );
		if(!Source->GetSize() ) return;
		const int size = Source->GetSize();
		CFifoXY* o0,* o1 = Source->GetFirst();
		for(int k=0;k<size;k++)
		{
			o0 = Dest->rpush();	//size会自动计算;
			Cpy( o1,o0 );
			o1 = o1->Next();
		}
	}

	//从树状队列赋值到线型队列：
	static void Cpy1(CFifoXY*  Source,CFifoY<Tx,Ty>* Dest,bool bRev=true)	//队列是正向还是逆向存储参数！
	{ //从根节点开始；
		if(Source==0||Dest==0)	return;
		CFifoY<Tx,Ty>*  o = bRev? Dest->lpush() : Dest->rpush();
		o->SetValX( *Source->GetpValX() );
		o->SetValY( *Source->GetpValY() );

		if(!Source->GetSize() ) return;
		const int size = Source->GetSize();
		CFifoXY* o1 = Source->GetFirst();
		for(int k=0;k<size;k++)
		{
			Cpy1( o1,Dest,bRev );	//警告：图在静态递归函数内使用静态变量；因为不是每次开始调用时都执行对该静态变量的初始化操作！！
			o1 = o1->Next();
		}
	}

	void pClearX(bool bArr=false) //%/指针型值域,对象在Clear-函数前调用;
	{
		if(!bArr)  delete    ((CFifoXY*)this)->m_X;
		else       delete [] ((CFifoXY*)this)->m_X;

		if( this&&GetFirst() ) //%/原始为:(*(_r+1));
		{
			CFifo* p,* q = GetFirst(); //%/原始为:(*(_r+1));
			while( q )
			{
				p = q;
				q = q->Next(); //%/原始为:q = q->m_t[0];
				((CFifoXY*)p)->pClearX(bArr);  //派生类;
			} 
		} 
	}
	void pClearY(bool bArr=false) //%/指针型值域,对象在Clear-函数前调用;
	{
		if(!bArr)  delete    ((CFifoXY*)this)->m_Y;
		else       delete [] ((CFifoXY*)this)->m_Y;

		if( this&&GetFirst() ) //%/原始为:(*(_r+1));
		{
			CFifo* p,* q = GetFirst(); //%/原始为:(*(_r+1));
			while( q )
			{
				p = q;
				q = q->Next(); //%/原始为:q = q->m_t[0];
				((CFifoXY*)p)->pClearY(bArr);  //派生类;
			} 
		} 
	}

	CFifoXY* GetFirst(bool bHead= true)
	{
		return (CFifoXY*)CFifo::GetFirst(bHead);
	}
	CFifoXY* Next (bool bHead= true)
	{
		return (CFifoXY*)CFifo::Next (bHead);
	}

	//将其它队列中剪切下来的节点插入到当前队列中-函数1:
	CFifoXY* rpush(CFifo* o)
	{
		return (CFifoXY*)CFifo::rpush( o );
	}
	//将其它队列中剪切下来的节点插入到当前队列中-函数2:
	CFifoXY* lpush(CFifo* o)
	{
		return (CFifoXY*)CFifo::lpush( o );
	}

	//缺省push函数:
	CFifoXY* rpush()
	{
		return (CFifoXY*)CFifo::rpush( new CFifoXY() );
	}
	CFifoXY* lpush()
	{
		return (CFifoXY*)CFifo::lpush( new CFifoXY() );
	}
	CFifoXY* rpush(Tx X,Ty Y)
	{
		return (CFifoXY*)CFifo::rpush( new CFifoXY(X,Y) );
	}
	CFifoXY* lpush(Tx X,Ty Y)
	{
		return (CFifoXY*)CFifo::lpush( new CFifoXY(X,Y) );
	}
	CFifoXY* lpop()
	{
		return (CFifoXY*)CFifo::lpop();
	}
	CFifoXY* rpop()
	{
		return (CFifoXY*)CFifo::rpop();
	}

	void GetValue(Tx*& pX,Ty*& pY)
	{
		if(!this)  { return;}
		pX      = &m_X;
		pY      = &m_Y;
	}

	Tx* GetpValX()
	{
		if(!this)  { return 0;}
		return &m_X;
	}
	Ty* GetpValY()
	{
		if(!this)  { return 0;}
		return &m_Y;
	}
	Tx GetValX()
	{
		return m_X;
	}
	Ty GetValY()
	{
		return m_Y;
	}
	void SetValX(Tx  X)
	{
		if(!this)  { return;}
		m_X      = X;
	}
	void SetValY(Ty  Y)
	{
		if(!this)  { return;}
		m_Y      = Y;
	}
	void GetValue(Tx& X,Ty& Y)
	{
		if(!this)  { return;}
		X      = m_X;
		Y      = m_Y;
	}
	void SetValue(Tx  X,Ty  Y)
	{
		if(!this)  { return;}
		m_X      = X;
		m_Y      = Y;
	}

};



////////////////////////////////////////////////////////////////////////////////////////////////
//定义标准数组队列类：
template<class Tx>
class CFifoA : public CFifo
{
protected:
  Tx* m_arr;
  int   m_len;

  void SetValue(Tx* c  ,int l  ,bool bCreate)
  {
    if(!bCreate) delete [] m_arr;
    m_arr = 0;
    m_len = 0;
    if(l>0)
	try
    {
      int i;
      m_arr = new Tx[l];
      m_len = l;
      for(i=0;i<l;i++)m_arr[i] = c[i];
    }
    catch(...)
    {
    }
  }
public:
  CFifoA(Tx* c=0,int l=0,int nSize=0) : CFifo(nSize)
  {
    SetValue(c,l, true);
  }
  ~CFifoA()
  {
    try
    {
      delete [] m_arr;  m_arr = 0;  m_len = 0;
    }
    catch(...)
    {
    }
    Clear();
  }

  CFifoA* GetFirst(bool bHead= true)
  {
    return (CFifoA*)CFifo::GetFirst(bHead);
  }
  CFifoA* Next (bool bHead= true)
  {
    return (CFifoA*)CFifo::Next (bHead);
  }

  CFifoA* rpush(Tx* c=0,int l=0,int nSize=0)
  {
    return (CFifoA*)CFifo::rpush( new CFifoA(c,l,nSize) );
  }
  CFifoA* lpush(Tx* c=0,int l=0,int nSize=0)
  {
    return (CFifoA*)CFifo::lpush( new CFifoA(c,l,nSize) );
  }
  CFifoA* lpop()
  {
    return (CFifoA*)CFifo::lpop();
  }
  CFifoA* rpop()
  {
    return (CFifoA*)CFifo::rpop();
  }

  void GetValue(Tx*& c,int& l)
  {
    if(!this)  { c=0;l=0;  return;}
    c      = m_arr;
    l      = m_len;
  }
  void GetValue(Tx*& c,int& l,int& nSize)
  {
    CFifo::GetValue(nSize);
    GetValue(c,l);
  }

  void SetValue(Tx*  c,int  l)
  {
	SetValue(c,l,false);
  }
  void SetValue(Tx*  c,int  l,int  nSize)
  {
    CFifo::SetValue(nSize);
	SetValue(c,l); //使用上一函数代码；
  }

};
////////////////////////////////////////////////////////////////////////////////////////////////



//存储一个字符串队列类：（补空字符）
class CFifo1 : public CFifo
{
protected:
  char* m_arr;
  int   m_len;

  void SetValue(char* c  ,int l  ,bool bCreate)
  {
    if(!bCreate) delete [] m_arr;
    if(l<0)  l = 0;
    try
    {
      int i;
      m_arr = new char[l+1];  m_arr[l] = 0;
      m_len = l;      
      for(i=0;i<l;i++)  m_arr[i] = c[i];
    }
    catch(...)
    {
    }
  }
public:
  CFifo1(char* c=0,int l=0,int nSize=0) : CFifo(nSize)
  {
    SetValue(c,l, true);
  }
  ~CFifo1()
  {
    try
    {
      delete [] m_arr;  m_arr = 0;  m_len = 0;
    }
    catch(...)
    {
    }
    Clear();
  }

  CFifo1* GetFirst(bool bHead= true)
  {
    return (CFifo1*)CFifo::GetFirst(bHead);
  }
  CFifo1* Next (bool bHead= true)
  {
    return (CFifo1*)CFifo::Next (bHead);
  }

  CFifo1* rpush(char* c=0,int l=0,int nSize=0)
  {
    return (CFifo1*)CFifo::rpush( new CFifo1(c,l,nSize) );
  }
  CFifo1* lpush(char* c=0,int l=0,int nSize=0)
  {
    return (CFifo1*)CFifo::lpush( new CFifo1(c,l,nSize) );
  }
  CFifo1* lpop()
  {
    return (CFifo1*)CFifo::lpop();
  }
  CFifo1* rpop()
  {
    return (CFifo1*)CFifo::rpop();
  }

  void GetValue(char*& c,int& l)
  {
    if(!this)  { c=0;l=0;  return;}
    c      = m_arr;
    l      = m_len;
  }
  void GetValue(char*& c,int& l,int& nSize)
  {
    nSize = CFifo::GetvSize();
    GetValue(c,l);
  }

  void SetValue(char*  c,int  l)
  {
	SetValue(c,l,false);
  }
  void SetValue(char*  c,int  l,int  nSize)
  {
    CFifo::SetvSize(nSize);
	SetValue(c,l); //使用上一函数代码；
  }

};



//存储两个字符串的队列类：（补空字符）
class CFifo2 : public CFifo1
{
protected:
  char* m_str;
  int   m_siz;

  void SetValue(char* s  ,int z  ,bool bCreate)
  {
    if(!bCreate) delete [] m_str;
    if(z<0)  z = 0;
    try
    {
      int i;
      m_str = new char[z+1];  m_str[z] = 0;
      m_siz = z;      
      for(i=0;i<z;i++)  m_str[i] = s[i];
    }
    catch(...)
    {
    }
  }
public:
  CFifo2(char* c=0,int l=0,char* s=0,int z=0,int nSize=0) : CFifo1(c,l,nSize)
  {
    SetValue(s,z, true);
  }
  ~CFifo2()
  {
    try
    {
      delete [] m_str;  m_str = 0;  m_siz = 0;
    }
    catch(...)
    {
    }
    Clear();
  }

  CFifo2* GetFirst(bool bHead= true)
  {
    return (CFifo2*)CFifo::GetFirst(bHead);
  }
  CFifo2* Next (bool bHead= true)
  {
    return (CFifo2*)CFifo::Next (bHead);
  }

  CFifo2* rpush(char* c=0,int l=0,char* s=0,int z=0,int nSize=0)
  {
    return (CFifo2*)CFifo::rpush( new CFifo2(c,l,s,z,nSize) );
  }
  CFifo2* lpush(char* c=0,int l=0,char* s=0,int z=0,int nSize=0)
  {
    return (CFifo2*)CFifo::lpush( new CFifo2(c,l,s,z,nSize) );
  }
  CFifo2* lpop()
  {
    return (CFifo2*)CFifo::lpop();
  }
  CFifo2* rpop()
  {
    return (CFifo2*)CFifo::rpop();
  }

  void GetValue(char*& c,int& l)
  {
    CFifo1::GetValue(c,l);
  }
  void GetValue(char*& c,int& l,char*& s,int& z)
  {
    GetValue(c,l);
    if(!this)  { s=0;z=0;  return;}
    s      = m_str;
    z      = m_siz;
  }
  void GetValue(char*& c,int& l,char*& s,int& z,int& nSize)
  {
    nSize = CFifo::GetvSize();
    GetValue(c,l,s,z);
  }

  void SetValue(char*  c,int  l,char*  s,int  z)
  {
    CFifo1::SetValue(c,l,false);
    SetValue(s,z,false);
  }
  void SetValue(char*  c,int  l,char*  s,int  z,int  nSize)
  {
    nSize = CFifo::GetvSize();
    SetValue(c,l,s,z); //使用上一函数代码；
  }

};