Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.java.proxies;
  
  import java.util.Arrays;
  import org.jruby.Ruby;
 
 public class ArrayJavaProxy extends JavaProxy {
 
     private final JavaUtil.JavaConverter converter;
 
     public ArrayJavaProxy(Ruby runtimeRubyClass klazzObject array) {
         this(runtimeklazzarray, JavaUtil.getJavaConverter(array.getClass().getComponentType()));
     }
 
     public ArrayJavaProxy(Ruby runtimeRubyClass klazzObject arrayJavaUtil.JavaConverter converter) {
         super(runtimeklazzarray);
         this. = converter;
     }
 
     public static RubyClass createArrayJavaProxy(ThreadContext context) {
         Ruby runtime = context.runtime;
 
         RubyClass arrayJavaProxy = runtime.defineClass("ArrayJavaProxy",
                 runtime.getJavaSupport().getJavaProxyClass(),
                 .);
 
         RubyClass singleton = arrayJavaProxy.getSingletonClass();
         singleton.addMethod("new"new ArrayNewMethod(singleton.));
 
         arrayJavaProxy.defineAnnotatedMethods(ArrayJavaProxy.class);
         arrayJavaProxy.includeModule(runtime.getEnumerable());
 
         return arrayJavaProxy;
     }
 
     static ArrayJavaProxy newArray(final Ruby runtimefinal Class<?> elementTypefinal int... dimensions) {
         final Object array;
         try {
             array = Array.newInstance(elementTypedimensions);
         }
         catch (IllegalArgumentException e) {
             throw runtime.newArgumentError("can not create " + dimensions.length + " dimensional array");
         }
         return new ArrayJavaProxy(runtime, Java.getProxyClassForObject(runtimearray), array);
     }
 
     public JavaArray getJavaArray() {
         JavaArray javaArray = (JavaArraydataGetStruct();
 
         if (javaArray == null) {
             javaArray = new JavaArray(getRuntime(), getObject());
             dataWrapStruct(javaArray);
         }
 
         return javaArray;
     }
 
     @JRubyMethod(name = {"length""size"})
     public RubyFixnum length(ThreadContext context) {
         return context.runtime.newFixnum( Array.getLengthgetObject() ) );
     }
 
     @JRubyMethod(name = "empty?")
     public RubyBoolean empty_p(ThreadContext context) {
         return context.runtime.newBoolean( Array.getLengthgetObject() ) == 0 );
     }
 
     @JRubyMethod(name = "[]")
     public IRubyObject op_aref(ThreadContext contextIRubyObject arg) {
         if ( arg instanceof RubyRange ) return arrayRange(context, (RubyRangearg);
         final int i = convertArrayIndex(arg);
         return ArrayUtils.arefDirect(context.runtimegetObject(), i);
     }
 
     @JRubyMethod(name = "[]", required = 1, rest = true)
     public IRubyObject op_aref(ThreadContext contextIRubyObject[] args) {
         if ( args.length == 1 ) return op_aref(contextargs[0]);
         return getRange(contextargs);
     }
    @JRubyMethod(name = "[]=")
    public IRubyObject op_aset(ThreadContext contextIRubyObject indexIRubyObject value) {
        final int i = convertArrayIndex(index);
        return ArrayUtils.asetDirect(context.runtimegetObject(), ivalue);
    }
    private static int convertArrayIndex(final IRubyObject index) {
        if ( index instanceof RubyInteger ) {
            return (int) ((RubyIntegerindex).getLongValue();
        }
        if ( index instanceof JavaProxy ) {
            return (Integerindex.toJava(Integer.class);
        }
        return (intindex.convertToInteger().getLongValue();
    }
    public IRubyObject at(ThreadContext contextIRubyObject index) {
        final Ruby runtime = context.runtime;
        final Object array = getObject();
        final int length = Array.getLength(array);
        int i = convertArrayIndex(index);
        if ( i < 0 ) i = i + length;
        if ( i >= 0 && i < length ) {
            return ArrayUtils.arefDirect(runtimearrayi);
        }
        return context.nil;
    }
    @JRubyMethod(name = "+")
    public IRubyObject op_plus(ThreadContext contextIRubyObject other) {
        final Object array = getObject();
        if ( other instanceof ArrayJavaProxy ) {
            final Object otherArray = ((ArrayJavaProxyother).getObject();
            final Class<?> componentType = array.getClass().getComponentType();
            if ( componentType.isAssignableFromotherArray.getClass().getComponentType() ) ) {
                return ArrayUtils.concatArraysDirect(contextarrayotherArray);
            }
        }
        return ArrayUtils.concatArraysDirect(contextarrayother);
    }
    public IRubyObject each(ThreadContext contextBlock block) {
        final Ruby runtime = context.runtime;
        final Object array = getObject();
        final int length = Array.getLength(array);
        for ( int i = 0; i < lengthi++ ) {
            IRubyObject element = ArrayUtils.arefDirect(runtimearrayi);
            block.yield(contextelement);
        }
        return this;
    }
    @JRubyMethod(name = {"to_a""to_ary"})
    public RubyArray to_a(ThreadContext context) {
        final Object array = getObject();
        return JavaUtil.convertJavaArrayToRubyWithNesting(contextarray);
    }
    @JRubyMethod(name = {"component_type"})
    public IRubyObject component_type(ThreadContext context) {
        Class<?> componentType = getObject().getClass().getComponentType();
        final JavaClass javaClass = JavaClass.get(context.runtimecomponentType);
        return Java.getProxyClass(context.runtimejavaClass);
    }
    public RubyString inspect(ThreadContext context) {
        final StringBuilder buffer = new StringBuilder();
        Class<?> componentClass = getObject().getClass().getComponentType();
        buffer.append(componentClass.getName());
        if (componentClass.isPrimitive()) {
            switch (componentClass.getName().charAt(0)) {
                case 'b':
                    if (componentClass == byte.classbuffer.append(Arrays.toString((byte[])getObject()));
                    if (componentClass == boolean.classbuffer.append(Arrays.toString((boolean[])getObject()));
                    break;
                case 's':
                    if (componentClass == short.classbuffer.append(Arrays.toString((short[])getObject()));
                    break;
                case 'c':
                    if (componentClass == char.classbuffer.append(Arrays.toString((char[])getObject()));
                    break;
                case 'i':
                    if (componentClass == int.classbuffer.append(Arrays.toString((int[])getObject()));
                    break;
                case 'l':
                    if (componentClass == long.classbuffer.append(Arrays.toString((long[])getObject()));
                    break;
                case 'f':
                    if (componentClass == float.classbuffer.append(Arrays.toString((float[])getObject()));
                    break;
                case 'd':
                    if (componentClass == double.classbuffer.append(Arrays.toString((double[])getObject()));
                    break;
            }
        } else {
            buffer.append(Arrays.toString((Object[]) getObject()));
        }
        buffer.append('@').append(Integer.toHexString(inspectHashCode()));
        return RubyString.newString(context.runtimebuffer.toString());
    }
    @JRubyMethod(name = "==")
    @Override
    public RubyBoolean op_eqq(ThreadContext contextIRubyObject other) {
        return eql_p(contextother);
    }
    @JRubyMethod(name = "eql?")
    public RubyBoolean eql_p(ThreadContext contextIRubyObject obj) {
        boolean equals = false;
        if ( obj instanceof ArrayJavaProxy ) {
            final ArrayJavaProxy that = (ArrayJavaProxyobj;
            equals = arraysEquals(this.getObject(), that.getObject());
        }
        if ( obj.getClass().isArray() ) {
            equals = arraysEquals(getObject(), obj);
        }
        return context.runtime.newBoolean(equals);
    }
    @Override
    public boolean equals(Object obj) {
        if ( obj instanceof ArrayJavaProxy ) {
            final ArrayJavaProxy that = (ArrayJavaProxyobj;
            final Object thisArray = this.getObject();
            final Object thatArray = that.getObject();
            return arraysEquals(thisArraythatArray);
        }
        return false;
    }
    private static boolean arraysEquals(final Object thisArrayfinal Object thatArray) {
        final Class<?> componentType = thisArray.getClass().getComponentType();
        if ( ! componentType.equals(thatArray.getClass().getComponentType()) ) {
            return false;
        }
        if ( componentType.isPrimitive() ) {
            switch ( componentType.getName().charAt(0) ) {
                case 'b':
                    if (componentType == byte.classreturn Arrays.equals((byte[]) thisArray, (byte[]) thatArray);
                    if (componentType == boolean.classreturn Arrays.equals((boolean[]) thisArray, (boolean[]) thatArray);
                case 's':
                    if (componentType == short.classreturn Arrays.equals((short[]) thisArray, (short[]) thatArray);
                case 'c':
                    if (componentType == char.classreturn Arrays.equals((char[]) thisArray, (char[]) thatArray);
                case 'i':
                    if (componentType == int.classreturn Arrays.equals((int[]) thisArray, (int[]) thatArray);
                case 'l':
                    if (componentType == long.classreturn Arrays.equals((long[]) thisArray, (long[]) thatArray);
                case 'f':
                    if (componentType == float.classreturn Arrays.equals((float[]) thisArray, (float[]) thatArray);
                case 'd':
                    if (componentType == double.classreturn Arrays.equals((double[]) thisArray, (double[]) thatArray);
            }
        }
        return Arrays.equals((Object[]) thisArray, (Object[]) thatArray);
    }
    @Override
    public RubyFixnum hash() {
        return getRuntime().newFixnumhashCode() );
    }
    @Override
    public int hashCode() {
        final Object array = getObject();
        final Class<?> componentType = array.getClass().getComponentType();
        if ( componentType.isPrimitive() ) {
            switch ( componentType.getName().charAt(0) ) {
                case 'b':
                    if (componentType == byte.classreturn 11 * Arrays.hashCode((byte[]) array);
                    if (componentType == boolean.classreturn 11 * Arrays.hashCode((boolean[]) array);
                case 's':
                    if (componentType == short.classreturn 11 * Arrays.hashCode((short[]) array);
                case 'c':
                    if (componentType == char.classreturn 11 * Arrays.hashCode((char[]) array);
                case 'i':
                    if (componentType == int.classreturn 11 * Arrays.hashCode((int[]) array);
                case 'l':
                    if (componentType == long.classreturn 11 * Arrays.hashCode((long[]) array);
                case 'f':
                    if (componentType == float.classreturn 11 * Arrays.hashCode((float[]) array);
                case 'd':
                    if (componentType == double.classreturn 11 * Arrays.hashCode((double[]) array);
            }
        }
        return 11 * Arrays.hashCode((Object[]) array);
    }
    public IRubyObject getRange(ThreadContext contextIRubyObject[] args) {
        if (args.length == 1) {
            return getRange(contextargs[0]);
        }
        if (args.length == 2) {
            return getRange(contextargs[0], args[1]);
        }
        throw context.runtime.newArgumentError(args.length, 1);
    }
    public IRubyObject getRange(ThreadContext contextIRubyObject arg0) {
        if ( arg0 instanceof RubyRange ) {
            return arrayRange(context, (RubyRangearg0);
        }
        throw context.runtime.newTypeError(arg0context.runtime.getRange());
    }
    private IRubyObject arrayRange(final ThreadContext contextfinal RubyRange range) {
        final Object array = getObject();
        final int arrayLength = Array.getLengtharray );
        final IRubyObject rFirst = range.first();
        final IRubyObject rLast = range.last();
        if ( rFirst instanceof RubyFixnum && rLast instanceof RubyFixnum ) {
            int first = (int) ((RubyFixnumrFirst).getLongValue();
            int last = (int) ((RubyFixnumrLast).getLongValue();
            first = first >= 0 ? first : arrayLength + first;
            last = last >= 0 ? last : arrayLength + last;
            int newLength = last - first;
            if ( range.exclude_end_p().isFalse() ) newLength += 1;
            if ( newLength <= 0 ) {
                return ArrayUtils.emptyJavaArrayDirect(contextarray.getClass().getComponentType());
            }
            return ArrayUtils.javaArraySubarrayDirect(contextarrayfirstnewLength);
        }
        throw context.runtime.newTypeError("only Fixnum ranges supported");
    }
    public IRubyObject getRange(ThreadContext contextIRubyObject firstIRubyObject length) {
        return arrayRange(contextfirstlength);
    }
    private IRubyObject arrayRange(final ThreadContext context,
        final IRubyObject rFirstfinal IRubyObject rLength) {
        final Object array = getObject();
        final int arrayLength = Array.getLengtharray );
        if ( rFirst instanceof RubyFixnum && rLength instanceof RubyFixnum ) {
            int first = (int) ((RubyFixnumrFirst).getLongValue();
            int length = (int) ((RubyFixnumrLength).getLongValue();
            if ( length > arrayLength ) {
                throw context.runtime.newIndexError("length specifed is longer than array");
            }
            if ( length <= 0 ) {
                return ArrayUtils.emptyJavaArrayDirect(contextarray.getClass().getComponentType());
            }
            first = first >= 0 ? first : arrayLength + first;
            return ArrayUtils.javaArraySubarrayDirect(contextarrayfirstlength);
        }
        throw context.runtime.newTypeError("only Fixnum ranges supported");
    }
    public static class ArrayNewMethod extends org.jruby.internal.runtime.methods.JavaMethod.JavaMethodOne {
        private final DynamicMethod newMethod;
        ArrayNewMethod(RubyModule implClassVisibility visibility) {
            this(implClassvisibilityimplClass.searchMethod("new"));
        }
        public ArrayNewMethod(RubyModule implClassVisibility visibilityDynamicMethod oldNew) {
            super(implClassvisibility);
            this. = oldNew;
        }
        @Override
        public final IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0) {
            final Ruby runtime = context.runtime;
            if ( ! ( arg0 instanceof JavaArray ) ) {
                throw runtime.newTypeError(arg0runtime.getJavaSupport().getJavaArrayClass());
            }
            IRubyObject proxy = .call(contextselfclazz"new_proxy");
            proxy.dataWrapStruct(arg0);
            return proxy;
        }
    }
New to GrepCode? Check out our FAQ X