fifo.h

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

/* * * * * * * * * * * * * * * * *
 *  ·(0)                        *
 *    ↖             调用点      *
 * Head  ☉0 ←——☉ｏ    　    *
 *        ↖↘     ︱            *
 *           ☉1   ︱            *
 *            ↖↘ ↓            *
 *               ☉2             *
 *             Tail ↘           *
 *                    ·(0)      *
 * * * * * * * * * * * * * * * * */

class CFifo
{
protected:
	CFifo* m_t[2];
	int   m_nSize;
public:
	CFifo(int nSize=0)
	{ 
		m_t[0] = 0;
		m_t[1] = 0;
		m_nSize = nSize;
	}
	virtual ~CFifo()
	{
		Clear(get_r());
	}
public:
	CFifo* cut(CFifo* o,bool& bSucc,bool bHead = true)
	{
		CFifo* oRtn = cut(get_r(),o,bSucc,bHead);
		return oRtn;
	}
	CFifo* del(CFifo* o,bool& bSucc,bool bHead = true)
	{
		CFifo* oRtn = cut(o,bSucc,bHead);
		try{delete o;}catch(...){}
		return oRtn;
	}
	CFifo* cut(CFifo* o,bool bHead = true)
	{	bool bSucc;  //调用上一函数;
		return cut(o,bSucc,bHead);
	}
	CFifo* del(CFifo* o,bool bHead = true)
	{	bool bSucc;  //调用上一函数;
		return del(o,bSucc,bHead);
	}

	void Clear()
	{
		Clear(get_r());
	}
	int  GetSize()
	{
		if(!this)  return 0;
		return m_nSize;
	}
	bool bHasNode()	//只有调用点才可以调用该函数；
	{
		if(!this)  return false;
		return ( *get_r() )? true : false;  //%/·先结合! 再结合&&或||；如：if(!a && !b)
	}
	CFifo* Next (bool bHead= true)
	{
		if(!this)  return 0;
		CFifo** _r = m_t;  //必须使用基类指针!
		return  bHead ? (*(_r+1)) : (*(_r+0));
	}
	CFifo* GetFirst(bool bHead= true)
	{
		return GetFirst(get_r(),bHead);
	}
	CFifo* rpush(CFifo* o)
	{
		return rpush( get_r(),o );
	}
	CFifo* lpush(CFifo* o)
	{
		return lpush( get_r(),o );
	}
	CFifo* rpush(int nSize=0)
	{
		return rpush( get_r(),new CFifo(nSize) );
	}
	CFifo* lpush(int nSize=0)
	{
		return lpush( get_r(),new CFifo(nSize) );
	}
	//%/返回参数判断是否有效：
	CFifo* lpop()
	{
		CFifo* o = lpop(get_r());
		return o;
	}
	//%/返回参数判断是否有效：
	CFifo* rpop()
	{
		CFifo* o = rpop(get_r());
		return o;
	}
	//%/返回参数判断是否有效：
	bool lpop(int& nSize)
	{
		CFifo* o = lpop(get_r());
		if(o==0)  { nSize=-1;  return false;}
		nSize = o->m_nSize;    
		delete   o;
		return  true;
	}
	//%/返回参数判断是否有效：
	bool rpop(int& nSize)
	{
		CFifo* o = rpop(get_r());
		if(o==0)  { nSize=-1;  return false;}
		nSize = o->m_nSize;	
		delete   o;
		return  true;
	}
	int  GetvSize()
	{
		if(!this)  {return 0;}
		return m_nSize;
	}
	void SetvSize(int  nSize)	//注：仅非树状队列的子节点可调用！
	{
		if(!this)  { return;}
		m_nSize = nSize;
	}

