/*!
* This program is free software; you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License, version 2.1 as published by the Free Software
* Foundation.
*
* You should have received a copy of the GNU Lesser General Public License along with this
* program; if not, you can obtain a copy at http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
* or from the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* Copyright (c) 2002-2013 Pentaho Corporation..  All rights reserved.
*/

package org.pentaho.reporting.libraries.base.util;

import java.io.Serializable;
import java.util.Arrays;
import java.util.EmptyStackException;

/**
 * A very simple unsynchronized stack. This one is faster than the java.util-Version, which is based on the synchronized
 * java.util.Vector class.
 *
 * @author Thomas Morgner
 */
public final class FastStack<T> implements Serializable, Cloneable {
  /**
   * The contents of the stack. The array is likely to be larger than the actual size of the stack, so use
   * <code>size</code> to get the last accessible item.
   */
  private Object[] contents;
  /**
   * The current fill-level of the stack.
   */
  private int size;
  /**
   * The initial size of the stack, but also the growth-factor.
   */
  private int initialSize;
  /**
   * A constant for serialization support.
   */
  private static final long serialVersionUID = 3111917250800511580L;

  /**
   * Creates a new stack with an initial size and growth of 10 items.
   */
  public FastStack() {
    initialSize = 10;
  }

  /**
   * Creates a new stack with an initial size and growth as specified.
   *
   * @param size the initial size and growth.
   */
  public FastStack( final int size ) {
    initialSize = Math.max( 1, size );
  }

  /**
   * Checks whether the stack is empty.
   *
   * @return true, if the stack is empty, false otherwise.
   */
  public boolean isEmpty() {
    return size == 0;
  }

  /**
   * Returns the number of elements in the stack.
   *
   * @return the stack size.
   */
  public int size() {
    return size;
  }

  /**
   * Pushes a new object on the stack. Null-references are allowed.
   *
   * @param o the object, maybe null.
   */
  public void push( final T o ) {
    if ( contents == null ) {
      contents = new Object[ initialSize ];
      contents[ 0 ] = o;
      size = 1;
      return;
    }

    final int oldSize = size;
    size += 1;
    if ( contents.length == size ) {
      // grow ..
      final Object[] newContents = new Object[ size + initialSize ];
      System.arraycopy( contents, 0, newContents, 0, size );
      this.contents = newContents;
    }
    this.contents[ oldSize ] = o;
  }

  /**
   * Loads the top-most element from the stack, without removing it from the stack.
   *
   * @return the top-most object.
   * @throws EmptyStackException if the stack is empty.
   */
  public T peek() {
    if ( size == 0 ) {
      throw new EmptyStackException();
    }
    return (T) contents[ size - 1 ];
  }

  /**
   * Loads the top-most element from the stack and removes it from the stack at the same time.
   *
   * @return the top-most object.
   * @throws EmptyStackException if the stack is empty.
   */
  public T pop() {
    if ( size == 0 ) {
      throw new EmptyStackException();
    }
    size -= 1;
    final T retval = (T) contents[ size ];
    contents[ size ] = null;
    return retval;
  }

  /**
   * Creates a shallow copy of the stack.
   *
   * @return the cloned stack.
   */
  public FastStack<T> clone() {
    try {
      final FastStack<T> stack = (FastStack<T>) super.clone();
      if ( contents != null ) {
        stack.contents = contents.clone();
      }
      return stack;
    } catch ( final CloneNotSupportedException cne ) {
      throw new IllegalStateException( "Clone not supported? Why?" );
    }
  }

  /**
   * Removes all contents from the stack.
   */
  public void clear() {
    if ( contents != null ) {
      Arrays.fill( contents, 0, size, null );
    }
    this.size = 0;
  }

  /**
   * Returns the element from the stack at the given index-position.
   *
   * @param index the element's index.
   * @return the object.
   * @throws IndexOutOfBoundsException if the index given is greater than the number of objects in the stack.
   */
  public T get( final int index ) {
    if ( index >= size ) {
      throw new IndexOutOfBoundsException();
    }
    return (T) contents[ index ];
  }

  public String toString() {
    return "FastStack{" +
      "contents=" + ( contents == null ? null : Arrays.asList( contents ) ) +
      ", size=" + size +
      ", initialSize=" + initialSize +
      '}';
  }
}