protected IRubyObject get(int index) { return this.storage.eltInternal(index); }
@JRubyMethod(name = {"to_h", "to_hash"}) public IRubyObject toHash(ThreadContext context) { Ruby runtime = context.runtime; RubyHash ret = RubyHash.newHash(runtime); for (Descriptors.FieldDescriptor fdef : this.descriptor.getFields()) { IRubyObject value = getField(context, fdef); if (!value.isNil()) { if (fdef.isRepeated() && !fdef.isMapField()) { if (fdef.getType() != Descriptors.FieldDescriptor.Type.MESSAGE) { value = Helpers.invoke(context, value, "to_a"); } else { RubyArray ary = value.convertToArray(); for (int i = 0; i < ary.size(); i++) { IRubyObject submsg = Helpers.invoke(context, ary.eltInternal(i), "to_h"); ary.eltInternalSet(i, submsg); } value = ary.to_ary(); } } else if (value.respondsTo("to_h")) { value = Helpers.invoke(context, value, "to_h"); } else if (value.respondsTo("to_a")) { value = Helpers.invoke(context, value, "to_a"); } } ret.fastASet(runtime.newSymbol(fdef.getName()), value); } return ret; }
private void checkArrayElementType(ThreadContext context, RubyArray arr) { for (int i = 0; i < arr.getLength(); i++) { Utils.checkType(context, fieldType, arr.eltInternal(i), (RubyModule) typeClass); } }
@JRubyMethod public IRubyObject dup(ThreadContext context) { RubyRepeatedField dup = new RubyRepeatedField(context.runtime, metaClass, fieldType, typeClass); for (int i = 0; i < this.storage.size(); i++) { dup.push(context, this.storage.eltInternal(i)); } return dup; }
protected RubyRepeatedField deepCopy(ThreadContext context) { RubyRepeatedField copy = new RubyRepeatedField(context.runtime, metaClass, fieldType, typeClass); for (int i = 0; i < size(); i++) { IRubyObject value = storage.eltInternal(i); if (fieldType == Descriptors.FieldDescriptor.Type.MESSAGE) { copy.storage.add(((RubyMessage) value).deepCopy(context)); } else { copy.storage.add(value); } } return copy; }
private RubyRepeatedField rubyToRepeatedField(ThreadContext context, Descriptors.FieldDescriptor fieldDescriptor, IRubyObject value) { RubyArray arr = value.convertToArray(); RubyRepeatedField repeatedField = repeatedFieldForFieldDescriptor(context, fieldDescriptor); RubyClass typeClass = null; if (fieldDescriptor.getType() == Descriptors.FieldDescriptor.Type.MESSAGE) { RubyDescriptor descriptor = (RubyDescriptor) getDescriptorForField(context, fieldDescriptor); typeClass = (RubyClass) descriptor.msgclass(context); } for (int i = 0; i < arr.size(); i++) { IRubyObject row = arr.eltInternal(i); if (row instanceof RubyHash && typeClass != null) { row = (IRubyObject) typeClass.newInstance(context, row, Block.NULL_BLOCK); } repeatedField.push(context, row); } return repeatedField; }
RubyArray arr = ary.convertToArray(); for (int i = 0; i < arr.size(); i++) { this.storage.add(arr.eltInternal(i));
@JRubyMethod(required=1, optional=1, name = {"at", "[]"}) public IRubyObject index(ThreadContext context, IRubyObject[] args) { if (args.length == 1){ IRubyObject arg = args[0]; if (Utils.isRubyNum(arg)) { /* standard case */ int arrIndex = normalizeArrayIndex(arg); if (arrIndex < 0 || arrIndex >= this.storage.size()) { return context.runtime.getNil(); } return this.storage.eltInternal(arrIndex); } else if (arg instanceof RubyRange) { RubyRange range = ((RubyRange) arg); int beg = RubyNumeric.num2int(range.first(context)); int to = RubyNumeric.num2int(range.last(context)); int len = to - beg + 1; return this.storage.subseq(beg, len); } } /* assume 2 arguments */ int beg = RubyNumeric.num2int(args[0]); int len = RubyNumeric.num2int(args[1]); if (beg < 0) { beg += this.storage.size(); } if (beg >= this.storage.size()) { return context.runtime.getNil(); } return this.storage.subseq(beg, len); }
public Object[] toArray() { // no catch for ArrayIndexOutOfBounds here because this impls a List method Object[] array = new Object[realLength]; for (int i = 0; i < realLength; i++) { array[i] = eltInternal(i).toJava(Object.class); } return array; }
/** rb_num_coerce_cmp * coercion used for comparisons */ @Deprecated // no longer used protected final IRubyObject coerceCmp(ThreadContext context, String method, IRubyObject other) { RubyArray ary = doCoerce(context, other, false); if (ary == null) { return context.nil; // MRI does it! } return (ary.eltInternal(0)).callMethod(context, method, ary.eltInternal(1)); }
public int lastIndexOf(Object element) { if (element != null) { IRubyObject convertedElement = JavaUtil.convertJavaToUsableRubyObject(getRuntime(), element); for (int i = realLength - 1; i >= 0; i--) { if (convertedElement.equals(eltInternal(i))) { return i; } } } return -1; }
private static void copyDataToJavaArrayDirect(final Class<?> targetType, final RubyArray rubyArray, final Object[] javaArray) { int length = rubyArray.getLength(); final int javaLength = javaArray.length; if ( javaLength < length ) length = javaLength; for ( int i = 0; i < length; i++ ) { javaArray[i] = rubyArray.eltInternal(i).toJava(targetType); } }
private static void copyDataToJavaArrayDirect(final Class<?> targetType, final RubyArray rubyArray, final byte[] javaArray) { int length = rubyArray.getLength(); final int javaLength = javaArray.length; if ( javaLength < length ) length = javaLength; for ( int i = 0; i < length; i++ ) { javaArray[i] = (Byte) rubyArray.eltInternal(i).toJava(targetType); } }
public T eltOk(long offset) { try { return (T) eltInternal((int)offset); } catch (ArrayIndexOutOfBoundsException ex) { throw concurrentModification(getRuntime(), ex); } }
@Deprecated // not used public static IRubyObject arrayPostOrNilZero(RubyArray array, int pre, int post) { if (pre + post < array.getLength()) { return array.eltInternal(array.getLength() - post + 0); } else if (pre + 0 < array.getLength()) { return array.eltInternal(pre + 0); } else { return array.getRuntime().getNil(); } }
@Deprecated // not used public static IRubyObject arrayEntryOrNil(RubyArray array, int index) { if (index < array.getLength()) { return array.eltInternal(index); } else { return array.getRuntime().getNil(); } }
@Deprecated // not used public static IRubyObject arrayEntryOrNilTwo(RubyArray array) { if (2 < array.getLength()) { return array.eltInternal(2); } else { return array.getRuntime().getNil(); } }
private IRubyObject getByName(String name) { final RubyArray member = __member__(); for ( int i = 0; i < member.getLength(); i++ ) { if ( member.eltInternal(i).asJavaString().equals(name) ) { return values[i]; } } return null; }
@Override public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg) { final RubyArray ifaces = getJavaInterfaces(self); if ( ifaces == null ) return context.nil; for ( int i = 0; i < ifaces.size(); i++ ) { final RubyModule iface = Java.get_interface_module(context.runtime, ifaces.eltInternal(i)); Helpers.invoke(context, iface, "implement", self); } return ifaces; } });
public static void marshalTo(RubyStruct struct, MarshalStream output) throws java.io.IOException { output.registerLinkTarget(struct); output.dumpDefaultObjectHeader('S', struct.getMetaClass()); RubyArray member = __member__(struct.classOf()); output.writeInt(member.size()); for (int i = 0; i < member.size(); i++) { RubySymbol name = (RubySymbol) member.eltInternal(i); output.dumpObject(name); output.dumpObject(struct.values[i]); } }