@Override @JRubyMethod(name = "clone") public IRubyObject rbClone() { final Ruby runtime = getRuntime(); RubyObject clone = new ArrayJavaProxy(runtime, getMetaClass(), cloneObject(), converter); clone.setMetaClass(getSingletonClassClone()); if (isTaint()) clone.setTaint(true); initCopy(clone, this, "initialize_clone"); if (isFrozen()) clone.setFrozen(true); return clone; }
public JavaArray getJavaArray() { JavaArray javaArray = (JavaArray)dataGetStruct(); if (javaArray == null) { javaArray = new JavaArray(getRuntime(), getObject()); dataWrapStruct(javaArray); } return javaArray; }
@Override public boolean equals(Object obj) { if ( obj instanceof ArrayJavaProxy ) { final ArrayJavaProxy that = (ArrayJavaProxy) obj; final Object thisArray = this.getObject(); final Object thatArray = that.getObject(); return arraysEquals(thisArray, thatArray); } return false; }
@Override public IRubyObject dup() { final Ruby runtime = getRuntime(); RubyObject dup = new ArrayJavaProxy(runtime, getMetaClass(), cloneObject(), converter); if (isTaint()) dup.setTaint(true); initCopy(dup, this, "initialize_dup"); return dup; }
@JRubyMethod(name = "+") public IRubyObject op_plus(ThreadContext context, IRubyObject other) { if (other instanceof ArrayJavaProxy) { Object otherArray = ((ArrayJavaProxy)other).getObject(); if (getObject().getClass().getComponentType().isAssignableFrom(otherArray.getClass().getComponentType())) { return ArrayUtils.concatArraysDirect(context, getObject(), otherArray); } } return ArrayUtils.concatArraysDirect(context, getObject(), other); }
public static ArrayJavaProxy newProxiedArray(Ruby runtime, Class<?> componentType, JavaUtil.JavaConverter converter, int size) { final Object array = Array.newInstance(componentType, size); RubyClass proxyClass = JavaClass.get(runtime, array.getClass()).getProxyClass(); return new ArrayJavaProxy(runtime, proxyClass, array, converter); }
@JRubyMethod(name = "[]", required = 1, rest = true) public IRubyObject op_aref(ThreadContext context, IRubyObject[] args) { if (args.length == 1 && args[0] instanceof RubyInteger) { int index = (int)((RubyInteger)args[0]).getLongValue(); return ArrayUtils.arefDirect(context.runtime, getObject(), converter, index); } else { return getRange(context, args); } }
private StringBuilder arrayToString() { final StringBuilder buffer = new StringBuilder(24); Class<?> componentClass = getObject().getClass().getComponentType(); switch (componentClass.getName().charAt(0)) { case 'b': if (componentClass == byte.class) buffer.append(Arrays.toString((byte[])getObject())); else /* if (componentClass == boolean.class) */ buffer.append(Arrays.toString((boolean[])getObject())); break; case 's': /* if (componentClass == short.class) */ buffer.append(Arrays.toString((short[])getObject())); break; case 'c': /* if (componentClass == char.class) */ buffer.append(Arrays.toString((char[])getObject())); break; case 'i': /* if (componentClass == int.class) */ buffer.append(Arrays.toString((int[])getObject())); break; case 'l': /* if (componentClass == long.class) */ buffer.append(Arrays.toString((long[])getObject())); break; case 'f': /* if (componentClass == float.class) */ buffer.append(Arrays.toString((float[])getObject())); break; case 'd': /* if (componentClass == double.class) */ buffer.append(Arrays.toString((double[])getObject())); break; buffer.append(Arrays.toString((Object[]) getObject()));
@JRubyMethod(name = "[]") public final IRubyObject op_aref(ThreadContext context, IRubyObject arg) { if ( arg instanceof RubyRange ) return arrayRange(context, (RubyRange) arg); final int i = convertArrayIndex(arg); return ArrayUtils.arefDirect(context.runtime, getObject(), converter, i); }
@Override @JRubyMethod public RubyFixnum hash() { return getRuntime().newFixnum( hashCode() ); }
public static IRubyObject concatArraysDirect(ThreadContext context, Object original, IRubyObject additional) { final Ruby runtime = context.runtime; final int oldLength = Array.getLength(original); final int addLength = RubyFixnum.fix2int(Helpers.invoke(context, additional, "length")); ArrayJavaProxy proxy = ArrayUtils.newProxiedArray(runtime, original.getClass().getComponentType(), oldLength + addLength); System.arraycopy(original, 0, proxy.getObject(), 0, oldLength); for (int i = 0; i < addLength; i++) { IRubyObject val = Helpers.invoke(context, additional, "[]", runtime.newFixnum(i)); proxy.setValue(runtime, oldLength + i, val); // [ oldLen + i ] = val } return proxy; }
@JRubyMethod(name = "count") // @override Enumerable#count public IRubyObject count(final ThreadContext context, final Block block) { final Ruby runtime = context.runtime; if ( block.isGiven() ) { final Object array = getObject(); int count = 0; for ( int i = 0; i < Array.getLength(array); i++ ) { IRubyObject next = JavaUtil.convertJavaArrayElementToRuby(runtime, converter, array, i); if ( block.yield( context, next ).isTrue() ) count++; } return RubyFixnum.newFixnum(runtime, count); } return RubyFixnum.newFixnum(runtime, length()); }
@JRubyMethod(module = true) public static IRubyObject java_to_ruby(ThreadContext context, IRubyObject recv, IRubyObject ary) { if (!(ary instanceof ArrayJavaProxy)) { throw context.runtime.newTypeError(ary, context.runtime.getJavaSupport().getArrayProxyClass()); } return ((ArrayJavaProxy)ary).to_a(context); }
ConcreteJavaProxy.createConcreteJavaProxy(context); InterfaceJavaProxy.createInterfaceJavaProxy(context); ArrayJavaProxy.createArrayJavaProxy(context);
public final JavaArray getJavaArray() { return (JavaArray) dataGetStruct(); }
protected JavaArray asJavaObject(final Object array) { return new JavaArray(getRuntime(), array); }
public IRubyObject getRange(ThreadContext context, IRubyObject first, IRubyObject length) { return arrayRange(context, first, length); }
@Override public String toString() { return arrayToString().toString(); }