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 {
     public ArrayJavaProxy(Ruby runtimeRubyClass klazz) {
         super(runtimeklazz);
     }
     
     public static RubyClass createArrayJavaProxy(ThreadContext context) {
         Ruby runtime = context.runtime;
         
         RubyClass arrayJavaProxy = runtime.defineClass("ArrayJavaProxy",
                 runtime.getJavaSupport().getJavaProxyClass(),
                 new ObjectAllocator() {
             public IRubyObject allocate(Ruby runtimeRubyClass klazz) {
                 return new ArrayJavaProxy(runtimeklazz);
             }
         });
         
         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() {
         return (JavaArray)dataGetStruct();
     }
     
     @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 getJavaArray().arefDirect(context.runtimeindex);
         } 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 getJavaArray().arefDirect(context.runtimeindex);
         } else {
             return getRange(contextargs);
         }
     }
     
     @JRubyMethod(name = "[]=")
     public IRubyObject op_aset(ThreadContext contextIRubyObject indexIRubyObject value) {
         getJavaArray().asetDirect(context.runtime, (int)((RubyInteger)index).getLongValue(), value);
         return value;
     }
     
     @JRubyMethod
     public IRubyObject at(ThreadContext contextIRubyObject indexObj) {
         Ruby runtime = context.runtime;
         RubyFixnum lengthF = getJavaArray().length();
         RubyInteger indexI = indexObj.convertToInteger();
         
         if (indexI.getLongValue() < 0) {
             indexI = RubyFixnum.newFixnum(runtimeindexI.getLongValue() + lengthF.getLongValue());
         }
         long index = indexI.getLongValue();
        
        if (index >= 0 && index < lengthF.getLongValue()) {
            return getJavaArray().arefDirect(runtime, (int)indexI.getLongValue());
        } else {
            return context.nil;
        }
    }
    
    @JRubyMethod(name = "+")
    public IRubyObject op_plus(ThreadContext contextIRubyObject other) {
        JavaClass arrayClass = JavaClass.get(context.runtimegetJavaArray().getComponentType());
        if (other instanceof ArrayJavaProxy) {
            JavaArray otherArray = ((ArrayJavaProxy)other).getJavaArray();
            
            if (getJavaArray().getComponentType().isAssignableFrom(otherArray.getComponentType())) {
                return arrayClass.concatArrays(contextgetJavaArray(), otherArray);
            }
        }
        return arrayClass.concatArrays(contextgetJavaArray(), other);
    }
    
    public IRubyObject each(ThreadContext contextBlock block) {
        Ruby runtime = context.runtime;
        int length = (int)getJavaArray().length().getLongValue();
        for (int i = 0; i < lengthi++) {
            IRubyObject rubyObj = getJavaArray().arefDirect(runtimei);
            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();
        JavaArray javaArray = getJavaArray();
        Class componentClass = javaArray.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 = (int)getJavaArray().length().getLongValue();
        JavaClass arrayClass = JavaClass.get(context.runtimegetJavaArray().getComponentType());
        
        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 arrayClass.emptyJavaArray(context);
                }
        
                return arrayClass.javaArraySubarray(contextgetJavaArray(), 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) {
        JavaClass arrayClass = JavaClass.get(context.runtimegetJavaArray().getComponentType());
        
        if (firstObj instanceof RubyFixnum && lengthObj instanceof RubyFixnum) {
            int first = (int)((RubyFixnum)firstObj).getLongValue();
            int length = (int)((RubyFixnum)lengthObj).getLongValue();
            if (length > getJavaArray().length().getLongValue()) {
                throw context.runtime.newIndexError("length specifed is longer than array");
            }
            first = first >= 0 ? first : (int)getJavaArray().length().getLongValue() + first;
            if (length <= 0) {
                return arrayClass.emptyJavaArray(context);
            }
            return arrayClass.javaArraySubarray(contextgetJavaArray(), 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());
            }
        }
    }
    @Deprecated
    public IRubyObject at(int index) {
        return getJavaArray().at(index);
    }
New to GrepCode? Check out our FAQ X