View Javadoc

    1   /*
    2    *  Licensed to the Apache Software Foundation (ASF) under one
    3    *  or more contributor license agreements.  See the NOTICE file
    4    *  distributed with this work for additional information
    5    *  regarding copyright ownership.  The ASF licenses this file
    6    *  to you under the Apache License, Version 2.0 (the
    7    *  "License"); you may not use this file except in compliance
    8    *  with the License.  You may obtain a copy of the License at
    9    *
    10   *    http://www.apache.org/licenses/LICENSE-2.0
    11   *
    12   *  Unless required by applicable law or agreed to in writing,
    13   *  software distributed under the License is distributed on an
    14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    15   *  KIND, either express or implied.  See the License for the
    16   *  specific language governing permissions and limitations
    17   *  under the License.
    18   *
    19   */
    20  package org.apache.mina.util;
    21
    22  import java.io.Serializable;
    23  import java.util.Arrays;
    24
    25  /**
    26   * A unbounded stack.
    27   *
    28   * @author The Apache Directory Project (mina-dev@directory.apache.org)
    29   * @version $Rev: 555855 $, $Date: 2007-07-13 05:19:00 +0200 (Fri, 13 Jul 2007) $
    30   */
    31  public class Stack implements Serializable {
    32      private static final long serialVersionUID = 3546919169401434168L;
    33
    34      private static final int DEFAULT_CAPACITY = 4;
    35
    36      private Object[] items;
    37
    38      private int size = 0;
    39
    40      /**
    41       * Construct a new, empty stack.
    42       */
    43      public Stack() {
    44          items = new Object[DEFAULT_CAPACITY];
    45      }
    46
    47      /**
    48       * Clears this stack.
    49       */
    50      public void clear() {
    51          Arrays.fill(items, null);
    52          size = 0;
    53      }
    54
    55      /**
    56       * Pops from this stack.
    57       *
    58       * @return <code>null</code>, if this stack is empty or the element is
    59       *         really <code>null</code>.
    60       */
    61      public Object pop() {
    62          if (size == 0) {
    63              return null;
    64          }
    65
    66          int pos = size - 1;
    67          Object ret = items[pos];
    68          items[pos] = null;
    69          size--;
    70
    71          return ret;
    72      }
    73
    74      /**
    75       * Push into this stack.
    76       */
    77      public void push(Object obj) {
    78          if (size == items.length) {
    79              // expand queue
    80              final int oldLen = items.length;
    81              Object[] tmp = new Object[oldLen * 2];
    82              System.arraycopy(items, 0, tmp, 0, size);
    83              items = tmp;
    84          }
    85
    86          items[size] = obj;
    87          size++;
    88      }
    89
    90      public void remove(Object o) {
    91          for (int i = size - 1; i >= 0; i--) {
    92              if (items[i] == o) {
    93                  System.arraycopy(items, i + 1, items, i, size - i - 1);
    94                  items[size - 1] = null;
    95                  size--;
    96                  break;
    97              }
    98          }
    99      }
    100
    101     /**
    102      * Returns the first element of the stack.
    103      *
    104      * @return <code>null</code>, if the stack is empty, or the element is
    105      *         really <code>null</code>.
    106      */
    107     public Object first() {
    108         if (size == 0) {
    109             return null;
    110         }
    111
    112         return items[size - 1];
    113     }
    114
    115     public Object last() {
    116         if (size == 0) {
    117             return null;
    118         }
    119
    120         return items[0];
    121     }
    122
    123     /**
    124      * Returns <code>true</code> if the stack is empty.
    125      */
    126     public boolean isEmpty() {
    127         return (size == 0);
    128     }
    129
    130     /**
    131      * Returns the number of elements in the stack.
    132      */
    133     public int size() {
    134         return size;
    135     }
    136 }