Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.java.util;
  
  import org.jruby.Ruby;
A collection of utilities for manipulating Java arrays.
 
 public class ArrayUtils {
     public static IRubyObject arefDirect(Ruby runtimeObject arrayJavaUtil.JavaConverter javaConverterint intIndex) {
         try {
             return JavaUtil.convertJavaArrayElementToRuby(runtimejavaConverterarrayintIndex);
         } catch (IndexOutOfBoundsException e) {
             throw runtime.newArgumentError(
                     "index out of bounds for java array (" + intIndex +
                             " for length " + Array.getLength(array) + ")");
         }
     }
 
     public static IRubyObject concatArraysDirect(ThreadContext contextObject originalObject additional) {
         int oldLength = Array.getLength(original);
         int addLength = Array.getLength(additional);
 
         ArrayJavaProxy proxy = newProxiedArray(context.runtimeoriginal.getClass().getComponentType(), oldLength + addLength);
         Object newArray = proxy.getObject();
 
         System.arraycopy(original, 0, newArray, 0, oldLength);
         System.arraycopy(additional, 0, newArrayoldLengthaddLength);
 
         return proxy;
     }
 
     public static ArrayJavaProxy newProxiedArray(Ruby runtimeClass<?> componentTypeint size) {
         return newProxiedArray(runtimecomponentType, JavaUtil.getJavaConverter(componentType), size);
     }
 
     public static ArrayJavaProxy newProxiedArray(Ruby runtimeClass<?> componentTypeJavaUtil.JavaConverter converterint size) {
         final Object array = Array.newInstance(componentTypesize);
         RubyClass proxyClass = JavaClass.get(runtimearray.getClass()).getProxyClass();
         return new ArrayJavaProxy(runtimeproxyClassarrayconverter);
     }
 
     public static IRubyObject emptyJavaArrayDirect(ThreadContext contextClass componentType) {
         Ruby runtime = context.runtime;
         return newProxiedArray(runtimecomponentType, 0);
     }
 
     public static IRubyObject javaArraySubarrayDirect(ThreadContext contextObject fromArrayint indexint size) {
         int actualLength = Array.getLength(fromArray);
         if (index >= actualLength) {
             return context.runtime.getNil();
         } else {
             if (index + size > actualLength) {
                 size = actualLength - index;
             }
 
             ArrayJavaProxy proxy = ArrayUtils.newProxiedArray(context.runtimefromArray.getClass().getComponentType(), size);
             Object newArray = proxy.getObject();
             System.arraycopy(fromArrayindexnewArray, 0, size);
 
             return proxy;
         }
     }
 
     public static IRubyObject concatArraysDirect(ThreadContext contextObject originalIRubyObject additional) {
         Ruby runtime = context.runtime;
         int oldLength = Array.getLength(original);
         int addLength = (int)((RubyFixnum) Helpers.invoke(contextadditional"length")).getLongValue();
 
         ArrayJavaProxy proxy = ArrayUtils.newProxiedArray(runtimeoriginal.getClass().getComponentType(), oldLength + addLength);
         Object newArray = proxy.getObject();
 
         System.arraycopy(original, 0, newArray, 0, oldLength);
 
         for (int i = 0; i < addLengthi++) {
             Helpers.invoke(contextproxy"[]="runtime.newFixnum(oldLength + i),
                     Helpers.invoke(contextadditional"[]"runtime.newFixnum(i)));
         }
 
         return proxy;
     }
 
     public static IRubyObject asetDirect(Ruby runtimeObject arrayJavaUtil.JavaConverter javaConverterint intIndexIRubyObject value) {
         try {
             javaConverter.set(runtimearrayintIndexvalue);
         } catch (IndexOutOfBoundsException e) {
             throw runtime.newArgumentError(
                     "index out of bounds for java array (" + intIndex +
                             " for length " + Array.getLength(array) + ")");
        } catch (ArrayStoreException e) {
            throw runtime.newTypeError(
                    "wrong element type " + value.getClass() + "(array contains " +
                            array.getClass().getComponentType().getName() + ")");
        } catch (IllegalArgumentException iae) {
            throw runtime.newArgumentError(
                    "wrong element type " + value.getClass() + "(array contains " +
                            array.getClass().getComponentType().getName() + ")");
        }
        return value;
    }
    public static void setWithExceptionHandlingDirect(Ruby runtimeObject aryint intIndexObject javaObject) {
        try {
            Array.set(aryintIndexjavaObject);
        } catch (IndexOutOfBoundsException e) {
            throw runtime.newArgumentError(
                                    "index out of bounds for java array (" + intIndex +
                                    " for length " + Array.getLength(ary) + ")");
        } catch (ArrayStoreException e) {
            throw runtime.newTypeError(
                                    "wrong element type " + javaObject.getClass() + "(array contains " +
                                    ary.getClass().getComponentType().getName() + ")");
        } catch (IllegalArgumentException iae) {
            throw runtime.newArgumentError(
                                    "wrong element type " + javaObject.getClass() + "(array contains " +
                                    ary.getClass().getComponentType().getName() + ")");
        }
    }
    public static void copyDataToJavaArrayDirect(
            ThreadContext contextRubyArray rubyArrayObject javaArray) {
        int javaLength = Array.getLength(javaArray);
        Class targetType = javaArray.getClass().getComponentType();
        int rubyLength = rubyArray.getLength();
        int i = 0;
        for (; i < rubyLength && i < javaLengthi++) {
            Array.set(javaArrayirubyArray.entry(i).toJava(targetType));
        }
    }
    public static void copyDataToJavaArray(
            ThreadContext contextRubyArray rubyArrayint srcJavaArray javaArrayint destint length) {
        Class targetType = javaArray.getComponentType();
        int destLength = (int)javaArray.length().getLongValue();
        int srcLength = rubyArray.getLength();
        for (int i = 0; src + i < srcLength && dest + i < destLength && i < lengthi++) {
            javaArray.setWithExceptionHandling(dest + irubyArray.entry(src + i).toJava(targetType));
        }
    }
New to GrepCode? Check out our FAQ X