content: /*
   * Copyright 2017 nebular
   *
   * This program is free software: you can redistribute it and/or modify it under the
   * terms of the GNU Lesser General Public License as published by the Free Software
   * Foundation, either version 3 of the License, or (at your option) any later version.
   *
   * 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.
   *
   * You should have received a copy of the GNU Lesser General Public License along with
   * this program. If not, see <http://www.gnu.org/licenses/>.
   */
  package org.oscim.layers.marker.utils;
  
  /**
   * This comes for Android API. It is used by the INT SPARSEARRAY.
   * The Android version uses some native routines to create the arrays, I suppose for performance.
   * However our use of this class is very basic, and we will avoid resizing the arrays as much
   * as possible.
   * <p>
   * A helper class that aims to provide comparable growth performance to ArrayList, but on primitive
   * arrays. Common array operations are implemented for efficient use in dynamic containers.
   * <p>
   * All methods in this class assume that the length of an array is equivalent to its capacity and
   * NOT the number of elements in the array. The current size of the array is always passed in as a
   * parameter.
   */
  public final class GrowingArrayUtils {
  
      /**
       * Appends an element to the end of the array, growing the array if there is no more room.
       *
       * @param array       The array to which to append the element. This must NOT be null.
       * @param currentSize The number of elements in the array. Must be less than or equal to
       *                    array.length.
       * @param element     The element to append.
       * @return the array to which the element was appended. This may be different than the given
       * array.
       */
      public static int[] append(int[] array, int currentSize, int element) {
          assert currentSize <= array.length;
          if (currentSize + 1 > array.length) {
              int[] newArray = new int[growSize(currentSize)];
              System.arraycopy(array, 0, newArray, 0, currentSize);
              array = newArray;
          }
          array[currentSize] = element;
          return array;
      }
  
      /**
       * Inserts an element into the array at the specified index, growing the array if there is no
       * more room.
       *
       * @param array       The array to which to append the element. Must NOT be null.
       * @param currentSize The number of elements in the array. Must be less than or equal to
       *                    array.length.
       * @param element     The element to insert.
       * @return the array to which the element was appended. This may be different than the given
       * array.
       */
      public static int[] insert(int[] array, int currentSize, int index, int element) {
          assert currentSize <= array.length;
          if (currentSize + 1 <= array.length) {
              System.arraycopy(array, index, array, index + 1, currentSize - index);
              array[index] = element;
              return array;
          }
          int[] newArray = new int[growSize(currentSize)];
          System.arraycopy(array, 0, newArray, 0, index);
          newArray[index] = element;
          System.arraycopy(array, index, newArray, index + 1, array.length - index);
          return newArray;
      }
  
      /**
       * Given the current size of an array, returns an ideal size to which the array should grow.
       * This is typically double the given size, but should not be relied upon to do so in the
       * future.
       */
      public static int growSize(int currentSize) {
          return currentSize <= 4 ? 8 : currentSize * 2;
      }
  
      private GrowingArrayUtils() {
      }
  }
  