/** * @see RubyArray#newArrayMayCopy(Ruby, IRubyObject[], int, int) */ public static RubyArray newArrayMayCopy(Ruby runtime, IRubyObject[] args, int start) { return newArrayMayCopy(runtime, args, start, args.length - start); }
/** * Package the arguments appropriately depending on how many there are * Corresponds to rb_enum_values_pack in MRI */ static IRubyObject packEnumValues(ThreadContext context, IRubyObject[] args) { switch (args.length) { case 0: return context.nil; case 1: return args[0]; default: return RubyArray.newArrayMayCopy(context.runtime, args); } }
public static IRubyObject constructRestArg(ThreadContext context, Object[] args, RubyHash keywordArguments, int required, int argIndex) { int argsLength = keywordArguments != null ? args.length - 1 : args.length; int remainingArguments = argsLength - required; if (remainingArguments <= 0) return context.runtime.newEmptyArray(); return RubyArray.newArrayMayCopy(context.runtime, (IRubyObject[]) args, argIndex, remainingArguments); }
private static IRubyObject intoStringArray(Ruby runtime, String[] members) { IRubyObject[] arr = new IRubyObject[members.length]; for(int i = 0; i<arr.length; i++) { arr[i] = runtime.newString(members[i]); } return RubyArray.newArrayMayCopy(runtime, arr); }
public static RubyArray createSubarray(IRubyObject[] input, Ruby runtime, int start, int exclude) { int length = input.length - exclude - start; if (length <= 0) { return RubyArray.newEmptyArray(runtime); } else { return RubyArray.newArrayMayCopy(runtime, input, start, length); } }
/** * Package the arguments appropriately depending on how many there are * Corresponds to rb_enum_values_pack in MRI */ private static IRubyObject packEnumValues(Ruby runtime, IRubyObject[] args) { if (args.length < 2) { return args.length == 0 ? runtime.getNil() : args[0]; } // For more than 1 arg, we pack them as an array return RubyArray.newArrayMayCopy(runtime, args); }
private static RubyArray asRubyStringList(Ruby runtime, List<ByteList> dirs) { final int size = dirs.size(); if ( size == 0 ) return RubyArray.newEmptyArray(runtime); IRubyObject[] dirStrings = new IRubyObject[ size ]; for ( int i = 0; i < size; i++ ) { dirStrings[i] = RubyString.newStringNoCopy(runtime, dirs.get(i)); } return RubyArray.newArrayMayCopy(runtime, dirStrings); }
@Override public IRubyObject yield(ThreadContext context, Block block, IRubyObject[] args, IRubyObject self, Block blockArg) { RubyProc.prepareArgs(context, block.type, this, args); return yieldInner(context, RubyArray.newArrayMayCopy(context.runtime, args), blockArg); }
@JRubyMethod(name = { "to_a", "entries" }) public static RubyArray to_a(final ThreadContext context, final IRubyObject self) { final Object[] array = ((java.util.Collection) unwrapIfJavaObject(self)).toArray(); if ( IRubyObject.class.isAssignableFrom(array.getClass().getComponentType()) ) { return RubyArray.newArrayMayCopy(context.runtime, (IRubyObject[]) array); } return RubyArray.newArrayNoCopy(context.runtime, convertJavaArrayToRuby(context.runtime, array)); }
private static IRubyObject constructRestArg(ThreadContext context, IRubyObject[] args, RubyHash keywordArguments, int required, int argIndex) { int argsLength = keywordArguments != null ? args.length - 1 : args.length; if ( required == 0 && argsLength == args.length ) { return RubyArray.newArray(context.runtime, args); } int remainingArguments = argsLength - required; if (remainingArguments <= 0) return context.runtime.newEmptyArray(); return RubyArray.newArrayMayCopy(context.runtime, args, argIndex, remainingArguments); }
@JRubyMethod public RubyArray keys() { IRubyObject[] keys = new IRubyObject[getFiberLocals().size()]; return RubyArray.newArrayMayCopy(getRuntime(), getFiberLocals().keySet().toArray(keys)); }
@JRubyMethod(name = { "to_a", "to_ary" }) public static RubyArray to_a(final ThreadContext context, final IRubyObject self) { // re-implemented to skip an intermediate toArray() conversion : final Ruby runtime = context.runtime; final java.util.List list = unwrapIfJavaObject(self); final IRubyObject[] array = new IRubyObject[ list.size() ]; int i = 0; for ( Object elem : list ) { array[i++] = convertJavaToUsableRubyObject(runtime, elem);; } return RubyArray.newArrayMayCopy(runtime, array); }
@JRubyMethod(name = { "to_a", "to_ary" }) public IRubyObject get(ThreadContext context) { IRubyObject[] elems = new IRubyObject[arrayType.length()]; for (int i = 0; i < elems.length; ++i) { elems[i] = get(context, i); } return RubyArray.newArrayMayCopy(context.runtime, elems); }
public static IRubyObject generateMRIBacktrace(Ruby runtime, RubyStackTraceElement[] trace) { if (trace == null) return runtime.getNil(); ThreadContext context = runtime.getCurrentContext(); final IRubyObject[] traceArray = new IRubyObject[trace.length]; for (int i = 0; i < trace.length; i++) { traceArray[i] = RubyStackTraceElement.to_s_mri(context, trace[i]); } return RubyArray.newArrayMayCopy(runtime, traceArray); }
public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { final IRubyObject larg; boolean ary = false; switch (largs.length) { case 0: larg = ctx.nil; break; case 1: larg = largs[0]; break; default: larg = RubyArray.newArrayMayCopy(ctx.runtime, largs); ary = true; } IRubyObject val = ary ? block.yieldArray(ctx, larg, null) : block.yield(ctx, larg); synchronized (result) { result.append(val); } return ctx.nil; } });
private static RubyString doJoin(ThreadContext context, IRubyObject recv, IRubyObject[] args) { final Ruby runtime = context.runtime; final String separator = runtime.getFile().getConstant("SEPARATOR").toString(); final RubyArray argsAry = RubyArray.newArrayMayCopy(runtime, args); final StringBuilder buffer = new StringBuilder(24); boolean isTainted = joinImpl(buffer, separator, context, recv, argsAry); RubyString fixedStr = new RubyString(runtime, runtime.getString(), buffer); fixedStr.setTaint(isTainted); return fixedStr; }
/** * @return all entries for this Dir */ @JRubyMethod(name = "entries") public RubyArray entries() { return RubyArray.newArrayMayCopy(getRuntime(), JavaUtil.convertJavaArrayToRuby(getRuntime(), snapshot)); }
@JRubyMethod(meta = true) public static RubyArray list(IRubyObject recv) { Ruby runtime = recv.getRuntime(); RubyThread[] activeThreads = runtime.getThreadService().getActiveRubyThreads(); return RubyArray.newArrayMayCopy(runtime, activeThreads); }
private IRubyObject yieldSpecificMultiArgsCommon(ThreadContext context, Block block, IRubyObject... args) { int blockArity = signature.arityValue(); if (blockArity == 1) { args = new IRubyObject[] { RubyArray.newArrayMayCopy(context.runtime, args) }; } if (canCallDirect()) return yieldDirect(context, block, args, null); if (blockArity == 0) { args = IRubyObject.NULL_ARRAY; // discard args } if (block.type == Block.Type.LAMBDA) signature.checkArity(context.runtime, args); return commonYieldPath(context, block, Block.Type.NORMAL, args, null, Block.NULL_BLOCK); }
private IRubyObject initialize(Ruby runtime, IRubyObject object, IRubyObject method, IRubyObject[] methodArgs, IRubyObject size, SizeFn sizeFn) { this.object = object; this.method = method.asJavaString(); this.methodArgs = methodArgs; this.size = size; this.sizeFn = sizeFn; this.feedValue = runtime.getNil(); setInstanceVariable("@__object__", object); setInstanceVariable("@__method__", method); setInstanceVariable("@__args__", RubyArray.newArrayMayCopy(runtime, methodArgs)); return this; }