RubyHash

java.lang.Object
- org.jruby.RubyBasicObject
- - org.jruby.RubyObject
  - - org.jruby.RubyHash

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<IRubyObject>, java.util.Map, InstanceVariables, InternalVariables, IRubyObject, CoreObjectType

Direct Known Subclasses:

MapJavaProxy.RubyHashMap, RubyGlobal.StringOnlyRubyHash
```
public class RubyHash
extends RubyObject
implements java.util.Map
```
Implementation of the Hash class. Concurrency: no synchronization is required among readers, but all users must synchronize externally with writers.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`RubyHash.BaseCollection`
`private class`	`RubyHash.BaseIterator`
`private class`	`RubyHash.BaseSet`
`private static class`	`RubyHash.ConvertingEntry`
`private static class`	`RubyHash.EntryMatchType`
`private static class`	`RubyHash.EntryView`
`private static class`	`RubyHash.Found`
`private static class`	`RubyHash.FoundKey`
`private static class`	`RubyHash.FoundPair`
`private static class`	`RubyHash.Mismatch` rb_hash_equal
`static class`	`RubyHash.RubyHashEntry`
`static class`	`RubyHash.Visitor`
`private static class`	`RubyHash.VisitorIOException`

Nested classes/interfaces inherited from class org.jruby.RubyObject
RubyObject.Data

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject
RubyBasicObject.Finalizer

Nested classes/interfaces inherited from interface java.util.Map
java.util.Map.Entry<K,V>

Field Summary

Fields
Modifier and Type	Field and Description
`static long`	`collisions`
`static int`	`DEFAULT_INSPECT_STR_SIZE`
`private static RubyHash.EntryView`	`DIRECT_ENTRY_VIEW`
`private static RubyHash.EntryView`	`DIRECT_KEY_VIEW`
`private static RubyHash.EntryView`	`DIRECT_VALUE_VIEW`
`private static RubyHash.EntryView`	`ENTRY_VIEW`
`private static RubyHash.Found`	`FOUND`
`private int`	`generation`
`private static ObjectAllocator`	`HASH_ALLOCATOR`
`private static int`	`HASH_SIGN_BIT_MASK`
`private RubyHash.RubyHashEntry`	`head`
`private IRubyObject`	`ifNone`
`private static int`	`INITIAL_THRESHOLD`
`private static java.util.concurrent.atomic.AtomicIntegerFieldUpdater<RubyHash>`	`ITERATOR_UPDATER`
`private int`	`iteratorCount`
`private static int`	`JAVASOFT_INITIAL_CAPACITY`
`private static RubyHash.EntryView`	`KEY_VIEW`
`private static RubyHash.EntryMatchType`	`MATCH_ENTRY`
`private static RubyHash.EntryMatchType`	`MATCH_KEY`
`private static int`	`MAXIMUM_CAPACITY`
`private static int`	`MIN_CAPA`
`private static RubyHash.Mismatch`	`MISMATCH`
`private static boolean`	`MRI_HASH`
`private static boolean`	`MRI_HASH_RESIZE`
`private static int`	`MRI_INITIAL_CAPACITY`
`private static int[]`	`MRI_PRIMES`
`static RubyHash.RubyHashEntry`	`NO_ENTRY`
`private static int`	`PROCDEFAULT_HASH_F`
`protected int`	`size`
`private static int`	`ST_DEFAULT_MAX_DENSITY`
`private RubyHash.RubyHashEntry[]`	`table`
`private int`	`threshold`
`private static RubyHash.EntryView`	`VALUE_VIEW`

Fields inherited from class org.jruby.RubyObject
FIELD_ALLOCATED_CLASSES, FIELD_ALLOCATORS, IVAR_INSPECTING_OBJECT_ALLOCATOR, OBJECT_ALLOCATOR, OBJECT_VAR0_ALLOCATOR, OBJECT_VAR1_ALLOCATOR, OBJECT_VAR2_ALLOCATOR, OBJECT_VAR3_ALLOCATOR, OBJECT_VAR4_ALLOCATOR, OBJECT_VAR5_ALLOCATOR, OBJECT_VAR6_ALLOCATOR, OBJECT_VAR7_ALLOCATOR, OBJECT_VAR8_ALLOCATOR, OBJECT_VAR9_ALLOCATOR, REIFYING_OBJECT_ALLOCATOR

Fields inherited from class org.jruby.RubyBasicObject
ALL_F, BASICOBJECT_ALLOCATOR, COMPARE_BY_IDENTITY_F, ERR_INSECURE_SET_INST_VAR, FALSE_F, FL_USHIFT, flags, FROZEN_F, metaClass, NEVER, NIL_F, STAMP_OFFSET, TAINTED_F, UNDEF, UNTRUSTED_F, USER0_F, USER1_F, USER2_F, USER3_F, USER4_F, USER5_F, USER6_F, USER7_F, USER8_F, VAR_TABLE_OFFSET, varTable, varTableStamp

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject
NULL_ARRAY

Constructor Summary

Constructors
Modifier	Constructor and Description
	`RubyHash(Ruby runtime)`
`(package private)`	`RubyHash(Ruby runtime, boolean objectSpace)`
	`RubyHash(Ruby runtime, int buckets)`
	`RubyHash(Ruby runtime, IRubyObject defaultValue)`
	`RubyHash(Ruby runtime, IRubyObject defaultValue, int buckets)`
	`RubyHash(Ruby runtime, java.util.Map valueMap, IRubyObject defaultValue)`
	`RubyHash(Ruby runtime, RubyClass klass)`