	int CalSize()
	{ //将从最末层节点向根层节点以统计的方式返回；
		int  all = 1;
		if( m_nSize>0 )
		{
			CFifo* q = GetFirst();  //派生类最终调用的仍然是基类函数;
			for(int i=0;i<m_nSize;i++)
			{
				all += q->CalSize();
				q = q->Next();
			}
		}
		return all;
	}
protected:
	virtual CFifo**  get_r() //获取子树指针；
	{
		if(!this) return 0;
		return m_t;
	}
	CFifo*  GetFirst(CFifo** _r, bool bHead= true)
	{
		if(!this)  return 0;
		return !bHead ? (*(_r+1)) : (*(_r+0));
	}
	CFifo*  rpush(CFifo** _r, CFifo* o) //%/参数使用new操作符;
	{
		if( (*(_r+1)) )
		{
			o->m_t[0] = (*(_r+1));
			(*(_r+1))->m_t[1] = o;
		}
		else
		if(!(*(_r+0)) )
			(*(_r+0))  = o;
		(*(_r+1))    = o;
		m_nSize++;
		return (*(_r+1));
	}
	CFifo*  lpush(CFifo** _r, CFifo* o) //%/参数使用new操作符;
	{
		if( (*(_r+0)) )
		{
			o->m_t[1] = (*(_r+0));
			(*(_r+0))->m_t[0] = o;
		}
		else
		if(!(*(_r+1)) )
			(*(_r+1))  = o;
		(*(_r+0))    = o;
		m_nSize++;
		return (*(_r+0));
	}
	CFifo*  lpop(CFifo** _r)
	{
		if( (*(_r+0)) )
		{
			CFifo* o = (*(_r+0));
			if( (*(_r+0))->m_t[1] )
			{
				(*(_r+0)) = (*(_r+0))->m_t[1];
				(*(_r+0))->m_t[0] =    0;
			}
			else
			{
				(*(_r+0)) = 0;
				(*(_r+1)) = 0;
			} 
			o->m_t[1]= 0;
			m_nSize--;

			return   o; //%/delete   o;
		}	return   0;
	}
	CFifo*  rpop(CFifo** _r)
	{
		if( (*(_r+1)) )
		{
			CFifo* o = (*(_r+1));
			if( (*(_r+1))->m_t[0] )
			{
				(*(_r+1)) = (*(_r+1))->m_t[0];
				(*(_r+1))->m_t[1] =    0;
			}
			else
			{
				(*(_r+0)) = 0;
				(*(_r+1)) = 0;
			} 
			o->m_t[0]= 0;
			m_nSize--;

			return   o; //%/delete   o;
		}	return   0;
	}
	CFifo*  cut(CFifo** _r, CFifo* o,bool& bSucc,bool bHead = true)  //参数：bHead = true，表示正向访问；
	{
		//如果是正向访问，返回其前一个节点；如果是逆向访问，返回其后一个节点；
		CFifo* oRtn = 0;
		bSucc = true;
		if(!this||o==this||o==0)
		{
			bSucc = false;
			return oRtn;
		}

		if( o!=(*(_r+0))&&o!=(*(_r+1)) )
		{
			if(o->m_t[0]&&o->m_t[1])
			{
				oRtn = bHead? o->m_t[0] : o->m_t[1];
				o->m_t[0]->m_t[1] = o->m_t[1];
				o->m_t[1]->m_t[0] = o->m_t[0];
				o->m_t[0] = 0;o->m_t[1] = 0;
				m_nSize--;  //减计数器;
			} 
			else bSucc = false;
		}
		else
		if( o==(*(_r+0)) )
		{
			CFifo* oT = o->m_t[1];
			lpop(_r); //只有一个点时，弹出后，(*(_r+1))指针会被修改；
			oRtn = bHead? (*(_r+1)) : oT;
		}//首;
		else
		if( o==(*(_r+1)) )
		{
			CFifo* oH = o->m_t[0];
			rpop(_r); //只有一个点时，弹出后，(*(_r+0))指针会被修改；
			oRtn = bHead? oH : (*(_r+0));
		}//尾;
		return oRtn;
	}
	virtual void  Clear(CFifo** _r)
	{
		if( this&&(*(_r+0)) )
		{
			CFifo* p,* q = (*(_r+0));
			while( q )
			{
				p = q;
				q = q->m_t[1];
				p->m_t[0] = 0;delete p;
			} 
			(*(_r+0)) = 0;
			(*(_r+1)) = 0;
			m_nSize = 0;
		}
	}
	virtual void  Clear_OrElse(CFifo** _r)  //删除值域可按本函数遍历顺序来执行;
	{
		if( this&&(*(_r+1)) )
		{
			CFifo* p,* q = (*(_r+1));
			while( q )
			{
				p = q;
				q = q->m_t[0];
				p->m_t[1] = 0;delete p;
			} 
			(*(_r+0)) = 0;
			(*(_r+1)) = 0;
			m_nSize = 0;
		} 
	}

};

//int     CFifo::CalSize() //%/为其派生类-树型堆栈使用;
//CFifo** CFifo::get_r()
//CFifo*  CFifo::GetFirst(CFifo** _r, bool bHead)
//CFifo*  CFifo::rpush(CFifo** _r, CFifo* o) //%/参数使用new操作符;
//CFifo*  CFifo::lpush(CFifo** _r, CFifo* o) //%/参数使用new操作符;
//CFifo*  CFifo::lpop(CFifo** _r)
//CFifo*  CFifo::rpop(CFifo** _r)
//CFifo*  CFifo::cut(CFifo** _r, CFifo* o,bool& bSucc,bool bHead)  //参数：bHead = true，表示正向访问；
//void    CFifo::Clear(CFifo** _r)
//void    CFifo::Clear_OrElse(CFifo** _r)  //删除值域可按本函数遍历顺序来执行;



//#include "Fifo.h"
template<class Tx>
class CFifoX : public CFifo
{
protected:
  Tx m_X;
public:
  CFifoX(int nSize=0) : CFifo(nSize)
  {
    //m_X = X;	//缺省参数有可能类型不匹配;
  }
  CFifoX(Tx X,int nSize=0) : CFifo(nSize)
  {
    m_X = X;
  }
  ~CFifoX()
  {
    try
    {
    }
    catch(...)
    {
    }

    Clear();
  }

