ArrayUtils.java

  1. /*
  2.  * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved. This
  3.  * code is released under a tri EPL/GPL/LGPL license. You can use it,
  4.  * redistribute it and/or modify it under the terms of the:
  5.  *
  6.  * Eclipse Public License version 1.0
  7.  * GNU General Public License version 2
  8.  * GNU Lesser General Public License version 2.1
  9.  */
  10. package org.jruby.truffle.runtime.util;

  12. import com.oracle.truffle.api.CompilerAsserts;
  13. import org.jruby.truffle.nodes.RubyNode;
  14. import org.jruby.truffle.runtime.RubyArguments;

  16. import java.util.Arrays;

  18. public abstract class ArrayUtils {

  20.     public static boolean contains(int[] array, int value) {
  21.         for (int n = 0; n < array.length; n++) {
  22.             if (array[n] == value) {
  23.                 return true;
  24.             }
  25.         }

  27.         return false;
  28.     }

  30.     public static boolean contains(long[] array, long value) {
  31.         for (int n = 0; n < array.length; n++) {
  32.             if (array[n] == value) {
  33.                 return true;
  34.             }
  35.         }

  37.         return false;
  38.     }

  40.     public static boolean contains(double[] array, double value) {
  41.         for (int n = 0; n < array.length; n++) {
  42.             if (array[n] == value) {
  43.                 return true;
  44.             }
  45.         }

  47.         return false;
  48.     }

  50.     public static boolean contains(Object[] array, int length, Object value) {
  51.         for (int n = 0; n < length; n++) {
  52.             if (array[n].equals(value)) {
  53.                 return true;
  54.             }
  55.         }

  57.         return false;
  58.     }

  60.     public static Object[] box(int[] unboxed) {
  61.         return box(unboxed, 0);
  62.     }

  64.     public static Object[] box(long[] unboxed) {
  65.         return box(unboxed, 0);
  66.     }

  68.     public static Object[] box(double[] unboxed) {
  69.         return box(unboxed, 0);
  70.     }

  72.     public static Object[] box(Object array) {
  73.         return box(array, 0);
  74.     }

  76.     public static Object[] box(int[] unboxed, int extra) {
  77.         final Object[] boxed = new Object[unboxed.length + extra];

  79.         for (int n = 0; n < unboxed.length; n++) {
  80.             boxed[n] = unboxed[n];
  81.         }

  83.         return boxed;
  84.     }

  86.     public static Object[] box(long[] unboxed, int extra) {
  87.         final Object[] boxed = new Object[unboxed.length + extra];

  89.         for (int n = 0; n < unboxed.length; n++) {
  90.             boxed[n] = unboxed[n];
  91.         }

  93.         return boxed;
  94.     }

  96.     public static Object[] box(double[] unboxed, int extra) {
  97.         final Object[] boxed = new Object[unboxed.length + extra];

  99.         for (int n = 0; n < unboxed.length; n++) {
  100.             boxed[n] = unboxed[n];
  101.         }

  103.         return boxed;
  104.     }

  106.     public static Object[] boxUntil(int[] unboxed, int length) {
  107.         final Object[] boxed = new Object[length];

  109.         for (int n = 0; n < length; n++) {
  110.             boxed[n] = unboxed[n];
  111.         }

  113.         return boxed;
  114.     }

  116.     public static Object[] boxUntil(long[] unboxed, int length) {
  117.         final Object[] boxed = new Object[length];

  119.         for (int n = 0; n < length; n++) {
  120.             boxed[n] = unboxed[n];
  121.         }

  123.         return boxed;
  124.     }

  126.     public static Object[] boxUntil(double[] unboxed, int length) {
  127.         final Object[] boxed = new Object[length];

  129.         for (int n = 0; n < length; n++) {
  130.             boxed[n] = unboxed[n];
  131.         }

  133.         return boxed;
  134.     }

  136.     public static Object[] box(Object array, int extra) {
  137.         CompilerAsserts.neverPartOfCompilation();

  139.         if (array == null) {
  140.            return new Object[extra];
  141.         } if (array instanceof int[]) {
  142.             return box((int[]) array, extra);
  143.         } else if (array instanceof long[]) {
  144.             return box((long[]) array, extra);
  145.         } else if (array instanceof double[]) {
  146.             return box((double[]) array, extra);
  147.         } else if (array instanceof Object[]) {
  148.             final Object[] objectArray = (Object[]) array;
  149.             return Arrays.copyOf(objectArray, objectArray.length + extra);
  150.         } else {
  151.             throw new UnsupportedOperationException();
  152.         }
  153.     }

  155.     public static int[] unboxInteger(Object[] unboxed, int length) {
  156.         CompilerAsserts.neverPartOfCompilation();

  158.         final int[] boxed = new int[length];

  160.         for (int n = 0; n < length; n++) {
  161.             boxed[n] = (int) unboxed[n];
  162.         }

  164.         return boxed;
  165.     }

  167.     public static long[] unboxLong(Object[] unboxed, int length) {
  168.         CompilerAsserts.neverPartOfCompilation();

  170.         final long[] boxed = new long[length];

  172.         for (int n = 0; n < length; n++) {
  173.             final Object value = unboxed[n];

  175.             if (value instanceof Integer) {
  176.                 boxed[n] = (long) (int) unboxed[n];
  177.             } else if (value instanceof Long) {
  178.                 boxed[n] = (long) unboxed[n];
  179.             }
  180.         }

  182.         return boxed;
  183.     }

  185.     public static double[] unboxDouble(Object[] unboxed, int length) {
  186.         CompilerAsserts.neverPartOfCompilation();

  188.         final double[] boxed = new double[length];

  190.         for (int n = 0; n < length; n++) {
  191.             boxed[n] = (double) unboxed[n];
  192.         }

  194.         return boxed;
  195.     }

  197.     public static void copy(Object source, Object[] destination, int destinationStart, int length) {
  198.         RubyNode.notDesignedForCompilation();

  200.         if (length == 0) {
  201.             return;
  202.         }

  204.         if (source instanceof int[]) {
  205.             final int[] unboxedSource = (int[]) source;

  207.             for (int n = 0; n < length; n++) {
  208.                 destination[destinationStart + n] = unboxedSource[n];
  209.             }
  210.         } else if (source instanceof long[]) {
  211.             final long[] unboxedSource = (long[]) source;

  213.             for (int n = 0; n < length; n++) {
  214.                 destination[destinationStart + n] = unboxedSource[n];
  215.             }
  216.         } else if (source instanceof double[]) {
  217.             final double[] unboxedSource = (double[]) source;

  219.             for (int n = 0; n < length; n++) {
  220.                 destination[destinationStart + n] = unboxedSource[n];
  221.             }
  222.         } else if (source instanceof Object[]) {
  223.             RubyArguments.arraycopy((Object[]) source, 0, destination, destinationStart, length);
  224.         } else {
  225.             throw new UnsupportedOperationException();
  226.         }
  227.     }

  229.     public static long[] longCopyOf(int[] ints) {
  230.         final long[] longs = new long[ints.length];

  232.         for (int n = 0; n < ints.length; n++) {
  233.             longs[n] = ints[n];
  234.         }

  236.         return longs;
  237.     }

  239.     public static int capacity(int current, int needed) {
  240.         if (needed < 16) {
  241.             return 16;
  242.         } else {
  243.             int capacity = current;

  245.             while (capacity < needed) {
  246.                 capacity *= 2;
  247.             }

  249.             return capacity;
  250.         }
  251.     }

  253. }
Created with JaCoCo 0.7.3.201501050207