import eQueue.*;
class eQueue.eQueue extends eObject
{
	private var mFrontNode:eNode;
	private var mRearNode:eNode;
	
	public function eQueue(inData:Object)
	{	//in here ,we will not allow the first node to be created while init a queue.
		mFrontNode=new eNode(inData);
		mFrontNode.mNextNode=mRearNode;
	}
	
	public function isEmpty():Boolean
	{
		return mFrontNode==null;
	}
	
	public function front():Object
	{
		assertDebug(mFrontNode!=null,"the front node is null\n");
		return mFrontNode.mData;
	}
	
	public function last():Object
	{
		assertDebug(mRearNode!=null,"the last node is null\n");
		return mRearNode.mData;
	}
	
	public function enQueue(inData:Object):Void
	{
		if(mFrontNode==null)//front:null,rear:null
			{
				mFrontNode=new eNode(inData);
			}
		else if(mRearNode==null)//front:unNull,rear:null
			{
				mRearNode=new eNode(inData);
				mFrontNode.mNextNode=mRearNode;
			}
		else //front:unNull,rear:unNull.
			{
				var tmpNode:eNode=new eNode(inData);
				mRearNode.mNextNode=tmpNode;
				mRearNode=tmpNode;
			}
	}
	
	public function deQueue():Object
	{
		assertDebug(mFrontNode!=null,"in dequeue,mFrontNode is null\n");
		
		var tmpData:Object=new Object();
		var tmpNode:eNode=new eNode(0);
		
		tmpNode=mFrontNode.mNextNode;
		tmpData=mFrontNode.mData;
		
		if(mFrontNode==mRearNode)//if the queue only has one node,and both front and rear point to it.
			{
				delete mFrontNode;
				delete mRearNode;
				mFrontNode=null;
				mRearNode=null;
			}
		else		//norm condition.
			{
				delete mFrontNode;//release the unused mem.
				mFrontNode=tmpNode;
			}
		//mFrontNode=new eNode(); no needed.
		return tmpData;
	}
	
	
	public function traversal():Void
	{
		var tmpNode:eNode=new eNode();
		tmpNode=mFrontNode;
		trace3("==starting of queue traversal==\n");
		while(tmpNode)
			{
				trace3(String(tmpNode.mData)+"\n");
				tmpNode=tmpNode.mNextNode;
			}
		trace3("==end of queue traversal==\n");
		
		tmpNode=null;
		delete tmpNode;
	}
	
	public function getLen():Number
	{
		var tmpNode:eNode=new eNode();
		var num:Number=0;
		
		tmpNode=mFrontNode;
		
		while(tmpNode)
		{
			tmpNode=tmpNode.mNextNode;
			num++;
		}
		
		delete tmpNode;
		return num;
	}
	
	
	public function finallize():Void
	{
		var tmpNode:eNode=new eNode();
		//assertion if mFrontNode is null is  no needed.
		while(mFrontNode)
		{
			tmpNode=mFrontNode.mNextNode;
			mFrontNode=null;
			delete mFrontNode;//free the mem.
			mFrontNode=tmpNode;
		}
		delete mRearNode;
	}
}