Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    **** BEGIN LICENSE BLOCK *****
    * Version: CPL 1.0/GPL 2.0/LGPL 2.1
    *
    * The contents of this file are subject to the Common Public
    * License Version 1.0 (the "License"); you may not use this file
    * except in compliance with the License. You may obtain a copy of
    * the License at http://www.eclipse.org/legal/cpl-v10.html
    *
   * Software distributed under the License is distributed on an "AS
   * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
   * implied. See the License for the specific language governing
   * rights and limitations under the License.
   *
   * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>
   * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com>
   * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
   * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
   * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
   * Copyright (C) 2002-2005 Thomas E Enebo <enebo@acm.org>
   * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com>
   * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
   * Copyright (C) 2006 Ola Bini <Ola.Bini@ki.se>
   * Copyright (C) 2006 Daniel Steer <damian.steer@hp.com>
   * 
   * Alternatively, the contents of this file may be used under the terms of
   * either of the GNU General Public License Version 2 or later (the "GPL"),
   * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   * in which case the provisions of the GPL or the LGPL are applicable instead
   * of those above. If you wish to allow use of your version of this file only
   * under the terms of either the GPL or the LGPL, and not to allow others to
   * use your version of this file under the terms of the CPL, indicate your
   * decision by deleting the provisions above and replace them with the notice
   * and other provisions required by the GPL or the LGPL. If you do not delete
   * the provisions above, a recipient may use your version of this file under
   * the terms of any one of the CPL, the GPL or the LGPL.
   ***** END LICENSE BLOCK *****/
  package org.jruby;
  
  import static org.jruby.RubyEnumerator.enumeratorize;
  
  import java.util.Arrays;
  import java.util.List;
  
  
  import static org.jruby.runtime.Visibility.*;
  import static org.jruby.CompatVersion.*;
  
  import static org.jruby.javasupport.util.RuntimeHelpers.invokedynamic;
  import static org.jruby.runtime.invokedynamic.MethodNames.HASH;
  import static org.jruby.runtime.invokedynamic.MethodNames.OP_CMP;

The implementation of the built-in class Array in Ruby. Concurrency: no synchronization is required among readers, but all users must synchronize externally with writers.
  
  @JRubyClass(name="Array")
  public class RubyArray extends RubyObject implements ListRandomAccess {
      public static final int DEFAULT_INSPECT_STR_SIZE = 10;
  
      public static RubyClass createArrayClass(Ruby runtime) {
          RubyClass arrayc = runtime.defineClass("Array"runtime.getObject(), );
          runtime.setArray(arrayc);
 
         arrayc.index = .;
         arrayc.setReifiedClass(RubyArray.class);
         
         arrayc.kindOf = new RubyModule.KindOf() {
             @Override
             public boolean isKindOf(IRubyObject objRubyModule type) {
                 return obj instanceof RubyArray;
             }
         };
 
         arrayc.includeModule(runtime.getEnumerable());
         arrayc.defineAnnotatedMethods(RubyArray.class);
 
         return arrayc;
     }
 
     private static ObjectAllocator ARRAY_ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtimeRubyClass klass) {
             return new RubyArray(runtimeklass.);
         }
     };
 
     @Override
     public int getNativeTypeIndex() {
         return .;
     }
 
     private final void concurrentModification() {
     }
 
     private static void concurrentModification(Ruby runtime) {
         throw runtime.newConcurrencyError("Detected invalid array contents due to unsynchronized modifications with concurrent users");
     }

    
