Returns true if this queue contains no elements.

Returns true if this queue perform a verification of the type of elements.

Verify that the passed-in Collection is a valid collection for use with the addAll, removeAll, retainAll and containsAll methods.

When dealing with typed and untyped collection, the following rules apply :

• Two typed collection, which have the same type, can collaborate each other.
• Two untyped collection can collaborate each other.
• An untyped collection can add, remove, retain or contains any typed collection of any type without throwing errors.
• A typed collection will always fail when attempting to add, remove, retain or contains an untyped collection.

If the passed-in Collection is null the method throw a NullPointerException error.

See also

Verify that the passed-in object type match the current Queue element's type.

In the case that the queue is untyped the function will always returns true.

In the case that the object's type prevents it to be added as element for this queue the method will throw a ClassCastException.

Returns an iterator over the elements in this queue. The elements are returned according to the FIFO (first-in-first-out) order.

Verify that the passed-in object type match the current queue element's type.

Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.

Retrieves and removes the head of this queue, or returns null if this queue is empty.

Removes a single instance of the specified element from this queue, if this queue contains one or more such elements. Returns true if this queue contained the specified element (or equivalently, if this collection changed as a result of the call).

In order to remove all occurences of an element you have to call the remove method as long as the queue contains an occurrence of the passed-in element. Typically, the construct to remove all occurrences of an element should look like that :

   while( queue.contains( element ) ) queue.remove( element );
   

If the current queue object is typed and if the passed-in object's type prevents it to be added (and then removed) in this queue, the function throws a ClassCastException.

   var queue : Queue = new Queue();
   queue.add ( "foo" );
   queue.add ( "foo" );
   
   trace( queue.size() ); // 1
   trace( queue.remove( "foo" ) ); // true, the first occurence of 'foo' have
              // been removed from the queue
   
   trace( queue.size() ); // 1
   trace( queue.remove( "foo" ) ); // true, the passed-in value has always
              // an occurence contained in the queue
   
   trace( queue.size() ); // 0
   trace( queue.remove( "foo" ) ); // false, as there is no more occurence
              // in the queue
   

   var queue : Queue = new Queue( String );
   queue.add ( "foo" );
   
   trace( queue.size() ); // 1
   trace( queue.remove( "foo" ) ); // true, the passed-in value have been removed
   
   // the code below will produce an exception
   try
   {
    queue.remove( 45 ); // fail, as the passed-in value is not of type string
   }
   catch( e : ClassCastException )
   {
    trace ( e );  
   }
   

Removes from this queue all of its elements that are contained in the specified collection (optional operation). At the end of the call there's no occurences of any elements contained in the passed-in collection.

The rules which govern collaboration between typed and untyped Collection are described in the isValidCollection descrition, all rules described there are supported by the removeAll method.

See also

   var queue1 : Queue = new Queue();
   var queue2 : Queue = new Queue();
   
   queue1.add( 1 );
   queue1.add( 2 );
   queue1.add( 3 );
   queue1.add( 4 );
   queue1.add( "foo1" );
   queue1.add( "foo2" );
   queue1.add( "foo3" );
   queue1.add( "foo4" );
   
   queue2.add( 1 );
   queue2.add( 3 );
   queue2.add( "foo1" );
   queue2.add( "foo3" );
   
   trace ( queue1.removeAll ( queue2 ) ) ;// true
   // queue1 now contains :
   // 2, 4, 'foo2', 'foo4' 
   

Retains only the elements in this queue that are contained in the specified collection (optional operation). In other words, removes from this queue all of its elements that are not contained in the specified collection.

The rules which govern collaboration between typed and untyped Collection are described in the isValidCollection descrition, all rules described there are supported by the retainAll method.

See also

   var queue1 : Queue = new Queue();
   var queue2 : Queue = new Queue();
   
   queue1.add( 1 );
   queue1.add( 2 );
   queue1.add( 3 );
   queue1.add( 4 );
   queue1.add( "foo1" );
   queue1.add( "foo2" );
   queue1.add( "foo3" );
   queue1.add( "foo4" );
   
   queue2.add( 1 );
   queue2.add( 3 );
   queue2.add( "foo1" );
   queue2.add( "foo3" );
   
   trace ( queue1.retainAll ( queue2 ) ) ;// true
   // queue1 now contains :
   // 1, 3, 'foo1', 'foo3' 
   

Returns the number of elements in this queue (its cardinality).

Returns an array containing all the elements in this queue. Obeys the general contract of the Collection.toArray method.

See also

Returns the String representation of this object.

The function return a string like com.bourre.collection::Queue<String> for a typed collection. The string between the < and > is the name of the type of the collection's elements. If the collection is an untyped collection the function will simply return the result of the PixlibStringifier.stringify call.