  void pClear() //%/指针型值域,对象在Clear-函数前调用;
  {
    //%/if(this)  delete ((CFifoX*)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];
        delete ((CFifoX*)p)->m_X;
      } 
    } 
  }

	CFifoX* Find(const Tx X)
	{
		CFifoX* q = GetFirst();
		for(int i=0;i<m_nSize;i++)
		{
			if(q->m_X==X)  return q;
			q = q->Next();
		}
		return 0;
	}
	CFifoX* Find(const Tx X,int& index)
	{	index = -1;
		CFifoX* q = GetFirst();
		for(int i=0;i<m_nSize;i++)
		{
			if(q->m_X==X)  {index = i;return q};
			q = q->Next();
		}
		return 0;
	}

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

  void rpush(CFifoX* o)	//注：参数是new对象；
  {
    (CFifoX*)CFifo::rpush( o );
  }
  void lpush(CFifoX* o)	//注：参数是new对象；
  {
    (CFifoX*)CFifo::lpush( o );
  }

  CFifoX* rpush()
  {
    return (CFifoX*)CFifo::rpush( new CFifoX(0) );
  }
  CFifoX* lpush()
  {
    return (CFifoX*)CFifo::lpush( new CFifoX(0) );
  }

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

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

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


};



template<class Tx,class Ty>
class CFifoY : public CFifoX<Tx>
{
protected:
  Ty m_Y;
public:
  CFifoY(int nSize=0) : CFifoX<Tx>(nSize)
  {
    //m_Y = Y;	//缺省参数有可能类型不匹配;
  }
  CFifoY(Tx X,int nSize=0) : CFifoX<Tx>(X,nSize)
  {
    //m_Y = Y;	//缺省参数有可能类型不匹配;
  }
  CFifoY(Tx X,Ty Y,int nSize=0) : CFifoX<Tx>(X,nSize)
  {
    m_Y = Y;
  }
  ~CFifoY()
  {
    try
    {
    }
    catch(...)
    {
    }

    Clear();
  }

  void pClearX() //%/指针型值域,对象在Clear-函数前调用;
  {
    CFifoX::pClear();
  }
  void pClearY() //%/指针型值域,对象在Clear-函数前调用;
  {
    //%/if(this) delete ((CFifoY*)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];
        delete ((CFifoY*)p)->m_Y;
      } 
    } 
  }
  void pClear() //%/指针型值域,对象在Clear-函数前调用;
  {
    pClearX();
    pClearY();
  }

	CFifoY* Find(const Tx X,const Ty Y,bool bXorY = true)
	{
		CFifoY* q = GetFirst();
		for(int i=0;i<m_nSize;i++)
		{
			if( bXorY&&q->m_X==X || !bXorY&&q->m_Y==Y)	return q;
			q = q->Next();
		}
		return 0;
	}
	CFifoY* Find(const Tx X,const Ty Y,int& index,bool bXorY = true)
	{	index = -1;
		CFifoY* q = GetFirst();
		for(int i=0;i<m_nSize;i++)
		{
			if( bXorY&&q->m_X==X || !bXorY&&q->m_Y==Y)  {index=i;return q;}
			q = q->Next();
		}
		return 0;
	}

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

  void rpush(CFifoY* o)	//注：参数是new对象；
  {
    (CFifoY*)CFifo::rpush( o );
  }
  void lpush(CFifoY* o)	//注：参数是new对象；
  {
    (CFifoY*)CFifo::lpush( o );
  }

  CFifoY* lpush(int nSize=0)
  {
    return (CFifoY*)CFifo::lpush( new CFifoY(nSize) );
  }
  CFifoY* rpush(int nSize=0)
  {
    return (CFifoY*)CFifo::rpush( new CFifoY(nSize) );
  }

  CFifoY* lpush(Tx X,int nSize=0)
  {
    return (CFifoY*)CFifo::lpush( new CFifoY(X,nSize) );
  }
  CFifoY* rpush(Tx X,int nSize=0)
  {
    return (CFifoY*)CFifo::rpush( new CFifoY(X,nSize) );
  }
  CFifoY* lpush(Tx X,Ty Y,int nSize=0)
  {
    return (CFifoY*)CFifo::lpush( new CFifoY(X,Y,nSize) );
  }
  CFifoY* rpush(Tx X,Ty Y,int nSize=0)
  {
    return (CFifoY*)CFifo::rpush( new CFifoY(X,Y,nSize) );
  }
  CFifoY* lpop()
  {
    return (CFifoY*)CFifo::lpop();
  }
  CFifoY* rpop()
  {
    return (CFifoY*)CFifo::rpop();
  }

  void SetValX(Tx  X)
  {
    CFifoX<Tx>::SetValX(X);