rb_ary_s_create
 
     @JRubyMethod(name = "[]", rest = true, meta = true)
     public static IRubyObject create(IRubyObject klassIRubyObject[] argsBlock block) {
         RubyArray arr = (RubyArray) ((RubyClassklass).allocate();
 
         if (args.length > 0) {
             arr.values = new IRubyObject[args.length];
             System.arraycopy(args, 0, arr.values, 0, args.length);
             arr.realLength = args.length;
         }
         return arr;
     }

    
rb_ary_new2
 
     public static final RubyArray newArray(final Ruby runtimefinal long len) {
         checkLength(runtimelen);
         return newArray(runtime, (int)len);
     }
     
     public static final RubyArray newArrayLight(final Ruby runtimefinal long len) {
         checkLength(runtimelen);
         return newArrayLight(runtime, (int)len);
     }
     
     public static final RubyArray newArray(final Ruby runtimefinal int len) {
         RubyArray array = new RubyArray(runtimelen);
         RuntimeHelpers.fillNil(array.values, 0, array.values.lengthruntime);
         return array;
     }
 
     public static final RubyArray newArrayLight(final Ruby runtimefinal int len) {
         RubyArray array = new RubyArray(runtimelenfalse);
         RuntimeHelpers.fillNil(array.values, 0, array.values.lengthruntime);
         return array;
     }

    
rb_ary_new
 
     public static final RubyArray newArray(final Ruby runtime) {
         return newArray(runtime);
     }

    
rb_ary_new
 
     public static final RubyArray newArrayLight(final Ruby runtime) {
         /* Ruby arrays default to holding 16 elements, so we create an
          * ArrayList of the same size if we're not told otherwise
          */
         return newArrayLight(runtime);
     }
 
     public static RubyArray newArray(Ruby runtimeIRubyObject obj) {
         return new RubyArray(runtimenew IRubyObject[] { obj });
     }
 
     public static RubyArray newArrayLight(Ruby runtimeIRubyObject obj) {
         return new RubyArray(runtimenew IRubyObject[] { obj }, false);
     }
 
     public static RubyArray newArrayLight(Ruby runtimeIRubyObject... objs) {
         return new RubyArray(runtimeobjsfalse);
     }

    
rb_assoc_new
 
     public static RubyArray newArray(Ruby runtimeIRubyObject carIRubyObject cdr) {
         return new RubyArray(runtimenew IRubyObject[] { carcdr });
     }
     
     public static RubyArray newEmptyArray(Ruby runtime) {
         return new RubyArray(runtime);
     }

    
rb_ary_new4, rb_ary_new3
 
     public static RubyArray newArray(Ruby runtimeIRubyObject[] args) {
         RubyArray arr = new RubyArray(runtimenew IRubyObject[args.length]);
         System.arraycopy(args, 0, arr.values, 0, args.length);
         arr.realLength = args.length;
         return arr;
     }
     
     public static RubyArray newArrayNoCopy(Ruby runtimeIRubyObject[] args) {
         return new RubyArray(runtimeargs);
     }
     
     public static RubyArray newArrayNoCopy(Ruby runtimeIRubyObject[] argsint begin) {
         return new RubyArray(runtimeargsbegin);
     }
 
     public static RubyArray newArrayNoCopy(Ruby runtimeIRubyObject[] argsint beginint length) {
         assert begin >= 0 : "begin must be >= 0";
         assert length >= 0 : "length must be >= 0";
         
         return new RubyArray(runtimeargsbeginlength);
     }
 
     public static RubyArray newArrayNoCopyLight(Ruby runtimeIRubyObject[] args) {
         RubyArray arr = new RubyArray(runtimefalse);
         arr.values = args;
         arr.realLength = args.length;
         return arr;
     }
 
     public static RubyArray newArray(Ruby runtimeCollection<? extends IRubyObjectcollection) {
         return new RubyArray(runtimecollection.toArray(new IRubyObject[collection.size()]));
     }
 
     public static final int ARRAY_DEFAULT_SIZE = 16;    
 
     // volatile to ensure that initial nil-fill is visible to other threads
     private volatile IRubyObject[] values;
 
     private static final int TMPLOCK_ARR_F = 1 << 9;
     private static final int TMPLOCK_OR_FROZEN_ARR_F =  | ;
 
     private volatile boolean isShared = false;
     private int begin = 0;
     private int realLength = 0;
 
     /*
      * plain internal array assignment
      */
     private RubyArray(Ruby runtimeIRubyObject[] vals) {
         super(runtimeruntime.getArray());
          = vals;
          = vals.length;
     }
 
     /* 
      * plain internal array assignment
      */
     private RubyArray(Ruby runtimeIRubyObject[] valsboolean objectSpace) {
         super(runtimeruntime.getArray(), objectSpace);
          = vals;
          = vals.length;
     }
 
     /* 
      * plain internal array assignment
      */
     private RubyArray(Ruby runtimeIRubyObject[] valsint begin) {
         super(runtimeruntime.getArray());
         this. = vals;
         this. = begin;
         this. = vals.length - begin;
         this. = true;
     }
 
     private RubyArray(Ruby runtimeIRubyObject[] valsint beginint length) {
         super(runtimeruntime.getArray());
         this. = vals;
         this. = begin;
         this. = length;
         this. = true;
     }
 
     private RubyArray(Ruby runtimeRubyClass metaClassIRubyObject[] valsint beginint length) {
         super(runtimemetaClass);
         this. = vals;
         this. = begin;
         this. = length;
         this. = true;
     }
     
     protected RubyArray(Ruby runtimeint length) {
         super(runtimeruntime.getArray());
          = new IRubyObject[length];
     }
 
     private RubyArray(Ruby runtimeint lengthboolean objectspace) {
         super(runtimeruntime.getArray(), objectspace);
          = new IRubyObject[length];
     }
 
     /* NEWOBJ and OBJSETUP equivalent
      * fastest one, for shared arrays, optional objectspace
      */
     private RubyArray(Ruby runtimeboolean objectSpace) {
         super(runtimeruntime.getArray(), objectSpace);
     }
 
     private RubyArray(Ruby runtimeRubyClass klass) {
         super(runtimeklass);
     }
 
     /* Array constructors taking the MetaClass to fulfil MRI Array subclass behaviour
      * 
      */
     private RubyArray(Ruby runtimeRubyClass klassint length) {
         super(runtimeklass);
          = new IRubyObject[length];
     }
 
     private RubyArray(Ruby runtimeRubyClass klassIRubyObject[]valsboolean objectspace) {
         super(runtimeklassobjectspace);
          = vals;
     }    
 
     private RubyArray(Ruby runtimeRubyClass klassboolean objectSpace) {
         super(runtimeklassobjectSpace);
     }
     
     private RubyArray(Ruby runtimeRubyClass klassRubyArray original) {
         super(runtimeklass);
          = original.realLength;
          = new IRubyObject[];
         safeArrayCopy(runtimeoriginal.valuesoriginal.begin, 0, );
     }
     
     private RubyArray(Ruby runtimeRubyClass klassIRubyObject[] vals) {
         super(runtimeklass);
          = vals;
          = vals.length;
     }
 
     private void alloc(int length) {
         final IRubyObject[] newValues = new IRubyObject[length];
         RuntimeHelpers.fillNil(newValuesgetRuntime());
          = newValues;
          = 0;
     }
 
     private void realloc(int newLengthint valuesLength) {
         IRubyObject[] reallocated = new IRubyObject[newLength];
         if (newLength > valuesLength) {
             RuntimeHelpers.fillNil(reallocatedvaluesLengthnewLengthgetRuntime());
             safeArrayCopy(reallocated, 0, valuesLength); // elements and trailing nils
         } else {
             safeArrayCopy(reallocated, 0, newLength); // ???
         }
          = 0;
          = reallocated;
     }
 
     private static void fill(IRubyObject[]arrint fromint toIRubyObject with) {
         for (int i=fromi<toi++) {
             arr[i] = with;
         }
     }
 
     private static final void checkLength(Ruby runtimelong length) {
         if (length < 0) {
             throw runtime.newArgumentError("negative array size (or size too big)");
         }
 
         if (length >= .) {
             throw runtime.newArgumentError("array size too big");
         }
     }

    
Getter for property list.

Returns:
Value of property list.
 
     public List getList() {
         return Arrays.asList(toJavaArray()); 
     }
 
     public int getLength() {
         return ;
     }
 
     public IRubyObject[] toJavaArray() {
         IRubyObject[] copy = new IRubyObject[];
         safeArrayCopy(copy, 0, );
         return copy;
     }
     
     public IRubyObject[] toJavaArrayUnsafe() {
         return ! ?  : toJavaArray();
     }    
 
     public IRubyObject[] toJavaArrayMaybeUnsafe() {
         return (! &&  == 0 && . == ) ?  : toJavaArray();
     }    

    
rb_ary_make_shared
 
     private RubyArray makeShared() {
         return makeShared(getMetaClass());
     }
 
     private RubyArray makeShared(int begint lenRubyClass klass) {
         return makeShared(beglennew RubyArray(klass.getRuntime(), klass));
     }
 
     private RubyArray makeShared(int begint lenRubyArray sharedArray) {
          = true;
         sharedArray.values = ;
         sharedArray.isShared = true;
         sharedArray.begin = beg;
         sharedArray.realLength = len;
         return sharedArray;
     }

    
ary_shared_first
 
     private RubyArray makeSharedFirst(ThreadContext contextIRubyObject numboolean lastRubyClass klass) {
         int n = RubyNumeric.num2int(num);
         
         if (n > ) {
             n = ;
         } else if (n < 0) {
             throw context.runtime.newArgumentError("negative array size");
         }
         
         return makeShared(last ?  +  - n : nklass);
     }

    
rb_ary_modify_check
 
     private final void modifyCheck() {
         if (( & ) != 0) {
             if (( & ) != 0) throw getRuntime().newFrozenError("array");           
             if (( & ) != 0) throw getRuntime().newTypeError("can't modify array during iteration");
         }
     }

    
rb_ary_modify
 
     private final void modify() {
         modifyCheck();
         if () {
             IRubyObject[] vals = new IRubyObject[];
             safeArrayCopy(vals, 0, );
              = 0;            
              = vals;
              = false;
         }
     }
 
     /*  ================
      *  Instance Methods
      *  ================ 
      */

    
Variable arity version for compatibility. Not bound to a Ruby method.

Deprecated:
Use the versions with zero, one, or two args.
 
     public IRubyObject initialize(ThreadContext contextIRubyObject[] argsBlock block) {
         switch (args.length) {
         case 0:
             return initialize(contextblock);
         case 1:
             return initializeCommon(contextargs[0], nullblock);
         case 2:
             return initializeCommon(contextargs[0], args[1], block);
         default:
             Arity.raiseArgumentError(getRuntime(), args.length, 0, 2);
             return null// not reached
         }
     }    
    
    
rb_ary_initialize
 
     @JRubyMethod(visibility = )
     public IRubyObject initialize(ThreadContext contextBlock block) {
         modifyCheck();
         Ruby runtime = context.runtime;
          = 0;
         if (block.isGiven() && runtime.isVerbose()) {
             runtime.getWarnings().warning(."given block not used");
         }
         return this;
     }

    
rb_ary_initialize
 
     @JRubyMethod(visibility = )
     public IRubyObject initialize(ThreadContext contextIRubyObject arg0Block block) {
         return initializeCommon(contextarg0nullblock);
     }

    
rb_ary_initialize
 
     @JRubyMethod(visibility = )
     public IRubyObject initialize(ThreadContext contextIRubyObject arg0IRubyObject arg1Block block) {
         return initializeCommon(contextarg0arg1block);
     }
 
     private IRubyObject initializeCommon(ThreadContext contextIRubyObject arg0IRubyObject arg1Block block) {
         Ruby runtime = context.runtime;
 
         if (arg1 == null && !(arg0 instanceof RubyFixnum)) {
             IRubyObject val = arg0.checkArrayType();
             if (!val.isNil()) {
                 replace(val);
                 return this;
             }
         }
 
         long len = RubyNumeric.num2long(arg0);
         if (len < 0) throw runtime.newArgumentError("negative array size");
         if (len >= .throw runtime.newArgumentError("array size too big");
         int ilen = (intlen;
 
         modify();
 
         if (ilen > . - ) {
              = new IRubyObject[ilen];
              = 0;
         }
 
         if (block.isGiven()) {
             if (arg1 != null) {
                 runtime.getWarnings().warn(."block supersedes default value argument");
             }
 
             if (block.getBody().getArgumentType() == .) {
                 IRubyObject nil = runtime.getNil();
                 for (int i = 0; i < ileni++) {
                     store(iblock.yield(contextnil));
                      = i + 1;
                 }
             } else {
                 for (int i = 0; i < ileni++) {
                     store(iblock.yield(context, RubyFixnum.newFixnum(runtimei)));
                      = i + 1;
                 }
             }
             
         } else {
             try {
                 if (arg1 == null) {
                     RuntimeHelpers.fillNil( + ilenruntime);
                 } else {
                     fill( + ilenarg1);
                 }
             } catch (ArrayIndexOutOfBoundsException e) {
                 concurrentModification();
             }
              = ilen;
         }
         return this;
     }

    
rb_ary_initialize_copy
 
     @JRubyMethod(name = {"initialize_copy"}, required = 1, visibility=)
     @Override
     public IRubyObject initialize_copy(IRubyObject orig) {
         return this.replace(orig);
     }

    
Overridden dup for fast-path logic.

Returns:
A new RubyArray sharing the original backing store.
 
     public IRubyObject dup() {
         if (. != .return super.dup();
 
         RubyArray dup = new RubyArray(.getClassRuntime(), );
         dup.isShared =  = true;
         dup.flags |=  & // from DUP_SETUP
         dup.flags |=  & ;
 
         return dup;
     }
    
    
rb_ary_replace
 
     @JRubyMethod(name = {"replace"}, required = 1)
     public IRubyObject replace(IRubyObject orig) {
         modifyCheck();
 
         RubyArray origArr = orig.convertToArray();
 
         if (this == origreturn this;
 
         origArr.isShared = true;
          = true;
          = origArr.values;
          = origArr.realLength;
          = origArr.begin;
 
 
         return this;
     }

    
rb_ary_to_s
 
     @JRubyMethod(name = "to_s")
     @Override
     public IRubyObject to_s() {
         if (getRuntime().is1_9()) {
             // 1.9 seems to just do inspect for to_s now
             return inspect();
         }
         
         if ( == 0) return RubyString.newEmptyString(getRuntime());
 
         return join(getRuntime().getCurrentContext(), getRuntime().getGlobalVariables().get("$,"));
     }
 
     
     public boolean includes(ThreadContext contextIRubyObject item) {
         int myBegin = this.;
         int end = myBegin + ;
         IRubyObject[] values = this.;
         for (int i = myBegini < endi++) {
             final IRubyObject value = safeArrayRef(valuesi);
             if (equalInternal(contextvalueitem)) return true;
         }
         
         return false;
     }

    
rb_ary_hash
 
     @JRubyMethod(name = "hash", compat = )
     public RubyFixnum hash(ThreadContext context) {
         Ruby runtime = context.runtime;
         if (runtime.isInspecting(this)) return  RubyFixnum.zero(runtime);
 
         try {
             runtime.registerInspecting(this);
             int myBegin = this.;
             int h = ;
             for (int i = myBegini < myBegin + i++) {
                 h = (h << 1) | (h < 0 ? 1 : 0);
                 final IRubyObject value = safeArrayRef(i);
                 h ^= RubyNumeric.num2long(invokedynamic(contextvalue));
             }
             return runtime.newFixnum(h);
         } finally {
             runtime.unregisterInspecting(this);
         }
     }

    
rb_ary_hash
 
     @JRubyMethod(name = "hash", compat = )
     public RubyFixnum hash19(final ThreadContext context) {
         return (RubyFixnumgetRuntime().execRecursiveOuter(new Ruby.RecursiveFunction() {
             public IRubyObject call(IRubyObject objboolean recur) {
                 int begin = RubyArray.this.;
                 long h = ;
                 if (recur) {
                     h ^= RubyNumeric.num2long(invokedynamic(contextcontext.runtime.getArray(), ));
                 } else {
                     for (int i = begini < begin + i++) {
                         h = (h << 1) | (h < 0 ? 1 : 0);
                         final IRubyObject value = safeArrayRef(i);
                         h ^= RubyNumeric.num2long(invokedynamic(contextvalue));
                     }
                 }
                 return getRuntime().newFixnum(h);
             }
         }, RubyArray.this);
     }

    
rb_ary_store
 
     public final IRubyObject store(long indexIRubyObject value) {
         if (index < 0 && (index += ) < 0) throw getRuntime().newIndexError("index " + (index - ) + " out of array");
 
         modify();
 
         if (index >= ) {
             int valuesLength = . - ;
             if (index >= valuesLengthstoreRealloc(indexvaluesLength);
              = (intindex + 1;
         }
 
         safeArraySet( + (intindexvalue);
         
         return value;
     }
 
     private void storeRealloc(long indexint valuesLength) {
         long newLength = valuesLength >> 1;
 
         if (newLength < newLength = ;
 
         newLength += index;
         if (index >= . || newLength >= .) {
             throw getRuntime().newArgumentError("index too big");
         }
         realloc((intnewLengthvaluesLength);
     }

    
rb_ary_elt
 
     private final IRubyObject elt(long offset) {
         if (offset < 0 || offset >= ) {
             return getRuntime().getNil();
         }
         return eltOk(offset);
     }
 
     public final IRubyObject eltOk(long offset) {
         return safeArrayRef( + (int)offset);
     }

    
rb_ary_entry
 
     public final IRubyObject entry(long offset) {
         return (offset < 0 ) ? elt(offset + ) : elt(offset);
     }
 
     public final IRubyObject entry(int offset) {
         return (offset < 0 ) ? elt(offset + ) : elt(offset);
     }
 
     public final IRubyObject eltInternal(int offset) {
         return [ + offset];
     }
     
     public final IRubyObject eltInternalSet(int offsetIRubyObject item) {
         return [ + offset] = item;
     }

    
Variable arity version for compatibility. Not bound to a Ruby method.

Deprecated:
Use the versions with zero, one, or two args.
 
     public IRubyObject fetch(ThreadContext contextIRubyObject[] argsBlock block) {
         switch (args.length) {
         case 1:
             return fetch(contextargs[0], block);
         case 2:
             return fetch(contextargs[0], args[1], block);
         default:
             Arity.raiseArgumentError(getRuntime(), args.length, 1, 2);
             return null// not reached
         }
     }    

    
rb_ary_fetch
 
     @JRubyMethod
     public IRubyObject fetch(ThreadContext contextIRubyObject arg0Block block) {
         long index = RubyNumeric.num2long(arg0);
 
         if (index < 0) index += ;
         if (index < 0 || index >= ) {
             if (block.isGiven()) return block.yield(contextarg0);
             throw getRuntime().newIndexError("index " + index + " out of array");
         }
         
         return safeArrayRef( + (intindex);
     }

    
rb_ary_fetch
 
    public IRubyObject fetch(ThreadContext contextIRubyObject arg0IRubyObject arg1Block block) {
        if (block.isGiven()) getRuntime().getWarnings().warn(."block supersedes default value argument");
 
        long index = RubyNumeric.num2long(arg0);
 
        if (index < 0) index += ;
        if (index < 0 || index >= ) {
            if (block.isGiven()) return block.yield(contextarg0);
            return arg1;
        }
        
        return safeArrayRef( + (intindex);
    }    

    
rb_ary_to_ary
 
     private static RubyArray aryToAry(IRubyObject obj) {
         if (obj instanceof RubyArrayreturn (RubyArrayobj;
 
         if (obj.respondsTo("to_ary")) return obj.convertToArray();
 
         RubyArray arr = new RubyArray(obj.getRuntime(), false); // possibly should not in object space
         arr.values = new IRubyObject[]{obj};
         arr.realLength = 1;
         return arr;
     }

    
rb_ary_splice
 
     private final void splice(long beglong lenIRubyObject rplboolean oneNine) {
         if (len < 0) throw getRuntime().newIndexError("negative length (" + len + ")");
         if (beg < 0 && (beg += ) < 0) throw getRuntime().newIndexError("index " + (beg - ) + " out of array");
 
         final RubyArray rplArr;
         final int rlen;
 
         if (rpl == null || (rpl.isNil() && !oneNine)) {
             rplArr = null;
             rlen = 0;
         } else if (rpl.isNil()) {
             // 1.9 replaces with nil
             rplArr = newArray(getRuntime(), rpl);
             rlen = 1;
         } else {
             rplArr = aryToAry(rpl);
             rlen = rplArr.realLength;
         }
 
         modify();
 
         int valuesLength = . - ;
         if (beg >= ) {
             len = beg + rlen;
             if (len >= valuesLengthspliceRealloc((int)lenvaluesLength);
             try {
                 RuntimeHelpers.fillNil( +  + ((int)beg), getRuntime());
             } catch (ArrayIndexOutOfBoundsException e) {
                 concurrentModification();
             }
              = (intlen;
         } else {
             if (beg + len > len =  - beg;
             int alen =  + rlen - (int)len;
             if (alen >= valuesLengthspliceRealloc(alenvaluesLength);
 
             if (len != rlen) {
                 safeArrayCopy( + (int) (beg + len),  + (intbeg + rlen - (int) (beg + len));
                  = alen;
             }
         }
 
         if (rlen > 0) {
             safeArrayCopy(rplArr.valuesrplArr.begin + (intbegrlen);
         }
     }

    
rb_ary_splice
 
     private final void spliceOne(long begIRubyObject rpl) {
         if (beg < 0 && (beg += ) < 0) throw getRuntime().newIndexError("index " + (beg - ) + " out of array");
 
         modify();
 
         int valuesLength = . - ;
         if (beg >= ) {
             int len = (int)beg + 1;
             if (len >= valuesLengthspliceRealloc((int)lenvaluesLength);
             RuntimeHelpers.fillNil( +  + ((int)beg), getRuntime());
              = (intlen;
         } else {
             int len = beg >  ?  - (int)beg : 0;
             int alen =  + 1 - len;
             if (alen >= valuesLengthspliceRealloc((int)alenvaluesLength);
 
             if (len == 0) {
                 safeArrayCopy( + (intbeg + (intbeg + 1,  - (intbeg);
                  = alen;
             }
         }
 
         safeArraySet( + (int)begrpl);
     }
 
     private void spliceRealloc(int lengthint valuesLength) {
         int tryLength = valuesLength + (valuesLength >> 1);
         int len = length > tryLength ? length : tryLength;
         IRubyObject[] vals = new IRubyObject[len];
         System.arraycopy(vals, 0, );
         
         // only fill if there actually will remain trailing storage
         if (len > length) RuntimeHelpers.fillNil(valslengthlengetRuntime());
          = 0;
          = vals;
     }
 
     @JRubyMethod
     public IRubyObject insert() {
         throw getRuntime().newArgumentError(0, 1);
     }

    
rb_ary_insert
 
     @JRubyMethod(name = "insert", compat = )
     public IRubyObject insert(IRubyObject arg) {
         return this;
     }
     
     @JRubyMethod(name = "insert", compat = )
     public IRubyObject insert19(IRubyObject arg) {
         modifyCheck();
         
         return insert(arg);
     }
 
     @JRubyMethod(name = "insert", compat = )
     public IRubyObject insert(IRubyObject arg1IRubyObject arg2) {
         long pos = RubyNumeric.num2long(arg1);
 
         if (pos == -1) pos = ;
         if (pos < 0) pos++;
         
         spliceOne(posarg2); // rb_ary_new4
         
         return this;
     }
 
     @JRubyMethod(name = "insert", compat = )
     public IRubyObject insert19(IRubyObject arg1IRubyObject arg2) {
         modifyCheck();
 
         return insert(arg1arg2);
     }
 
     @JRubyMethod(name = "insert", required = 1, rest = true, compat = )
     public IRubyObject insert(IRubyObject[] args) {
         if (args.length == 1) return this;
 
         long pos = RubyNumeric.num2long(args[0]);
 
         if (pos == -1) pos = ;
         if (pos < 0) pos++;
 
         RubyArray inserted = new RubyArray(getRuntime(), false);
         inserted.values = args;
         inserted.begin = 1;
         inserted.realLength = args.length - 1;
         
         splice(pos, 0, insertedfalse); // rb_ary_new4
         
         return this;
     }
 
     @JRubyMethod(name = "insert", required = 1, rest = true, compat = )
     public IRubyObject insert19(IRubyObject[] args) {
         modifyCheck();
 
         return insert(args);
     }

    
rb_ary_dup
 
     public final RubyArray aryDup() {
         RubyArray dup = new RubyArray(.getClassRuntime(), );
         dup.isShared = true;
          = true;
         dup.flags |=  & ( | ); // from DUP_SETUP
        // rb_copy_generic_ivar from DUP_SETUP here ...unlikely..
        return dup;
    }
    
    public final RubyArray aryDup19() {
        // In 1.9, rb_ary_dup logic changed so that on subclasses of Array,
        // dup returns an instance of Array, rather than an instance of the subclass
        // Also, taintedness and trustedness are not inherited to duplicates
        RubyArray dup = new RubyArray(.getClassRuntime(), );
        dup.isShared = true;
         = true;
        // rb_copy_generic_ivar from DUP_SETUP here ...unlikely..
        return dup;
    }

    
rb_ary_transpose
    @JRubyMethod(name = "transpose")
    public RubyArray transpose() {
        RubyArray tmpresult = null;
        int alen = ;
        if (alen == 0) return aryDup();
    
        Ruby runtime = getRuntime();
        int elen = -1;
        int end =  + alen;
        for (int i = i < endi++) {
            tmp = elt(i).convertToArray();
            if (elen < 0) {
                elen = tmp.realLength;
                result = new RubyArray(runtimeelen);
                for (int j = 0; j < elenj++) {
                    result.store(jnew RubyArray(runtimealen));
                }
            } else if (elen != tmp.realLength) {
                throw runtime.newIndexError("element size differs (" + tmp.realLength
                        + " should be " + elen + ")");
            }
            for (int j = 0; j < elenj++) {
                ((RubyArrayresult.elt(j)).store(i - tmp.elt(j));
            }
        }
        return result;
    }

    
rb_values_at (internal)
    private final IRubyObject values_at(long olenIRubyObject[] args) {
        RubyArray result = new RubyArray(getRuntime(), args.length);
        for (int i = 0; i < args.lengthi++) {
            if (args[iinstanceof RubyFixnum) {
                result.append(entry(((RubyFixnum)args[i]).getLongValue()));
                continue;
            }
            long beglen[];
            if (!(args[iinstanceof RubyRange)) {
            } else if ((beglen = ((RubyRangeargs[i]).begLen(olen, 0)) == null) {
                continue;
            } else {
                int beg = (intbeglen[0];
                int len = (intbeglen[1];
                int end =  + len;
                for (int j = j < endj++) {
                    result.append(entry(j + beg));
                }
                continue;
            }
            result.append(entry(RubyNumeric.num2long(args[i])));
        }
        RuntimeHelpers.fillNil(result.valuesresult.realLengthresult.values.lengthgetRuntime());
        return result;
    }

    
rb_values_at
    @JRubyMethod(name = "values_at", rest = true)
    public IRubyObject values_at(IRubyObject[] args) {
        return values_at(args);
    }

    
rb_ary_subseq
    public IRubyObject subseq(long beglong len) {
        int realLength = this.;
        if (