`private`	`RubyHash(Ruby runtime, RubyClass klass, RubyHash other)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`private void`	`alloc()`
`private void`	`alloc(int buckets)`
`private void`	`allocFirst()`
`private void`	`allocFirst(int buckets)`
`IRubyObject`	`aref(IRubyObject key)` Deprecated. use RubyHash.op_aref instead
`IRubyObject`	`aset(IRubyObject key, IRubyObject value)` Deprecated. use RubyHash.op_aset instead
`IRubyObject`	`assoc(ThreadContext context, IRubyObject obj)`
`private static int`	`bucketIndex(int h, int length)`
`private void`	`checkDefaultProcArity(IRubyObject proc)` default_proc_arity_check
`private void`	`checkIterating()`
`private void`	`checkResize()`
`void`	`clear()`
`RubyBoolean`	`compare(ThreadContext context, MethodNames method, IRubyObject other)`
`private RaiseException`	`concurrentModification()`
`boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(java.lang.Object value)`
`RubyHash`	`convertToHash()` Tries to convert this object to a Ruby Hash using the "to_hash" method.
`static IRubyObject`	`create(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)` rb_hash_s_create
`static RubyClass`	`createHashClass(Ruby runtime)`
`IRubyObject`	`default_proc()` rb_hash_default_proc
`IRubyObject`	`default_value_get(ThreadContext context)`
`IRubyObject`	`default_value_get(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`default_value_get(ThreadContext context, IRubyObject[] args)` Deprecated.
`IRubyObject`	`default_value_set(IRubyObject defaultValue)` rb_hash_set_default
`IRubyObject`	`delete_if(ThreadContext context, Block block)`
`RubyHash`	`delete_ifInternal(ThreadContext context, Block block)` rb_hash_delete_if
`IRubyObject`	`delete(ThreadContext context, IRubyObject key, Block block)` rb_hash_delete
`java.util.Set`	`directEntrySet()`
`java.util.Set`	`directKeySet()`
`java.util.Collection`	`directValues()`
`IRubyObject`	`dup(ThreadContext context)`
`RubyHash`	`dupFast(ThreadContext context)` A lightweight dup for internal use that does not dispatch to initialize_copy nor rehash the keys.
`IRubyObject`	`each_key(ThreadContext context, Block block)`
`RubyHash`	`each_keyCommon(ThreadContext context, Block block)` rb_hash_each_key
`IRubyObject`	`each_pair(ThreadContext context, Block block)`
`RubyHash`	`each_pairCommon(ThreadContext context, Block block, boolean oneNine)` rb_hash_each_pair
`IRubyObject`	`each_value(ThreadContext context, Block block)`
`RubyHash`	`each_valueCommon(ThreadContext context, Block block)` rb_hash_each_value
`IRubyObject`	`each(ThreadContext context, Block block)`
`IRubyObject`	`each19(ThreadContext context, Block block)`
`RubyHash`	`eachCommon(ThreadContext context, Block block)` rb_hash_each
`RubyBoolean`	`empty_p()` rb_hash_empty_p
`java.util.Set`	`entrySet()`
`boolean`	`equals(java.lang.Object other)` This method is just a wrapper around the Ruby "==" method, provided so that RubyObjects can be used as keys in the Java HashMap object underlying RubyHash.
`IRubyObject`	`fastARef(IRubyObject key)`
`void`	`fastASet(IRubyObject key, IRubyObject value)`
`RubyHash`	`fastASetChained(IRubyObject key, IRubyObject value)`
`void`	`fastASetCheckString(Ruby runtime, IRubyObject key, IRubyObject value)`
`void`	`fastASetCheckString19(Ruby runtime, IRubyObject key, IRubyObject value)` Deprecated.
`void`	`fastASetSmallCheckString(Ruby runtime, IRubyObject key, IRubyObject value)`
`void`	`fastASetSmallCheckString19(Ruby runtime, IRubyObject key, IRubyObject value)` Deprecated.
`boolean`	`fastDelete(IRubyObject key)`
`IRubyObject`	`fetch(ThreadContext context, IRubyObject[] args, Block block)` rb_hash_fetch
`IRubyObject`	`fetch(ThreadContext context, IRubyObject key, Block block)`
`IRubyObject`	`fetch(ThreadContext context, IRubyObject key, IRubyObject _default, Block block)`
`IRubyObject`	`flatten(ThreadContext context)`
`IRubyObject`	`flatten(ThreadContext context, IRubyObject level)`
`java.lang.Object`	`get(java.lang.Object key)`
`IRubyObject`	`getCompareByIdentity_p(ThreadContext context)`
`IRubyObject`	`getCompareByIdentity(ThreadContext context)`
`IRubyObject`	`getIfNone()`
`java.lang.Class`	`getJavaClass()` Will return the Java interface that most closely can represent this object, when working through JAva integration translations.
`int`	`getNativeTypeIndex()` This is overridden in the other concrete Java builtins to provide a fast way to determine what type they are.
`RubyBoolean`	`has_key_p(IRubyObject key)` rb_hash_has_key
`RubyBoolean`	`has_value_p(ThreadContext context, IRubyObject expected)` rb_hash_has_value
`boolean`	`hasDefaultProc()`
`RubyFixnum`	`hash()` rb_hash_hash
`RubyFixnum`	`hash19()` rb_hash_hash
`protected static int`	`hashValue(int h)`
`private boolean`	`hasValue(ThreadContext context, IRubyObject expected)`
`IRubyObject`	`index(ThreadContext context, IRubyObject expected)` rb_hash_index
`IRubyObject`	`index19(ThreadContext context, IRubyObject expected)`
`RubyArray`	`indices(ThreadContext context, IRubyObject[] indices)` rb_hash_indexes
`RubyHash`	`initialize_copy(ThreadContext context, IRubyObject other)` rb_hash_replace
`RubyHash`	`initialize_copy19(ThreadContext context, IRubyObject other)` rb_hash_replace
`IRubyObject`	`initialize(IRubyObject[] args, Block block)` rb_hash_initialize
`IRubyObject`	`inspect(ThreadContext context)` rb_hash_inspect
`IRubyObject`	`inspect19(ThreadContext context)`
`private IRubyObject`	`inspectHash(ThreadContext context)` inspect_hash
`private IRubyObject`	`inspectHash19(ThreadContext context)`
`private RubyHash.RubyHashEntry[]`	`internalCopyTable(RubyHash.RubyHashEntry destHead)`
`private RubyHash.RubyHashEntry`	`internalDelete(int hash, RubyHash.EntryMatchType matchType, java.lang.Object obj)`
`protected RubyHash.RubyHashEntry`	`internalDelete(IRubyObject key)`
`protected RubyHash.RubyHashEntry`	`internalDeleteEntry(RubyHash.RubyHashEntry entry)`
`protected IRubyObject`	`internalGet(IRubyObject key)`
`protected RubyHash.RubyHashEntry`	`internalGetEntry(IRubyObject key)`
`private IRubyObject`	`internalIndex(ThreadContext context, IRubyObject expected)`
`private boolean`	`internalKeyExist(RubyHash.RubyHashEntry entry, int hash, IRubyObject key)`
`private void`	`internalPut(IRubyObject key, IRubyObject value)`
`protected void`	`internalPut(IRubyObject key, IRubyObject value, boolean checkForExisting)`
`private void`	`internalPutSmall(IRubyObject key, IRubyObject value)`
`protected void`	`internalPutSmall(IRubyObject key, IRubyObject value, boolean checkForExisting)`
`RubyHash`	`invert(ThreadContext context)` rb_hash_invert
`protected boolean`	`isComparedByIdentity()` Is this object compared by identity or not? Shortcut for doing getFlag(COMPARE_BY_IDENTITY_F).
`boolean`	`isEmpty()`
`private void`	`iteratorEntry()`
`private void`	`iteratorEntrySync()`
`private void`	`iteratorExit()`
`private void`	`iteratorExitSync()`
`private void`	`iteratorVisitAll(RubyHash.Visitor visitor)`
`private static int`	`JavaSoftBucketIndex(int h, int length)`
`private void`	`JavaSoftCheckResize()`
`private static int`	`JavaSoftHashValue(int h)`
`IRubyObject`	`keep_if(ThreadContext context, Block block)`
`boolean`	`keep_ifCommon(ThreadContext context, Block block)`
`IRubyObject`	`key(ThreadContext context, IRubyObject expected)`
`RubyArray`	`keys()` rb_hash_keys
`java.util.Set`	`keySet()`
`static void`	`marshalTo(RubyHash hash, MarshalStream output)`
`RubyHash`	`merge_bang(ThreadContext context, IRubyObject other, Block block)` rb_hash_update
`RubyHash`	`merge_bang19(ThreadContext context, IRubyObject other, Block block)` rb_hash_update
`RubyHash`	`merge(ThreadContext context, IRubyObject other, Block block)` rb_hash_merge
`void`	`modify()` rb_hash_modify
`private static int`	`MRIBucketIndex(int h, int length)`
`private void`	`MRICheckResize()`
`private static int`	`MRIHashValue(int h)`
`static RubyHash`	`newHash(Ruby runtime)` rb_hash_new
`static RubyHash`	`newHash(Ruby runtime, java.util.Map valueMap, IRubyObject defaultValue)` rb_hash_new
`static RubyHash`	`newSmallHash(Ruby runtime)` rb_hash_new
`IRubyObject`	`op_aref(ThreadContext context, IRubyObject key)` rb_hash_aref
`IRubyObject`	`op_aset(IRubyObject key, IRubyObject value)` Deprecated.
`IRubyObject`	`op_aset(ThreadContext context, IRubyObject key, IRubyObject value)` rb_hash_aset
`IRubyObject`	`op_aset19(ThreadContext context, IRubyObject key, IRubyObject value)` Deprecated.
`protected void`	`op_asetForString(Ruby runtime, RubyString key, IRubyObject value)`
`protected void`	`op_asetSmallForString(Ruby runtime, RubyString key, IRubyObject value)`
`IRubyObject`	`op_eql19(ThreadContext context, IRubyObject other)` rb_hash_eql
`IRubyObject`	`op_equal(ThreadContext context, IRubyObject other)` rb_hash_equal
`private boolean`	`overThreshold()`
`java.lang.Object`	`put(java.lang.Object key, java.lang.Object value)`
`void`	`putAll(java.util.Map map)`
`IRubyObject`	`rassoc(ThreadContext context, IRubyObject obj)`
`RubyHash`	`rb_clear()` rb_hash_clear
`RubyFixnum`	`rb_size()` rb_hash_size
`RubyArray`	`rb_values()` rb_hash_values
`IRubyObject`	`rbClone(ThreadContext context)`
`RubyHash`	`rehash()` rb_hash_rehash
`IRubyObject`	`reject_bang(ThreadContext context, Block block)`
`IRubyObject`	`reject_bangInternal(ThreadContext context, Block block)` rb_hash_reject_bang
`IRubyObject`	`reject(ThreadContext context, Block block)`
`RubyHash`	`rejectInternal(ThreadContext context, Block block)` rb_hash_reject
`java.lang.Object`	`remove(java.lang.Object key)`
`RubyHash`	`replace(ThreadContext context, IRubyObject other)` rb_hash_replace
`RubyHash`	`replace19(ThreadContext context, IRubyObject other)`
`private RubyHash`	`replaceCommon(ThreadContext context, IRubyObject other, RubyHash.Visitor visitor)`
`private RubyHash`	`replaceCommon19(ThreadContext context, IRubyObject other, RubyHash.Visitor visitor)`
`private void`	`resize(int newCapacity)`
`private void`	`resizeAndAdjustThreshold(RubyHash.RubyHashEntry[] oldTable)`
`IRubyObject`	`select_bang(ThreadContext context, Block block)`
`IRubyObject`	`select(ThreadContext context, Block block)` rb_hash_select
`IRubyObject`	`select19(ThreadContext context, Block block)`
`IRubyObject`	`set_default_proc(IRubyObject proc)` rb_hash_set_default_proc
`IRubyObject`	`set_default_proc20(IRubyObject proc)`
`void`	`setComparedByIdentity(boolean comparedByIdentity)` Sets whether this object is compared by identity or not.
`IRubyObject`	`shift(ThreadContext context)` rb_hash_shift
`int`	`size()`
`IRubyObject`	`sort(ThreadContext context, Block block)` rb_hash_sort
`RubyArray`	`to_a()` rb_hash_to_a
`RubyHash`	`to_h(ThreadContext context)`
`RubyHash`	`to_hash()` rb_hash_to_hash
`IRubyObject`	`to_s(ThreadContext context)` rb_hash_to_s & to_s_hash
`IRubyObject`	`to_s19(ThreadContext context)`
`static IRubyObject`	`try_convert(ThreadContext context, IRubyObject recv, IRubyObject args)`
`static RubyHash`	`unmarshalFrom(UnmarshalStream input, boolean defaultValue)`
`RubyArray`	`values_at(ThreadContext context, IRubyObject[] args)` rb_hash_values_at
`java.util.Collection`	`values()`
`void`	`visitAll(RubyHash.Visitor visitor)`
`private void`	`visitLimited(RubyHash.Visitor visitor, long size)`

Methods inherited from class org.jruby.RubyObject
attachToObjectSpace, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, callInit, convertToType, createObjectClass, eqlInternal, equalInternal, hashCode, initialize, initialize, inspect, op_eqq, puts, specificEval, toString

Methods inherited from class org.jruby.RubyBasicObject
addFinalizer, anyToString, asJavaString, asString, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callMethod, callSuper, checkArrayType, checkCallMethod, checkFrozen, checkStringType, checkStringType19, compareTo, convertToArray, convertToFloat, convertToInteger, convertToInteger, convertToInteger, convertToString, copyInstanceVariablesInto, copySpecialInstanceVariables, createBasicObjectClass, dataGetStruct, dataGetStructChecked, dataWrapStruct, display, dup, ensureInstanceVariablesSettable, eql_p, eql, equal_p, equal_p19, evalUnder, extend, fastGetInstanceVariable, fastGetInternalVariable, fastHasInstanceVariable, fastHasInternalVariable, fastSetInstanceVariable, fastSetInternalVariable, freeze, frozen_p, getFFIHandle, getFlag, getInstanceEvalClass, getInstanceVariable, getInstanceVariableList, getInstanceVariableNameList, getInstanceVariables, getInternalVariable, getInternalVariables, getMetaClass, getNativeHandle, getObjectId, getRuntime, getSingletonClass, getSingletonClassClone, getType, getVariable, getVariableCount, getVariableList, getVariableNameList, hashyInspect, hasInstanceVariable, hasInternalVariable, hasVariables, id_deprecated, id, infectBy, infectBy, infectBy, initialize_copy, initialize19, inspect, inspectHashCode, instance_eval, instance_eval, instance_eval, instance_eval, instance_eval19, instance_eval19, instance_eval19, instance_eval19, instance_exec, instance_exec19, instance_of_p, instance_variable_defined_p, instance_variable_get, instance_variable_set, instance_variables, instance_variables19, isBuiltin, isClass, isFalse, isFrozen, isImmediate, isModule, isNil, isTaint, isTrue, isUntrusted, kind_of_p, makeMetaClass, method_missing19, method, method19, methods, methods, methods19, nil_p, op_cmp, op_equal_19, op_match, op_match19, op_not_equal, op_not_match, op_not, private_methods, private_methods19, protected_methods, protected_methods19, public_methods, public_methods19, rbClone, recacheBuiltinMethods, remove_instance_variable, removeFinalizers, removeInstanceVariable, removeInternalVariable, respond_to_p, respond_to_p, respond_to_p19, respond_to_p19, respondsTo, respondsToMissing, respondsToMissing, send, send, send, send, send, send19, send19, send19, send19, setFFIHandle, setFlag, setFrozen, setInstanceVariable, setInternalVariable, setMetaClass, setNativeHandle, setTaint, setUntrusted, setVariable, singleton_method_added19, singleton_method_removed19, singleton_method_undefined19, singleton_methods, singleton_methods19, specificEval, specificEval, specificEval, specificEval, syncVariables, syncVariables, taint, taint, tainted_p, testFrozen, testFrozen, to_s, toJava, trust, type_deprecated, type, untaint, untrust, untrusted_p, validateInstanceVariable, variableTableContains, variableTableFastContains, variableTableFastFetch, variableTableFastStore, variableTableFetch, variableTableRemove, variableTableStore, variableTableSync, yieldUnder, yieldUnder

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

Field Detail

DEFAULT_INSPECT_STR_SIZE
```
public static final int DEFAULT_INSPECT_STR_SIZE
```
See Also:

Constant Field Values

HASH_ALLOCATOR

private static final ObjectAllocator HASH_ALLOCATOR

table
```
private RubyHash.RubyHashEntry[] table
```

size
```
protected int size
```

threshold
```
private int threshold
```

PROCDEFAULT_HASH_F
```
private static final int PROCDEFAULT_HASH_F
```
See Also:

Constant Field Values

ifNone
```
private IRubyObject ifNone
```

MRI_PRIMES
```
private static final int[] MRI_PRIMES
```

JAVASOFT_INITIAL_CAPACITY
```
private static final int JAVASOFT_INITIAL_CAPACITY
```
See Also:

Constant Field Values

MRI_INITIAL_CAPACITY

private static final int MRI_INITIAL_CAPACITY

INITIAL_THRESHOLD
```
private static final int INITIAL_THRESHOLD
```
See Also:

Constant Field Values

MAXIMUM_CAPACITY
```
private static final int MAXIMUM_CAPACITY
```
See Also:

Constant Field Values

NO_ENTRY

public static final RubyHash.RubyHashEntry NO_ENTRY

generation
```
private int generation
```

head

private final RubyHash.RubyHashEntry head

HASH_SIGN_BIT_MASK
```
private static final int HASH_SIGN_BIT_MASK
```
See Also:

Constant Field Values

MIN_CAPA
```
private static final int MIN_CAPA
```
See Also:

Constant Field Values

ST_DEFAULT_MAX_DENSITY
```
private static final int ST_DEFAULT_MAX_DENSITY
```
See Also:

Constant Field Values

MRI_HASH
```
private static final boolean MRI_HASH
```
See Also:

Constant Field Values

MRI_HASH_RESIZE

private static final boolean MRI_HASH_RESIZE

See Also:: Constant Field Values

collisions
```
public static long collisions
```

MATCH_KEY

private static final RubyHash.EntryMatchType MATCH_KEY

MATCH_ENTRY

private static final RubyHash.EntryMatchType MATCH_ENTRY

FOUND

private static final RubyHash.Found FOUND

iteratorCount
```
private volatile int iteratorCount
```

ITERATOR_UPDATER

private static final java.util.concurrent.atomic.AtomicIntegerFieldUpdater<RubyHash> ITERATOR_UPDATER

MISMATCH

private static final RubyHash.Mismatch MISMATCH

DIRECT_KEY_VIEW

private static final RubyHash.EntryView DIRECT_KEY_VIEW

KEY_VIEW

private static final RubyHash.EntryView KEY_VIEW

DIRECT_VALUE_VIEW

private static final RubyHash.EntryView DIRECT_VALUE_VIEW

VALUE_VIEW

private static final RubyHash.EntryView VALUE_VIEW

DIRECT_ENTRY_VIEW

private static final RubyHash.EntryView DIRECT_ENTRY_VIEW

ENTRY_VIEW

private static final RubyHash.EntryView ENTRY_VIEW

Constructor Detail

RubyHash

private RubyHash(Ruby runtime,
                 RubyClass klass,
                 RubyHash other)

RubyHash

public RubyHash(Ruby runtime,
                RubyClass klass)

RubyHash

public RubyHash(Ruby runtime,
                int buckets)

RubyHash
```
public RubyHash(Ruby runtime)
```

RubyHash

public RubyHash(Ruby runtime,
                IRubyObject defaultValue)

RubyHash

public RubyHash(Ruby runtime,
                IRubyObject defaultValue,
                int buckets)

RubyHash

RubyHash(Ruby runtime,
         boolean objectSpace)

RubyHash

public RubyHash(Ruby runtime,
                java.util.Map valueMap,
                IRubyObject defaultValue)

Method Detail

createHashClass

public static RubyClass createHashClass(Ruby runtime)

getNativeTypeIndex
```
public int getNativeTypeIndex()
```
Description copied from class: RubyObject

This is overridden in the other concrete Java builtins to provide a fast way to determine what type they are. Will generally return a value from org.jruby.runtime.ClassIndex

Specified by:

getNativeTypeIndex in interface CoreObjectType

Overrides:

getNativeTypeIndex in class RubyObject

Returns:

the ClassIndex of the native type this object was constructed from

See Also:

ClassIndex

create

public static IRubyObject create(ThreadContext context,
                                 IRubyObject recv,
                                 IRubyObject[] args,
                                 Block block)

rb_hash_s_create

try_convert

public static IRubyObject try_convert(ThreadContext context,
                                      IRubyObject recv,
                                      IRubyObject args)

newHash

public static final RubyHash newHash(Ruby runtime)

rb_hash_new

newSmallHash

public static final RubyHash newSmallHash(Ruby runtime)

rb_hash_new

newHash

public static final RubyHash newHash(Ruby runtime,
                                     java.util.Map valueMap,
                                     IRubyObject defaultValue)

rb_hash_new

allocFirst
```
private final void allocFirst()
```

allocFirst

private final void allocFirst(int buckets)

alloc
```
private final void alloc()
```

alloc

private final void alloc(int buckets)

JavaSoftHashValue

private static int JavaSoftHashValue(int h)

JavaSoftBucketIndex

private static int JavaSoftBucketIndex(int h,
                                       int length)

MRIHashValue

private static int MRIHashValue(int h)

MRIBucketIndex

private static int MRIBucketIndex(int h,
                                  int length)

resize

private final void resize(int newCapacity)

JavaSoftCheckResize

private final void JavaSoftCheckResize()

overThreshold
```
private boolean overThreshold()
```

resizeAndAdjustThreshold

private void resizeAndAdjustThreshold(RubyHash.RubyHashEntry[] oldTable)

MRICheckResize
```
private final void MRICheckResize()
```

hashValue

protected static int hashValue(int h)

bucketIndex

private static int bucketIndex(int h,
                               int length)

checkResize
```
private void checkResize()
```

checkIterating
```
private void checkIterating()
```

internalPut

private final void internalPut(IRubyObject key,
                               IRubyObject value)

internalPutSmall

private final void internalPutSmall(IRubyObject key,
                                    IRubyObject value)

internalPut

protected void internalPut(IRubyObject key,
                           IRubyObject value,
                           boolean checkForExisting)

internalPutSmall

protected void internalPutSmall(IRubyObject key,
                                IRubyObject value,
                                boolean checkForExisting)

internalGet

protected IRubyObject internalGet(IRubyObject key)

internalGetEntry

protected RubyHash.RubyHashEntry internalGetEntry(IRubyObject key)

internalKeyExist

private boolean internalKeyExist(RubyHash.RubyHashEntry entry,
                                 int hash,
                                 IRubyObject key)

internalDelete

protected RubyHash.RubyHashEntry internalDelete(IRubyObject key)

internalDeleteEntry

protected RubyHash.RubyHashEntry internalDeleteEntry(RubyHash.RubyHashEntry entry)

internalDelete

private final RubyHash.RubyHashEntry internalDelete(int hash,
                                                    RubyHash.EntryMatchType matchType,
                                                    java.lang.Object obj)

internalCopyTable

private final RubyHash.RubyHashEntry[] internalCopyTable(RubyHash.RubyHashEntry destHead)

visitAll

public void visitAll(RubyHash.Visitor visitor)

visitLimited

private void visitLimited(RubyHash.Visitor visitor,
                          long size)

initialize

public IRubyObject initialize(IRubyObject[] args,
                              Block block)

rb_hash_initialize

default_value_get

@Deprecated
public IRubyObject default_value_get(ThreadContext context,
                                                 IRubyObject[] args)

Deprecated.

rb_hash_default

default_value_get

public IRubyObject default_value_get(ThreadContext context)

default_value_get

public IRubyObject default_value_get(ThreadContext context,
                                     IRubyObject arg)

default_value_set

public IRubyObject default_value_set(IRubyObject defaultValue)

rb_hash_set_default

default_proc
```
public IRubyObject default_proc()
```
rb_hash_default_proc

checkDefaultProcArity

private void checkDefaultProcArity(IRubyObject proc)

default_proc_arity_check

set_default_proc

public IRubyObject set_default_proc(IRubyObject proc)

rb_hash_set_default_proc

set_default_proc20

public IRubyObject set_default_proc20(IRubyObject proc)

modify
```
public void modify()
```
rb_hash_modify

inspectHash

private IRubyObject inspectHash(ThreadContext context)

inspect_hash

inspectHash19

private IRubyObject inspectHash19(ThreadContext context)

inspect

public IRubyObject inspect(ThreadContext context)

rb_hash_inspect

inspect19

public IRubyObject inspect19(ThreadContext context)

rb_size
```
public RubyFixnum rb_size()
```
rb_hash_size

empty_p
```
public RubyBoolean empty_p()
```
rb_hash_empty_p

to_a
```
public RubyArray to_a()
```
rb_hash_to_a

Overrides:

to_a in class RubyBasicObject

to_s

public IRubyObject to_s(ThreadContext context)

rb_hash_to_s & to_s_hash

to_s19

public IRubyObject to_s19(ThreadContext context)

rehash
```
public RubyHash rehash()
```
rb_hash_rehash

to_hash
```
public RubyHash to_hash()
```
rb_hash_to_hash

to_h

public RubyHash to_h(ThreadContext context)

convertToHash
```
public RubyHash convertToHash()
```
Description copied from class: RubyBasicObject

Tries to convert this object to a Ruby Hash using the "to_hash" method.

Specified by:

convertToHash in interface IRubyObject

Overrides:

convertToHash in class RubyBasicObject

Returns:

fastASet

public final void fastASet(IRubyObject key,
                           IRubyObject value)

fastASetChained

public final RubyHash fastASetChained(IRubyObject key,
                                      IRubyObject value)

fastASetCheckString

public final void fastASetCheckString(Ruby runtime,
                                      IRubyObject key,
                                      IRubyObject value)

fastASetSmallCheckString

public final void fastASetSmallCheckString(Ruby runtime,
                                           IRubyObject key,
                                           IRubyObject value)

op_aset

public IRubyObject op_aset(ThreadContext context,
                           IRubyObject key,
                           IRubyObject value)

rb_hash_aset

op_asetForString

protected void op_asetForString(Ruby runtime,
                                RubyString key,
                                IRubyObject value)

op_asetSmallForString

protected void op_asetSmallForString(Ruby runtime,
                                     RubyString key,
                                     IRubyObject value)

fastARef

public final IRubyObject fastARef(IRubyObject key)

compare

public RubyBoolean compare(ThreadContext context,
                           MethodNames method,
                           IRubyObject other)

op_equal

public IRubyObject op_equal(ThreadContext context,
                            IRubyObject other)

rb_hash_equal

Specified by:: op_equal in interface IRubyObject
Overrides:: op_equal in class RubyBasicObject

op_eql19

public IRubyObject op_eql19(ThreadContext context,
                            IRubyObject other)

rb_hash_eql

op_aref

public IRubyObject op_aref(ThreadContext context,
                           IRubyObject key)

rb_hash_aref

hash
```
public RubyFixnum hash()
```
rb_hash_hash

Overrides:

hash in class RubyBasicObject

hash19
```
public RubyFixnum hash19()
```
rb_hash_hash

fetch

public IRubyObject fetch(ThreadContext context,
                         IRubyObject[] args,
                         Block block)

rb_hash_fetch

fetch

public IRubyObject fetch(ThreadContext context,
                         IRubyObject key,
                         Block block)

fetch

public IRubyObject fetch(ThreadContext context,
                         IRubyObject key,
                         IRubyObject _default,
                         Block block)

has_key_p

public RubyBoolean has_key_p(IRubyObject key)

rb_hash_has_key

hasValue

private boolean hasValue(ThreadContext context,
                         IRubyObject expected)

has_value_p

public RubyBoolean has_value_p(ThreadContext context,
                               IRubyObject expected)

rb_hash_has_value

iteratorEntry
```
private void iteratorEntry()
```

iteratorExit
```
private void iteratorExit()
```

iteratorEntrySync
```
private void iteratorEntrySync()
```

iteratorExitSync
```
private void iteratorExitSync()
```

iteratorVisitAll

private void iteratorVisitAll(RubyHash.Visitor visitor)

eachCommon

public RubyHash eachCommon(ThreadContext context,
                           Block block)

rb_hash_each

each

public IRubyObject each(ThreadContext context,
                        Block block)

each19

public IRubyObject each19(ThreadContext context,
                          Block block)

each_pairCommon

public RubyHash each_pairCommon(ThreadContext context,
                                Block block,
                                boolean oneNine)

rb_hash_each_pair

each_pair

public IRubyObject each_pair(ThreadContext context,
                             Block block)

each_valueCommon

public RubyHash each_valueCommon(ThreadContext context,
                                 Block block)

rb_hash_each_value

each_value

public IRubyObject each_value(ThreadContext context,
                              Block block)

each_keyCommon

public RubyHash each_keyCommon(ThreadContext context,
                               Block block)

rb_hash_each_key

each_key

public IRubyObject each_key(ThreadContext context,
                            Block block)

select_bang

public IRubyObject select_bang(ThreadContext context,
                               Block block)

keep_if

public IRubyObject keep_if(ThreadContext context,
                           Block block)

keep_ifCommon

public boolean keep_ifCommon(ThreadContext context,
                             Block block)

sort

public IRubyObject sort(ThreadContext context,
                        Block block)

rb_hash_sort

index

public IRubyObject index(ThreadContext context,
                         IRubyObject expected)

rb_hash_index

index19

public IRubyObject index19(ThreadContext context,
                           IRubyObject expected)

key

public IRubyObject key(ThreadContext context,
                       IRubyObject expected)

internalIndex

private IRubyObject internalIndex(ThreadContext context,
                                  IRubyObject expected)

indices

public RubyArray indices(ThreadContext context,
                         IRubyObject[] indices)

rb_hash_indexes

keys
```
public RubyArray keys()
```
rb_hash_keys

rb_values
```
public RubyArray rb_values()
```
rb_hash_values

shift

public IRubyObject shift(ThreadContext context)

rb_hash_shift

fastDelete

public final boolean fastDelete(IRubyObject key)

delete

public IRubyObject delete(ThreadContext context,
                          IRubyObject key,
                          Block block)

rb_hash_delete

select

public IRubyObject select(ThreadContext context,
                          Block block)

rb_hash_select

select19

public IRubyObject select19(ThreadContext context,
                            Block block)

delete_ifInternal

public RubyHash delete_ifInternal(ThreadContext context,
                                  Block block)

rb_hash_delete_if

delete_if

public IRubyObject delete_if(ThreadContext context,
                             Block block)

rejectInternal

public RubyHash rejectInternal(ThreadContext context,
                               Block block)

rb_hash_reject

reject

public IRubyObject reject(ThreadContext context,
                          Block block)

reject_bangInternal

public IRubyObject reject_bangInternal(ThreadContext context,
                                       Block block)

rb_hash_reject_bang

reject_bang

public IRubyObject reject_bang(ThreadContext context,
                               Block block)

rb_clear
```
public RubyHash rb_clear()
```
rb_hash_clear

invert

public RubyHash invert(ThreadContext context)

rb_hash_invert

merge_bang

public RubyHash merge_bang(ThreadContext context,
                           IRubyObject other,
                           Block block)

rb_hash_update

merge_bang19

public RubyHash merge_bang19(ThreadContext context,
                             IRubyObject other,
                             Block block)

rb_hash_update

merge

public RubyHash merge(ThreadContext context,
                      IRubyObject other,
                      Block block)

rb_hash_merge

initialize_copy

public RubyHash initialize_copy(ThreadContext context,
                                IRubyObject other)

rb_hash_replace

initialize_copy19

public RubyHash initialize_copy19(ThreadContext context,
                                  IRubyObject other)

rb_hash_replace

replace

public RubyHash replace(ThreadContext context,
                        IRubyObject other)

rb_hash_replace

replace19

public RubyHash replace19(ThreadContext context,
                          IRubyObject other)

replaceCommon

private RubyHash replaceCommon(ThreadContext context,
                               IRubyObject other,
                               RubyHash.Visitor visitor)

replaceCommon19

private RubyHash replaceCommon19(ThreadContext context,
                                 IRubyObject other,
                                 RubyHash.Visitor visitor)

values_at

public RubyArray values_at(ThreadContext context,
                           IRubyObject[] args)

rb_hash_values_at

assoc

public IRubyObject assoc(ThreadContext context,
                         IRubyObject obj)

rassoc

public IRubyObject rassoc(ThreadContext context,
                          IRubyObject obj)

flatten

public IRubyObject flatten(ThreadContext context)

flatten

public IRubyObject flatten(ThreadContext context,
                           IRubyObject level)

getCompareByIdentity

public IRubyObject getCompareByIdentity(ThreadContext context)

getCompareByIdentity_p

public IRubyObject getCompareByIdentity_p(ThreadContext context)

dup

public IRubyObject dup(ThreadContext context)

rbClone

public IRubyObject rbClone(ThreadContext context)

dupFast
```
public RubyHash dupFast(ThreadContext context)
```
A lightweight dup for internal use that does not dispatch to initialize_copy nor rehash the keys. Intended for use in dup'ing keyword args for processing.

Parameters:

context -

Returns:

hasDefaultProc
```
public boolean hasDefaultProc()
```

getIfNone
```
public IRubyObject getIfNone()
```

marshalTo

public static void marshalTo(RubyHash hash,
                             MarshalStream output)
                      throws java.io.IOException

Throws:: java.io.IOException

unmarshalFrom

public static RubyHash unmarshalFrom(UnmarshalStream input,
                                     boolean defaultValue)
                              throws java.io.IOException

Throws:: java.io.IOException

getJavaClass
```
public java.lang.Class getJavaClass()
```
Description copied from class: RubyBasicObject

Will return the Java interface that most closely can represent this object, when working through JAva integration translations.

Specified by:

getJavaClass in interface IRubyObject

Overrides:

getJavaClass in class RubyBasicObject

Returns:

Class

size
```
public int size()
```
Specified by:

size in interface java.util.Map

isEmpty
```
public boolean isEmpty()
```
Specified by:

isEmpty in interface java.util.Map

containsKey
```
public boolean containsKey(java.lang.Object key)
```
Specified by:

containsKey in interface java.util.Map

containsValue
```
public boolean containsValue(java.lang.Object value)
```
Specified by:

containsValue in interface java.util.Map

get

public java.lang.Object get(java.lang.Object key)

Specified by:: get in interface java.util.Map

put

public java.lang.Object put(java.lang.Object key,
                            java.lang.Object value)

Specified by:: put in interface java.util.Map

remove

public java.lang.Object remove(java.lang.Object key)

Specified by:: remove in interface java.util.Map

putAll
```
public void putAll(java.util.Map map)
```
Specified by:

putAll in interface java.util.Map

clear
```
public void clear()
```
Specified by:

clear in interface java.util.Map

equals
```
public boolean equals(java.lang.Object other)
```
Description copied from class: RubyObject

This method is just a wrapper around the Ruby "==" method, provided so that RubyObjects can be used as keys in the Java HashMap object underlying RubyHash.

Specified by:

equals in interface java.util.Map

Overrides:

equals in class RubyObject

keySet
```
public java.util.Set keySet()
```
Specified by:

keySet in interface java.util.Map

directKeySet
```
public java.util.Set directKeySet()
```

values
```
public java.util.Collection values()
```
Specified by:

values in interface java.util.Map

directValues

public java.util.Collection directValues()

entrySet
```
public java.util.Set entrySet()
```
Specified by:

entrySet in interface java.util.Map

directEntrySet
```
public java.util.Set directEntrySet()
```

concurrentModification

private final RaiseException concurrentModification()

isComparedByIdentity
```
protected boolean isComparedByIdentity()
```
Is this object compared by identity or not? Shortcut for doing getFlag(COMPARE_BY_IDENTITY_F).

Returns:

true if this object is compared by identity, false otherwise

setComparedByIdentity
```
public void setComparedByIdentity(boolean comparedByIdentity)
```
Sets whether this object is compared by identity or not. Shortcut for doing setFlag(COMPARE_BY_IDENTITY_F, frozen).

Parameters:

comparedByIdentity - should this object be compared by identity?

op_aset19

@Deprecated
public IRubyObject op_aset19(ThreadContext context,
                                         IRubyObject key,
                                         IRubyObject value)

Deprecated.

aset

public IRubyObject aset(IRubyObject key,
                        IRubyObject value)

Deprecated. use RubyHash.op_aset instead

Note: this is included as a compatibility measure for AR-JDBC

aref
```
public IRubyObject aref(IRubyObject key)
```
Deprecated. use RubyHash.op_aref instead

Note: this is included as a compatibility measure for Mongrel+JRuby

fastASetCheckString19

@Deprecated
public final void fastASetCheckString19(Ruby runtime,
                                                    IRubyObject key,
                                                    IRubyObject value)

Deprecated.

fastASetSmallCheckString19

@Deprecated
public final void fastASetSmallCheckString19(Ruby runtime,
                                                         IRubyObject key,
                                                         IRubyObject value)

Deprecated.

op_aset

@Deprecated
public IRubyObject op_aset(IRubyObject key,
                                       IRubyObject value)

Deprecated.

Class RubyHash

Nested Class Summary

Nested classes/interfaces inherited from class org.jruby.RubyObject

Nested classes/interfaces inherited from class org.jruby.RubyBasicObject

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Fields inherited from class org.jruby.RubyObject

Fields inherited from class org.jruby.RubyBasicObject

Fields inherited from interface org.jruby.runtime.builtin.IRubyObject

Constructor Summary

Method Summary

Methods inherited from class org.jruby.RubyObject

Methods inherited from class org.jruby.RubyBasicObject

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Field Detail

DEFAULT_INSPECT_STR_SIZE

HASH_ALLOCATOR

table

size

threshold

PROCDEFAULT_HASH_F

ifNone

MRI_PRIMES

JAVASOFT_INITIAL_CAPACITY

MRI_INITIAL_CAPACITY

INITIAL_THRESHOLD

MAXIMUM_CAPACITY

NO_ENTRY

generation

head

HASH_SIGN_BIT_MASK

MIN_CAPA

ST_DEFAULT_MAX_DENSITY

MRI_HASH

MRI_HASH_RESIZE

collisions

MATCH_KEY

MATCH_ENTRY

FOUND

iteratorCount

ITERATOR_UPDATER

MISMATCH

DIRECT_KEY_VIEW

KEY_VIEW

DIRECT_VALUE_VIEW

VALUE_VIEW

DIRECT_ENTRY_VIEW

ENTRY_VIEW

Constructor Detail

RubyHash

RubyHash

RubyHash

RubyHash

RubyHash

RubyHash

RubyHash

RubyHash

Method Detail

createHashClass

getNativeTypeIndex

create

try_convert

newHash

newSmallHash

newHash

allocFirst

allocFirst

alloc

alloc

JavaSoftHashValue

JavaSoftBucketIndex

MRIHashValue

MRIBucketIndex

resize

JavaSoftCheckResize

overThreshold

resizeAndAdjustThreshold

MRICheckResize

hashValue