Create an empty Stack.

You can pass the type for stack elements as argument of the constructor. In that case the stack is considered as typed

Appends the specified element to the end of this stack.

See also

   var stack : Stack = new Stack();
   
   stack.add( 50 );
   stack.add( "foo" );
   
   trace( stack.add( "foo" ) ); // true, because stack allow one or more entries
           // for an element
   
   trace( stack.size() ); // 3
   

   var stack : Stack = new Stack( String );
   
   stack.add( "foo" );
   
   trace( stack.add( "foo" ) ); // true, because stack allow one or more occurrences
           // for an element
           
   try
   {
    stack.add( 50 ); // fail, as 50 is not a string
   }
   catch( e : ClassCastException )
   {
    trace ( e );
   }
   
   trace( stack.size() ); // 2
   

Appends all of the elements in the specified Collection to the end of this stack, in the order that they are returned by the specified Collection's Iterator. The behavior of this operation is undefined if the specified Collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified Collection is this stack, and this stack is nonempty.)

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

See also

Inserts all of the elements in the specified Collection into this stack at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in the stack in the order that they are returned by the specified Collection's iterator.

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

See also

Inserts the specified element at the specified position in this stack. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

See also

Removes all of the elements from this Stack. The Stack will be empty after this call returns (unless it throws an exception).

Returns true if this stack contains at least one occurence of the specified element. Moreformally, returns true if and only if this stack contains at least an element e such that o === e.

Returns true if this Stack contains all of the elements in the specified Collection.

Returns the Object stored at the passed-in index in this stack object.

If the passed-in index is not a valid index for this stack, the function throw an IndexOutOfBoundsException exception.

Return the current type allowed in the Stack

Searches for the first occurence of the given argument.

Returns true if this stack contains no elements.

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

Verify that the passed-in Collection is a valid collection for use with the addAll, addAllAt, 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 uint index is a valid index for this Stack. If not, an IndexOutOfBoundsException exception is thrown.

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

In the case that the stack 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 stack the method will throw a ClassCastException.

Returns an iterator over the elements in this list in proper sequence. The elements are returned according to the LIFO order of the stack.

This implementation returns a straightforward implementation of the iterator interface.

Returns the index of the last occurrence of the specified object in this Stack.

Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in the list. The specified index indicates the first element that would be returned by an initial call to the next method. An initial call to the previous method would return the element with the specified index minus one.

This implementation returns a straightforward implementation of the ListIterator interface that extends the implementation of the Iterator interface returned by the iterator() method. The ListIterator implementation relies on the backing list's get(int), set(int, Object), add(int, Object) and remove(int) methods.

Verify if the passed-in object can be inserted in the current Stack.

Looks at the object at the top of this stack without removing it from the stack.

Removes the object at the top of this stack and returns that object as the value of this function.

Pushes an item onto the top of this stack. This has exactly the same effect as:

add(item)

See also

Removes a single instance of the specified element from this stack, if this stack contains one or more such elements. Returns true if this stack 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 stack contains an occurrence of the passed-in element. Typically, the construct to remove all occurrences of an element should look like that :

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

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

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

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

Removes from this stack 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 stack1 : Stack = new Stack();
   var stack2 : Stack = new Stack();
   
   stack1.add( 1 );
   stack1.add( 2 );
   stack1.add( 3 );
   stack1.add( 4 );
   stack1.add( "foo1" );
   stack1.add( "foo2" );
   stack1.add( "foo3" );
   stack1.add( "foo4" );
   
   stack2.add( 1 );
   stack2.add( 3 );
   stack2.add( "foo1" );
   stack2.add( "foo3" );
   
   trace ( stack1.removeAll ( stack2 ) ) ;// true
   // stack1 now contains :
   // 2, 4, 'foo2', 'foo4' 
   

Removes the element at the specified position in this stack. Shifts any subsequent elements to the right (subtracts one from their indices).

Removes a single instance of the specified element from this stack, if this stack contains one or more such elements. Returns true if this stack 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 stack contains an occurrence of the passed-in element. Typically, the construct to remove all occurrences of an element should look like that :

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

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

See also

   var stack : Stack = new Stack();
   stack.add( "foo1" );
   stack.add( "foo2" );
   stack.add( "foo3" );
   
   trace ( stack.removeAt( 2 ) ); // return true, 'foo3' have been removed
   trace ( stack.removeAt( 0 ) ); // return true, 'foo1' have been removed  
           // and 'foo2' is now at index 0
   
   try
   {
    stack.removeAt( 1 ); // fail, as stack have only one entry at index 0
   }
   catch( e : IndexOutOfBoundsException )
   {
    trace( e );
   }
   

Retains only the elements in this stack that are contained in the specified collection (optional operation). In other words, removes from this stack 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 stack1 : Stack = new Stack();
   var stack2 : Stack = new Stack();
   
   stack1.add( 1 );
   stack1.add( 2 );
   stack1.add( 3 );
   stack1.add( 4 );
   stack1.add( "foo1" );
   stack1.add( "foo2" );
   stack1.add( "foo3" );
   stack1.add( "foo4" );
   
   stack2.add( 1 );
   stack2.add( 3 );
   stack2.add( "foo1" );
   stack2.add( "foo3" );
   
   trace ( stack1.retainAll ( stack2 ) ) ;// true
   // stack1 now contains :
   // 1, 3, 'foo1', 'foo3' 
   

Searches for the first occurence of the given argument.

Insert the passed-in Object in this stack at the specified index. The method returns the object previously stored at this index.

If the passed-in index is not a valid index for this stack, the function throw an IndexOutOfBoundsException exception.

If the passed-in object's type prevents it to be added in this stack the function will throw a ClassCastException.

Returns the number of components in this Stack.

Returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and ToIndex are equal, the returned List is empty.)

Returns an array containing all the elements in this stack. 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::Stack<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.