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 ary) {
         this(runtimeklazzary, JavaUtil.getJavaConverter(ary.getClass().getComponentType()));
     }
     
     public ArrayJavaProxy(Ruby runtimeRubyClass klazzObject aryJavaUtil.JavaConverter converter) {
         super(runtimeklazzary);
         this. = converter;
     }
     
     public static RubyClass createArrayJavaProxy(ThreadContext context) {
         Ruby runtime = context.runtime;
         
         RubyClass arrayJavaProxy = runtime.defineClass("ArrayJavaProxy",
                 runtime.getJavaSupport().getJavaProxyClass(),
                 .);
         
         RubyClass singleton = arrayJavaProxy.getSingletonClass();
         
         final DynamicMethod oldNew = singleton.searchMethod("new");
         
         singleton.addMethod("new"new ArrayNewMethod(singleton.oldNew));
         
         arrayJavaProxy.defineAnnotatedMethods(ArrayJavaProxy.class);
         arrayJavaProxy.includeModule(runtime.getEnumerable());
         
         return arrayJavaProxy;
     }
     
     public JavaArray getJavaArray() {
         JavaArray javaArray = (JavaArray)dataGetStruct();
         
         if (javaArray == null) {
             javaArray = new JavaArray(getRuntime(), getObject());
             dataWrapStruct(javaArray);
         }
         
         return javaArray;
     }
     
     @JRubyMethod(name = {"length","size"})
     public IRubyObject length(ThreadContext context) {
         return context.runtime.newFixnum(Array.getLength(this.getObject()));
     }
 
     @JRubyMethod(name = "empty?")
     public IRubyObject empty(ThreadContext context) {
         return context.runtime.newBoolean(Array.getLength(this.getObject()) == 0);
     }
     
     @JRubyMethod(name = "[]")
     public IRubyObject op_aref(ThreadContext contextIRubyObject arg) {
         if (arg instanceof RubyInteger) {
             int index = (int)((RubyInteger)arg).getLongValue();
             return ArrayUtils.arefDirect(context.runtimegetObject(), index);
         } else {
             return getRange(contextarg);
         }
     }
 
     @JRubyMethod(name = "[]", required = 1, rest = true)
     public IRubyObject op_aref(ThreadContext contextIRubyObject[] args) {
         if (args.length == 1 && args[0] instanceof RubyInteger) {
             int index = (int)((RubyInteger)args[0]).getLongValue();
             return ArrayUtils.arefDirect(context.runtimegetObject(), index);
         } else {
             return getRange(contextargs);
         }
     }
     
     @JRubyMethod(name = "[]=")
     public IRubyObject op_aset(ThreadContext contextIRubyObject indexIRubyObject value) {
         ArrayUtils.asetDirect(context.runtimegetObject(), , (int)((RubyInteger)index).getLongValue(), value);
         return value;
     }
    
    public IRubyObject at(ThreadContext contextIRubyObject indexObj) {
        Ruby runtime = context.runtime;
        Object array = getObject();
        int length = Array.getLength(array);
        long index = indexObj.convertToInteger().getLongValue();
        
        if (index < 0) {
            index = index + length;
        }
        
        if (index >= 0 && index < length) {
            return ArrayUtils.arefDirect(runtimearray, (int)index);
        } else {
            return context.nil;
        }
    }
    
    @JRubyMethod(name = "+")
    public IRubyObject op_plus(ThreadContext contextIRubyObject other) {
        if (other instanceof ArrayJavaProxy) {
            Object otherArray = ((ArrayJavaProxy)other).getObject();
            
            if (getObject().getClass().getComponentType().isAssignableFrom(otherArray.getClass().getComponentType())) {
                return ArrayUtils.concatArraysDirect(contextgetObject(), otherArray);
            }
        }
        return ArrayUtils.concatArraysDirect(contextgetObject(), other);
    }
    
    public IRubyObject each(ThreadContext contextBlock block) {
        Ruby runtime = context.runtime;
        int length = Array.getLength(getObject());
        for (int i = 0; i < lengthi++) {
            IRubyObject rubyObj = ArrayUtils.arefDirect(runtimegetObject(), i);
            block.yield(contextrubyObj);
        }
        return this;
    }
    
    @JRubyMethod(name = {"to_a","to_ary"})
    public IRubyObject to_a(ThreadContext context) {
        return JavaUtil.convertJavaArrayToRubyWithNesting(contextthis.getObject());
    }
    
    public IRubyObject inspect(ThreadContext context) {
        StringBuffer buffer = new StringBuffer();
        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 context.runtime.newString(buffer.toString());        
    }
    
    public IRubyObject getRange(ThreadContext contextIRubyObject[] args) {
        if (args.length == 1) {
            return getRange(contextargs[0]);
        } else if (args.length == 2) {
            return getRange(contextargs[0], args[1]);
        } else {
            throw context.runtime.newArgumentError(args.length, 1);
        }
    }
    
    public IRubyObject getRange(ThreadContext contextIRubyObject arg0) {
        int length = Array.getLength(getObject());
        
        if (arg0 instanceof RubyRange) {
            RubyRange range = (RubyRange)arg0;
            if (range.first() instanceof RubyFixnum && range.last() instanceof RubyFixnum) {
                int first = (int)((RubyFixnum)range.first()).getLongValue();
                int last = (int)((RubyFixnum)range.last()).getLongValue();
                
                first = first >= 0 ? first : length + first;
                last = last >= 0 ? last : length + last;
                int newLength = last - first;
                if (range.exclude_end_p().isFalse()) newLength += 1;
                
                if (newLength <= 0) {
                    return ArrayUtils.emptyJavaArrayDirect(contextgetObject().getClass().getComponentType());
                }
        
                return ArrayUtils.javaArraySubarrayDirect(contextgetObject(), firstnewLength);
            } else {
                throw context.runtime.newTypeError("only Fixnum ranges supported");
            }
        } else {
            throw context.runtime.newTypeError(arg0context.runtime.getRange());
        }
    }
    
    public IRubyObject getRange(ThreadContext contextIRubyObject firstObjIRubyObject lengthObj) {
        if (firstObj instanceof RubyFixnum && lengthObj instanceof RubyFixnum) {
            int first = (int)((RubyFixnum)firstObj).getLongValue();
            int length = (int)((RubyFixnum)lengthObj).getLongValue();
            if (length > Array.getLength(getObject())) {
                throw context.runtime.newIndexError("length specifed is longer than array");
            }
            first = first >= 0 ? first : Array.getLength(getObject()) + first;
            if (length <= 0) {
                return ArrayUtils.emptyJavaArrayDirect(contextgetObject().getClass().getComponentType());
            }
            return ArrayUtils.javaArraySubarrayDirect(contextgetObject(), firstlength);
        } else {
            throw context.runtime.newTypeError("only Fixnum ranges supported");
        }
    }
    
    public static class ArrayNewMethod extends org.jruby.internal.runtime.methods.JavaMethod.JavaMethodOne {
        private DynamicMethod oldNew;
        
        public ArrayNewMethod(RubyModule implClassVisibility visibilityDynamicMethod oldNew) {
            super(implClassvisibility);
            this. = oldNew;
        }
        
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0) {
            Ruby runtime = context.runtime;
            IRubyObject proxy = .call(contextselfclazz"new_proxy");
            
            if (arg0 instanceof JavaArray) {
                proxy.dataWrapStruct(arg0);
                return proxy;
            } else {
                throw runtime.newTypeError(arg0runtime.getJavaSupport().getJavaArrayClass());
            }
        }
    }
New to GrepCode? Check out our FAQ X