RubyBasicObject (JRuby Core 9.0.1.0 API)

java.lang.Object
- org.jruby.RubyBasicObject

All Implemented Interfaces:

Serializable, Cloneable, Comparable<IRubyObject>, InstanceVariables, InternalVariables, IRubyObject, CoreObjectType

Direct Known Subclasses:

RubyObject
```
public class RubyBasicObject
extends Object
implements Cloneable, IRubyObject, Serializable, Comparable<IRubyObject>, CoreObjectType, InstanceVariables, InternalVariables
```
RubyBasicObject is the only implementation of the IRubyObject. Every Ruby object in JRuby is represented by something that is an instance of RubyBasicObject. In the core class implementations, this means doing a subclass that extends RubyBasicObject. In other cases it means using a simple RubyBasicObject instance and its data fields to store specific information about the Ruby object. Some care has been taken to make the implementation be as monomorphic as possible, so that the Java Hotspot engine can improve performance of it. That is the reason for several patterns that might seem odd in this class. The IRubyObject interface used to have lots of methods for different things, but these have now mostly been refactored into several interfaces that gives access to that specific part of the object. This gives us the possibility to switch out that subsystem without changing interfaces again. For example, instance variable and internal variables are handled this way, but the implementation in RubyObject only returns "this" in getInstanceVariables() and getInternalVariables(). Methods that are implemented here, such as "initialize" should be implemented with care; reification of Ruby classes into Java classes can produce conflicting method names in rare cases. See JRUBY-5906 for an example.

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RubyBasicObject.Finalizer
Class that keeps track of the finalizers for the object under operation.

Nested Classes
Modifier and Type	Class and Description
`static class`	`RubyBasicObject.Finalizer` Class that keeps track of the finalizers for the object under operation.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALL_F`
`static ObjectAllocator`	`BASICOBJECT_ALLOCATOR` Default allocator instance for all Ruby objects.
`static int`	`COMPARE_BY_IDENTITY_F`
`static String`	`ERR_INSECURE_SET_INST_VAR` The error message used when some one tries to modify an instance variable in a high security setting.
`static int`	`FALSE_F`
`static int`	`FL_USHIFT`
`protected int`	`flags` object flags
`static int`	`FROZEN_F`
`static int`	`IS_OVERLAID_F`
`protected RubyClass`	`metaClass` The class of this object
`static IRubyObject`	`NEVER` A value that is used as a null sentinel in among other places the RubyArray implementation.
`static int`	`NIL_F` This flag is a bit funny.
`static int`	`REFINED_MODULE_F`
`static long`	`STAMP_OFFSET` offset of the varTableTamp field in RubyBasicObject
`static int`	`TAINTED_F`
`static IRubyObject`	`UNDEF` A value that specifies an undefined value.
`static int`	`UNTRUST_F` Deprecated.
`static int`	`USER0_F`
`static int`	`USER1_F`
`static int`	`USER2_F`
`static int`	`USER3_F`
`static int`	`USER4_F`
`static int`	`USER5_F`
`static int`	`USER6_F`
`static int`	`USER7_F`
`static int`	`USER8_F`
`static int`	`USER9_F`
`static int`	`USERA_F`
`static long`	`VAR_TABLE_OFFSET` offset of the varTable field in RubyBasicObject
`Object[]`	`varTable` variable table, lazily allocated as needed (if needed)
`int`	`varTableStamp` locking stamp for Unsafe ops updating the vartable

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

Constructor Summary

Constructors
Modifier	Constructor and Description
	`RubyBasicObject(RubyClass metaClass)` Path for objects that don't taint and don't enter objectspace.
	`RubyBasicObject(Ruby runtime, RubyClass metaClass)` Standard path for object creation.
`protected`	`RubyBasicObject(Ruby runtime, RubyClass metaClass, boolean useObjectSpace)` Path for objects who want to decide whether they don't want to be in ObjectSpace even when it is on.
`protected`	`RubyBasicObject(Ruby runtime, RubyClass metaClass, boolean useObjectSpace, boolean canBeTainted)` Deprecated.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addFinalizer(IRubyObject f)` Adds the specified object as a finalizer for this object.
`IRubyObject`	`anyToString()` Internal method that helps to convert any object into the format of a class name and a hex string inside of #<>.
`String`	`asJavaString()` rb_to_id Will try to convert this object to a String using the Ruby "to_str" if the object isn't already a String.
`RubyString`	`asString()` rb_obj_as_string First converts this object into a String using the "to_s" method, infects it with the current taint and returns it.
`IRubyObject`	`callMethod(String name)`
`IRubyObject`	`callMethod(String name, IRubyObject... args)`
`IRubyObject`	`callMethod(ThreadContext context, int methodIndex, String name)` Deprecated.
`IRubyObject`	`callMethod(ThreadContext context, int methodIndex, String name, IRubyObject arg)` Deprecated.
`IRubyObject`	`callMethod(ThreadContext context, String name)` Will invoke a named method with no arguments and no block.
`IRubyObject`	`callMethod(ThreadContext context, String name, IRubyObject arg)` Will invoke a named method with one argument and no block with functional invocation.
`IRubyObject`	`callMethod(ThreadContext context, String name, IRubyObject[] args)` Will invoke a named method with the supplied arguments and no block with functional invocation.
`IRubyObject`	`callMethod(ThreadContext context, String name, IRubyObject[] args, Block block)` Will invoke a named method with the supplied arguments and supplied block with functional invocation.
`IRubyObject`	`callSuper(ThreadContext context, IRubyObject[] args, Block block)` Deprecated.
`IRubyObject`	`checkArrayType()` rb_check_array_type Returns the result of trying to convert this object to an Array with "to_ary".
`IRubyObject`	`checkCallMethod(ThreadContext context, String name)` Will invoke a named method with no arguments and no block if that method or a custom method missing exists.
`void`	`checkFrozen()` The actual method that checks frozen with the default frozen message from MRI.
`IRubyObject`	`checkStringType()` rb_check_string_type Tries to return a coerced string representation of this object, using "to_str".
`IRubyObject`	`checkStringType19()` rb_check_string_type Tries to return a coerced string representation of this object, using "to_str".
`int`	`compareTo(IRubyObject other)` Compares this Ruby object with another.
`RubyArray`	`convertToArray()` Tries to convert this object to a Ruby Array using the "to_ary" method.
`RubyFloat`	`convertToFloat()` Tries to convert this object to a Ruby Float using the "to_f" method.
`RubyHash`	`convertToHash()` Tries to convert this object to a Ruby Hash using the "to_hash" method.
`RubyInteger`	`convertToInteger()` Tries to convert this object to a Ruby Integer using the "to_int" method.
`RubyInteger`	`convertToInteger(int methodIndex, String convertMethod)` Deprecated.
`RubyInteger`	`convertToInteger(String convertMethod)` Tries to convert this object to a Ruby Integer using the supplied conversion method.
`RubyString`	`convertToString()` Tries to convert this object to a Ruby String using the "to_str" method.
`void`	`copyInstanceVariablesInto(InstanceVariables other)` Copies all instance variables from the given object into the receiver
`void`	`copySpecialInstanceVariables(IRubyObject clone)` Lots of MRI objects keep their state in non-lookupable ivars (e:g.
`static RubyClass`	`createBasicObjectClass(Ruby runtime, RubyClass objectClass)` Will create the Ruby class Object in the runtime specified.
`Object`	`dataGetStruct()` Our version of Data_Get_Struct.
`Object`	`dataGetStructChecked()`
`void`	`dataWrapStruct(Object obj)` Our version of Data_Wrap_Struct.
`IRubyObject`	`display(ThreadContext context, IRubyObject[] args)` rb_obj_display call-seq: obj.display(port=$>) => nil Prints obj on the given port (default `$>`).
`IRubyObject`	`dup()` RubyMethod dup.
`void`	`ensureInstanceVariablesSettable()` Makes sure that instance variables can be set on this object, including information about whether this object is frozen, or tainted.
`IRubyObject`	`eql_p(IRubyObject obj)` rb_obj_equal Just like "==" and "equal?", "eql?" will use identity equality for Object.
`boolean`	`eql(IRubyObject other)` method used for Hash key comparison (specialized for String, Symbol and Fixnum) Will by default just call the Ruby method "eql?"
`IRubyObject`	`equal_p(ThreadContext context, IRubyObject obj)` rb_obj_equal Will use Java identity equality.
`IRubyObject`	`equal_p19(ThreadContext context, IRubyObject other)`
`protected static boolean`	`equalInternal(ThreadContext context, IRubyObject that, IRubyObject other)` Helper method for checking equality, first using Java identity equality, and then calling the "==" method.
`boolean`	`equals(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`	`evalUnder(ThreadContext context, RubyModule under, RubyString src, String file, int line, EvalType evalType)` Evaluates the string src with self set to the current object, using the module under as the context.
`IRubyObject`	`extend(IRubyObject[] args)` rb_obj_extend call-seq: obj.extend(module, ...) => obj Adds to _obj_ the instance methods from each module given as a parameter.
`IRubyObject`	`fastGetInstanceVariable(String internedName)` Deprecated.
`Object`	`fastGetInternalVariable(String internedName)` Deprecated.
`boolean`	`fastHasInstanceVariable(String internedName)` Deprecated.
`boolean`	`fastHasInternalVariable(String internedName)` Deprecated.
`IRubyObject`	`fastSetInstanceVariable(String internedName, IRubyObject value)` Deprecated.
`void`	`fastSetInternalVariable(String internedName, Object value)` Deprecated.
`IRubyObject`	`freeze(ThreadContext context)` rb_obj_freeze call-seq: obj.freeze => obj Prevents further modifications to obj.
`RubyBoolean`	`frozen_p(ThreadContext context)` rb_obj_frozen_p call-seq: obj.frozen? => true or false Returns the freeze status of obj.
`Object`	`getFFIHandle()`
`boolean`	`getFlag(int flag)` Get the value of a custom flag on this object.
`protected RubyModule`	`getInstanceEvalClass()`
`IRubyObject`	`getInstanceVariable(String name)` Returns the named instance variable if present, else null.
`List<Variable<IRubyObject>>`	`getInstanceVariableList()` Gets a list of all variables in this object.
`List<String>`	`getInstanceVariableNameList()` Gets a name list of all variables in this object.
`InstanceVariables`	`getInstanceVariables()` Dummy method to avoid a cast, and to avoid polluting the IRubyObject interface with all the instance variable management methods.
`Object`	`getInternalVariable(String name)` Returns the named internal variable if present, else null.
`InternalVariables`	`getInternalVariables()` Dummy method to avoid a cast, and to avoid polluting the IRubyObject interface with all the instance variable management methods.
`Class`	`getJavaClass()` Will return the Java interface that most closely can represent this object, when working through JAva integration translations.
`RubyClass`	`getMetaClass()` if exist return the meta-class else return the type of the object.
`ClassIndex`	`getNativeClassIndex()` Return the ClassIndex for the native type this object was constructed from.
`Object`	`getNativeHandle()` Deprecated.
`int`	`getNativeTypeIndex()` Deprecated.
`protected long`	`getObjectId()` The logic here is to use the special objectId accessor slot from the parent as a lazy store for an object ID.
`Ruby`	`getRuntime()` Will return the runtime that this object is associated with.
`RubyClass`	`getSingletonClass()` rb_singleton_class Note: this method is specialized for RubyFixnum, RubySymbol, RubyNil and RubyBoolean Will either return the existing singleton class for this object, or create a new one and return that.
`protected RubyClass`	`getSingletonClassClone()` rb_singleton_class_clone Will make sure that if the current objects class is a singleton, it will get cloned.
`RubyClass`	`getType()` RubyMethod getType.
`Object`	`getVariable(int index)`
`int`	`getVariableCount()` Deprecated.
`List<Variable<Object>>`	`getVariableList()` Gets a list of all variables in this object.
`List<String>`	`getVariableNameList()` Gets a name list of all variables in this object.
`RubyFixnum`	`hash()` rb_obj_id Will return the hash code of this object.
`int`	`hashCode()` Override the Object#hashCode method to make sure that the Ruby hash is actually used as the hashcode for Ruby objects.
`IRubyObject`	`hashyInspect()`
`boolean`	`hasInstanceVariable(String name)` Returns true if object has the named instance variable.
`boolean`	`hasInternalVariable(String name)` Returns true if object has the named internal variable.
`boolean`	`hasVariables()` Returns true if object has any variables
`IRubyObject`	`id()` rb_obj_id Return the internal id of an object.
`IRubyObject`	`infectBy(IRubyObject obj)` OBJ_INFECT Infects this object with traits from the argument obj.
`IRubyObject`	`initialize_copy(IRubyObject original)` rb_obj_init_copy Initializes this object as a copy of the original, that is the parameter to this object.
`IRubyObject`	`initialize()` Deprecated.
`IRubyObject`	`initialize19(ThreadContext context)`
`IRubyObject`	`inspect()` rb_obj_inspect call-seq: obj.inspect => string Returns a string containing a human-readable representation of obj.
`protected int`	`inspectHashCode()` For most objects, the hash used in the default #inspect is just the identity hashcode of the actual object.
`IRubyObject`	`instance_eval(ThreadContext context, Block block)` rb_obj_instance_eval call-seq: obj.instance_eval(string [, filename [, lineno]] ) => obj obj.instance_eval {\| \| block } => obj Evaluates a string containing Ruby source code, or the given block, within the context of the receiver (_obj_).
`IRubyObject`	`instance_eval(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`instance_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`instance_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block)`
`IRubyObject`	`instance_eval19(ThreadContext context, Block block)`
`IRubyObject`	`instance_eval19(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`instance_eval19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`instance_eval19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block)`
`IRubyObject`	`instance_exec(ThreadContext context, IRubyObject[] args, Block block)` rb_obj_instance_exec call-seq: obj.instance_exec(arg...) {\|var...\| block } => obj Executes the given block within the context of the receiver (_obj_).
`IRubyObject`	`instance_exec19(ThreadContext context, IRubyObject[] args, Block block)`
`RubyBoolean`	`instance_of_p(ThreadContext context, IRubyObject type)` rb_obj_is_instance_of call-seq: obj.instance_of?(class) => true or false Returns `true` if obj is an instance of the given class.
`IRubyObject`	`instance_variable_defined_p(ThreadContext context, IRubyObject name)` rb_obj_ivar_defined call-seq: obj.instance_variable_defined?(symbol) => true or false Returns `true` if the given instance variable is defined in obj.
`IRubyObject`	`instance_variable_get(ThreadContext context, IRubyObject name)` rb_obj_ivar_get call-seq: obj.instance_variable_get(symbol) => obj Returns the value of the given instance variable, or nil if the instance variable is not set.
`IRubyObject`	`instance_variable_set(IRubyObject name, IRubyObject value)` rb_obj_ivar_set call-seq: obj.instance_variable_set(symbol, obj) => obj Sets the instance variable names by symbol to object, thereby frustrating the efforts of the class's author to attempt to provide proper encapsulation.
`RubyArray`	`instance_variables(ThreadContext context)` rb_obj_instance_variables call-seq: obj.instance_variables => array Returns an array of instance variable names for the receiver.
`RubyArray`	`instance_variables19(ThreadContext context)`
`boolean`	`isBuiltin(String methodName)` A method to determine whether the method named by methodName is a builtin method.
`boolean`	`isClass()` Specifically polymorphic method that are meant to be overridden by classes to specify that they are classes in an easy way.
`boolean`	`isFalse()` Is this value a falsey value or not? Based on the `FALSE_F` flag.
`boolean`	`isFrozen()` Is this value frozen or not? Shortcut for doing getFlag(FROZEN_F).
`boolean`	`isImmediate()` Is object immediate (def: Fixnum, Symbol, true, false, nil?).
`boolean`	`isModule()` Specifically polymorphic method that are meant to be overridden by modules to specify that they are modules in an easy way.
`boolean`	`isNil()` Does this object represent nil? See the docs for the `NIL_F` flag for more information.
`boolean`	`isSpecialConst()`
`boolean`	`isTaint()` Gets the taint.
`boolean`	`isTrue()` Is this value a truthy value or not? Based on the `FALSE_F` flag.
`boolean`	`isUntrusted()` Deprecated.
`RubyBoolean`	`kind_of_p(ThreadContext context, IRubyObject type)` rb_obj_is_kind_of call-seq: obj.is_a?(class) => true or false obj.kind_of?(class) => true or false Returns `true` if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.
`RubyClass`	`makeMetaClass(RubyClass superClass)` rb_make_metaclass Will create a new meta class, insert this in the chain of classes for this specific object, and return the generated meta class.
`static IRubyObject`	`method_missing19(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block)`
`IRubyObject`	`method(IRubyObject symbol)` rb_obj_method call-seq: obj.method(sym) => method Looks up the named method as a receiver in obj, returning a `Method` object (or raising `NameError`).
`IRubyObject`	`method19(IRubyObject symbol)`
`IRubyObject`	`methods(ThreadContext context, IRubyObject[] args)` rb_obj_methods call-seq: obj.methods => array Returns a list of the names of methods publicly accessible in obj.
`IRubyObject`	`methods(ThreadContext context, IRubyObject[] args, boolean useSymbols)`
`IRubyObject`	`methods19(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`nil_p(ThreadContext context)` rb_false call_seq: nil.nil? => true .nil? => false Only the object nil responds `true` to `nil?`.
`protected static int`	`nonFixnumHashCode(IRubyObject hashValue)`
`protected static boolean`	`OBJ_INIT_COPY(IRubyObject obj, IRubyObject orig)`
`protected static void`	`objInitCopy(IRubyObject obj, IRubyObject orig)`
`IRubyObject`	`op_cmp(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_eqq(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_equal_19(ThreadContext context, IRubyObject obj)` rb_obj_equal Will by default use identity equality to compare objects.
`IRubyObject`	`op_equal(ThreadContext context, IRubyObject obj)`
`IRubyObject`	`op_match(ThreadContext context, IRubyObject arg)` rb_obj_pattern_match call-seq: obj =~ other => false Pattern Match---Overridden by descendents (notably `Regexp` and `String`) to provide meaningful pattern-match semantics.
`IRubyObject`	`op_match19(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`op_not_equal(ThreadContext context, IRubyObject other)`
`IRubyObject`	`op_not_match(ThreadContext context, IRubyObject arg)`
`IRubyObject`	`op_not(ThreadContext context)`
`IRubyObject`	`private_methods(ThreadContext context, IRubyObject[] args)` rb_obj_private_methods call-seq: obj.private_methods(all=true) => array Returns the list of private methods accessible to obj.
`IRubyObject`	`private_methods19(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`protected_methods(ThreadContext context, IRubyObject[] args)` rb_obj_protected_methods call-seq: obj.protected_methods(all=true) => array Returns the list of protected methods accessible to obj.
`IRubyObject`	`protected_methods19(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`public_methods(ThreadContext context, IRubyObject[] args)` rb_obj_public_methods call-seq: obj.public_methods(all=true) => array Returns the list of public methods accessible to obj.
`IRubyObject`	`public_methods19(ThreadContext context, IRubyObject[] args)`
`IRubyObject`	`rbClone()` RubyMethod rbClone.
`static IRubyObject`	`rbInspect(ThreadContext context, IRubyObject obj)`
`IRubyObject`	`remove_instance_variable(ThreadContext context, IRubyObject name, Block block)` rb_obj_remove_instance_variable call-seq: obj.remove_instance_variable(symbol) => obj Removes the named instance variable from obj, returning that variable's value.
`void`	`removeFinalizers()` Remove all the finalizers for this object.
`IRubyObject`	`removeInstanceVariable(String name)` Removes the named instance variable, if present, returning its value.
`Object`	`removeInternalVariable(String name)` Removes the named internal variable, if present, returning its value.
`RubyBoolean`	`respond_to_p(IRubyObject mname)` obj_respond_to respond_to?( aSymbol, includePriv=false ) -> true or false Returns true if this object responds to the given method.
`RubyBoolean`	`respond_to_p(IRubyObject mname, IRubyObject includePrivate)`
`RubyBoolean`	`respond_to_p19(IRubyObject mname)`
`RubyBoolean`	`respond_to_p19(IRubyObject mname, IRubyObject includePrivate)`
`boolean`	`respondsTo(String name)` Does this object respond to the specified message? Uses a shortcut if it can be proved that respond_to? and respond_to_missing? haven't been overridden.
`boolean`	`respondsToMissing(String name)` Does this object respond to the specified message via "method_missing?"
`boolean`	`respondsToMissing(String name, boolean incPrivate)` Does this object respond to the specified message via "method_missing?"
`IRubyObject`	`send(ThreadContext context, Block block)` rb_f_send send( aSymbol [, args ]* ) -> anObject Invokes the method identified by aSymbol, passing it any arguments specified.
`IRubyObject`	`send(ThreadContext context, IRubyObject[] args, Block block)`
`IRubyObject`	`send(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`send(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`send(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block)`
`IRubyObject`	`send19(ThreadContext context, IRubyObject[] args, Block block)`
`IRubyObject`	`send19(ThreadContext context, IRubyObject arg0, Block block)`
`IRubyObject`	`send19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block)`
`IRubyObject`	`send19(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block)`
`void`	`setFFIHandle(Object value)`
`void`	`setFlag(int flag, boolean set)` Sets or unsets a flag on this object.
`void`	`setFrozen(boolean frozen)` Sets whether this object is frozen or not.
`IRubyObject`	`setInstanceVariable(String name, IRubyObject value)` rb_iv_set / rb_ivar_set
`void`	`setInternalVariable(String name, Object value)` Sets the named internal variable to the specified value.
`void`	`setMetaClass(RubyClass metaClass)` Makes it possible to change the metaclass of an object.
`void`	`setNativeHandle(Object value)` Deprecated.
`void`	`setTaint(boolean taint)` Sets the taint flag.
`void`	`setUntrusted(boolean untrusted)` Deprecated.
`void`	`setVariable(int index, Object value)`
`static IRubyObject`	`singleton_method_added19(ThreadContext context, IRubyObject recv, IRubyObject symbolId, Block block)`
`static IRubyObject`	`singleton_method_removed19(ThreadContext context, IRubyObject recv, IRubyObject symbolId, Block block)`
`static IRubyObject`	`singleton_method_undefined19(ThreadContext context, IRubyObject recv, IRubyObject symbolId, Block block)`
`RubyArray`	`singleton_methods(ThreadContext context, IRubyObject[] args)` rb_obj_singleton_methods call-seq: obj.singleton_methods(all=true) => array Returns an array of the names of singleton methods for obj.
`IRubyObject`	`specificEval(ThreadContext context, RubyModule mod, Block block, EvalType evalType)` specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments.
`IRubyObject`	`specificEval(ThreadContext context, RubyModule mod, IRubyObject arg, Block block, EvalType evalType)` specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments.
`IRubyObject`	`specificEval(ThreadContext context, RubyModule mod, IRubyObject arg0, IRubyObject arg1, Block block, EvalType evalType)` specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments.
`IRubyObject`	`specificEval(ThreadContext context, RubyModule mod, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block, EvalType evalType)` specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments.
`void`	`syncVariables(IRubyObject other)` Sync one this object's variables with other's - this is used to make rbClone work correctly.
`void`	`syncVariables(List<Variable<Object>> variables)` Deprecated.
`protected void`	`taint(Ruby runtime)`
`IRubyObject`	`taint(ThreadContext context)` rb_obj_taint call-seq: obj.taint -> obj Marks obj as tainted---if the `$SAFE` level is set appropriately, many method calls which might alter the running programs environment will refuse to accept tainted strings.
`RubyBoolean`	`tainted_p(ThreadContext context)` rb_obj_tainted call-seq: obj.tainted? => true or false Returns `true` if the object is tainted.
`protected void`	`testFrozen()` rb_frozen_class_p Helper to test whether this object is frozen, and if it is will throw an exception based on the message.
`protected void`	`testFrozen(String message)` rb_frozen_class_p Helper to test whether this object is frozen, and if it is will throw an exception based on the message.
`RubyArray`	`to_a()` rb_any_to_a call-seq: obj.to_a -> anArray Returns an array representation of obj.
`IRubyObject`	`to_s()` rb_any_to_s call-seq: obj.to_s => string Returns a string representing obj.
`Object`	`toJava(Class target)` Convert the object to the specified Java class, if possible.
`IRubyObject`	`trust(ThreadContext context)` Deprecated.
`RubyClass`	`type_deprecated()` rb_obj_type The deprecated version of type, that emits a deprecation warning.
`RubyClass`	`type()` rb_obj_class Returns the real class of this object, excluding any singleton/meta class in the inheritance chain.
`IRubyObject`	`untaint(ThreadContext context)` rb_obj_untaint call-seq: obj.untaint => obj Removes the taint from obj.
`IRubyObject`	`untrust(ThreadContext context)` Deprecated.
`RubyBoolean`	`untrusted_p(ThreadContext context)` Deprecated.
`protected String`	`validateInstanceVariable(String name)` Checks if the name parameter represents a legal instance variable name, and otherwise throws a Ruby NameError
`protected boolean`	`variableTableContains(String name)` Checks if the variable table contains a variable of the specified name.
`protected boolean`	`variableTableFastContains(String internedName)` Deprecated.
`protected Object`	`variableTableFastFetch(String internedName)` Deprecated.
`protected Object`	`variableTableFastStore(String internedName, Object value)` Deprecated.
`protected Object`	`variableTableFetch(String name)` Fetch an object from the variable table based on the name.
`protected Object`	`variableTableRemove(String name)` Removes the entry with the specified name from the variable table, and returning the removed value.
`protected Object`	`variableTableStore(String name, Object value)` Store a value in the variable store under the specific name.
`protected void`	`variableTableSync(List<Variable<Object>> vars)` Synchronize the variable table with the argument.
`protected IRubyObject`	`yieldUnder(ThreadContext context, RubyModule under, Block block, EvalType evalType)` Will yield to the specific block changing the self to be the current object instead of the self that is part of the frame saved in the block frame.
`protected IRubyObject`	`yieldUnder(ThreadContext context, RubyModule under, IRubyObject[] args, Block block, EvalType evalType)` Will yield to the specific block changing the self to be the current object instead of the self that is part of the frame saved in the block frame.

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

- Field Detail
  - metaClass
```
protected transient RubyClass metaClass
```
    The class of this object
  - flags
```
protected int flags
```
    object flags
  - varTable
```
public transient Object[] varTable
```
    variable table, lazily allocated as needed (if needed)
  - varTableStamp
```
public transient volatile int varTableStamp
```
    locking stamp for Unsafe ops updating the vartable
  - VAR_TABLE_OFFSET
```
public static final long VAR_TABLE_OFFSET
```
    offset of the varTable field in RubyBasicObject
  - STAMP_OFFSET
```
public static final long STAMP_OFFSET
```
    offset of the varTableTamp field in RubyBasicObject
  - ERR_INSECURE_SET_INST_VAR
```
public static final String ERR_INSECURE_SET_INST_VAR
```
    The error message used when some one tries to modify an instance variable in a high security setting.
    
    See Also:
    Constant Field Values
  - ALL_F
```
public static final int ALL_F
```
    See Also:
    Constant Field Values
  - FALSE_F
```
public static final int FALSE_F
```
    See Also:
    Constant Field Values
  - NIL_F
```
public static final int NIL_F
```
    This flag is a bit funny. It's used to denote that this value is nil. It's a bit counterintuitive for a Java programmer to not use subclassing to handle this case, since we have a RubyNil subclass anyway. Well, the reason for it being a flag is that the isNil() method is called extremely often. So often that it gives a good speed boost to make it monomorphic and final. It turns out using a flag for this actually gives us better performance than having a polymorphic isNil() method.
    
    See Also:
    Constant Field Values
  - FROZEN_F
```
public static final int FROZEN_F
```
    See Also:
    Constant Field Values
  - TAINTED_F
```
public static final int TAINTED_F
```
    See Also:
    Constant Field Values
  - FL_USHIFT
```
public static final int FL_USHIFT
```
    See Also:
    Constant Field Values
  - USER0_F
```
public static final int USER0_F
```
    See Also:
    Constant Field Values
  - USER1_F
```
public static final int USER1_F
```
    See Also:
    Constant Field Values
  - USER2_F
```
public static final int USER2_F
```
    See Also:
    Constant Field Values
  - USER3_F
```
public static final int USER3_F
```
    See Also:
    Constant Field Values
  - USER4_F
```
public static final int USER4_F
```
    See Also:
    Constant Field Values
  - USER5_F
```
public static final int USER5_F
```
    See Also:
    Constant Field Values
  - USER6_F
```
public static final int USER6_F
```
    See Also:
    Constant Field Values
  - USER7_F
```
public static final int USER7_F
```
    See Also:
    Constant Field Values
  - USER8_F
```
public static final int USER8_F
```
    See Also:
    Constant Field Values
  - USER9_F
```
public static final int USER9_F
```
    See Also:
    Constant Field Values
  - USERA_F
```
public static final int USERA_F
```
    See Also:
    Constant Field Values
  - REFINED_MODULE_F
```
public static final int REFINED_MODULE_F
```
    See Also:
    Constant Field Values
  - IS_OVERLAID_F
```
public static final int IS_OVERLAID_F
```
    See Also:
    Constant Field Values
  - COMPARE_BY_IDENTITY_F
```
public static final int COMPARE_BY_IDENTITY_F
```
    See Also:
    Constant Field Values
  - NEVER
```
public static final IRubyObject NEVER
```
    A value that is used as a null sentinel in among other places the RubyArray implementation. It will cause large problems to call any methods on this object.
  - UNDEF
```
public static final IRubyObject UNDEF
```
    A value that specifies an undefined value. This value is used as a sentinel for undefined constant values, and other places where neither null nor NEVER makes sense.
  - BASICOBJECT_ALLOCATOR
```
public static final ObjectAllocator BASICOBJECT_ALLOCATOR
```
    Default allocator instance for all Ruby objects. The only reason to not use this allocator is if you actually need to have all instances of something be a subclass of RubyObject.
    
    See Also:
    ObjectAllocator
  - UNTRUST_F
```
@Deprecated
public static final int UNTRUST_F
```
    Deprecated.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - RubyBasicObject
```
public RubyBasicObject(Ruby runtime,
               RubyClass metaClass)
```
    Standard path for object creation. Objects are entered into ObjectSpace only if ObjectSpace is enabled.
  - RubyBasicObject
```
public RubyBasicObject(RubyClass metaClass)
```
    Path for objects that don't taint and don't enter objectspace.
  - RubyBasicObject
```
protected RubyBasicObject(Ruby runtime,
               RubyClass metaClass,
               boolean useObjectSpace)
```
    Path for objects who want to decide whether they don't want to be in ObjectSpace even when it is on. (notably used by objects being considered immediate, they'll always pass false here)
  - RubyBasicObject
```
@Deprecated
protected RubyBasicObject(Ruby runtime,
                          RubyClass metaClass,
                          boolean useObjectSpace,
                          boolean canBeTainted)
```
    Deprecated.
- Method Detail
  - createBasicObjectClass
```
public static RubyClass createBasicObjectClass(Ruby runtime,
                               RubyClass objectClass)
```
    Will create the Ruby class Object in the runtime specified. This method needs to take the actual class as an argument because of the Object class' central part in runtime initialization.
  - initialize19
```
public IRubyObject initialize19(ThreadContext context)
```
  - taint
```
protected void taint(Ruby runtime)
```
  - testFrozen
```
protected final void testFrozen(String message)
```
    rb_frozen_class_p Helper to test whether this object is frozen, and if it is will throw an exception based on the message.
  - testFrozen
```
protected final void testFrozen()
```
    rb_frozen_class_p Helper to test whether this object is frozen, and if it is will throw an exception based on the message.
  - setFlag
```
public final void setFlag(int flag,
           boolean set)
```
    Sets or unsets a flag on this object. The only flags that are guaranteed to be valid to use as the first argument is:
    - FALSE_F
    - NIL_F
    - FROZEN_F
    - TAINTED_F
    - USER0_F
    - USER1_F
    - USER2_F
    - USER3_F
    - USER4_F
    - USER5_F
    - USER6_F
    - USER7_F
    Parameters:
    flag - the actual flag to set or unset.
    set - if true, the flag will be set, if false, the flag will be unset.
  - getFlag
```
public final boolean getFlag(int flag)
```
    Get the value of a custom flag on this object. The only guaranteed flags that can be sent in to this method is:
    - FALSE_F
    - NIL_F
    - FROZEN_F
    - TAINTED_F
    - USER0_F
    - USER1_F
    - USER2_F
    - USER3_F
    - USER4_F
    - USER5_F
    - USER6_F
    - USER7_F
    Parameters:
    flag - the flag to get
    
    Returns:
    true if the flag is set, false otherwise
  - checkCallMethod
```
public final IRubyObject checkCallMethod(ThreadContext context,
                          String name)
```
    Will invoke a named method with no arguments and no block if that method or a custom method missing exists. Otherwise returns null. 1.9: rb_check_funcall
    
    Specified by:
    
    checkCallMethod in interface IRubyObject
  - callMethod
```
public final IRubyObject callMethod(ThreadContext context,
                     String name)
```
    Will invoke a named method with no arguments and no block.
    
    Specified by:
    
    callMethod in interface IRubyObject
  - callMethod
```
public final IRubyObject callMethod(ThreadContext context,
                     String name,
                     IRubyObject arg)
```
    Will invoke a named method with one argument and no block with functional invocation.
    
    Specified by:
    
    callMethod in interface IRubyObject
  - callMethod
```
public final IRubyObject callMethod(ThreadContext context,
                     String name,
                     IRubyObject[] args)
```
    Will invoke a named method with the supplied arguments and no block with functional invocation.
    
    Specified by:
    
    callMethod in interface IRubyObject
  - callMethod
```
public final IRubyObject callMethod(String name,
                     IRubyObject... args)
```
  - callMethod
```
public final IRubyObject callMethod(String name)
```
  - callMethod
```
public final IRubyObject callMethod(ThreadContext context,
                     String name,
                     IRubyObject[] args,
                     Block block)
```
    Will invoke a named method with the supplied arguments and supplied block with functional invocation.
    
    Specified by:
    
    callMethod in interface IRubyObject
  - isNil
```
public final boolean isNil()
```
    Does this object represent nil? See the docs for the NIL_F flag for more information.
    
    Specified by:
    
    isNil in interface IRubyObject
    
    Returns:
    boolean
  - isTrue
```
public final boolean isTrue()
```
    Is this value a truthy value or not? Based on the FALSE_F flag.
    
    Specified by:
    
    isTrue in interface IRubyObject
    
    Returns:
  - isFalse
```
public final boolean isFalse()
```
    Is this value a falsey value or not? Based on the FALSE_F flag.
  - isTaint
```
public boolean isTaint()
```
    Gets the taint. Shortcut for getFlag(TAINTED_F).
    
    Specified by:
    
    isTaint in interface IRubyObject
    
    Returns:
    true if this object is tainted
  - setTaint
```
public void setTaint(boolean taint)
```
    Sets the taint flag. Shortcut for setFlag(TAINTED_F, taint)
    
    Specified by:
    
    setTaint in interface IRubyObject
    
    Parameters:
    taint - should this object be tainted or not?
  - infectBy
```
public IRubyObject infectBy(IRubyObject obj)
```
    OBJ_INFECT Infects this object with traits from the argument obj. In real terms this currently means that if obj is tainted, this object will get tainted too. It's possible to hijack this method to do other infections if that would be interesting.
    
    Specified by:
    
    infectBy in interface IRubyObject
    
    Returns:
  - isFrozen
```
public boolean isFrozen()
```
    Is this value frozen or not? Shortcut for doing getFlag(FROZEN_F).
    
    Specified by:
    
    isFrozen in interface IRubyObject
    
    Returns:
    true if this object is frozen, false otherwise
  - setFrozen
```
public void setFrozen(boolean frozen)
```
    Sets whether this object is frozen or not. Shortcut for doing setFlag(FROZEN_F, frozen).
    
    Specified by:
    
    setFrozen in interface IRubyObject
    
    Parameters:
    frozen - should this object be frozen?
  - isImmediate
```
public boolean isImmediate()
```
    Is object immediate (def: Fixnum, Symbol, true, false, nil?).
    
    Specified by:
    
    isImmediate in interface IRubyObject
    
    Returns:
  - isSpecialConst
```
public boolean isSpecialConst()
```
    Specified by:
    
    isSpecialConst in interface IRubyObject
    
    Returns:
  - getMetaClass
```
public final RubyClass getMetaClass()
```
    if exist return the meta-class else return the type of the object.
    
    Specified by:
    
    getMetaClass in interface IRubyObject
    
    Returns:
  - getSingletonClass
```
public RubyClass getSingletonClass()
```
    rb_singleton_class Note: this method is specialized for RubyFixnum, RubySymbol, RubyNil and RubyBoolean Will either return the existing singleton class for this object, or create a new one and return that.
    
    Specified by:
    
    getSingletonClass in interface IRubyObject
    
    Returns:
    RubyClass
  - makeMetaClass
```
public RubyClass makeMetaClass(RubyClass superClass)
```
    rb_make_metaclass Will create a new meta class, insert this in the chain of classes for this specific object, and return the generated meta class.
  - setMetaClass
```
public void setMetaClass(RubyClass metaClass)
```
    Makes it possible to change the metaclass of an object. In practice, this is a simple version of Smalltalks Become, except that it doesn't work when we're dealing with subclasses. In practice it's used to change the singleton/meta class used, without changing the "real" inheritance chain.
  - getType
```
public RubyClass getType()
```
    Description copied from interface: IRubyObject
    
    RubyMethod getType.
    
    Specified by:
    
    getType in interface IRubyObject
    
    Returns:
    RubyClass
    See Also:
    IRubyObject.getType()
  - respondsTo
```
public final boolean respondsTo(String name)
```
    Does this object respond to the specified message? Uses a shortcut if it can be proved that respond_to? and respond_to_missing? haven't been overridden.
    
    Specified by:
    
    respondsTo in interface IRubyObject
    
    Returns:
    boolean
  - respondsToMissing
```
public final boolean respondsToMissing(String name)
```
    Does this object respond to the specified message via "method_missing?"
    
    Specified by:
    
    respondsToMissing in interface IRubyObject
    
    Returns:
    boolean
  - respondsToMissing
```
public final boolean respondsToMissing(String name,
                        boolean incPrivate)
```
    Does this object respond to the specified message via "method_missing?"
    
    Specified by:
    
    respondsToMissing in interface IRubyObject
    
    Returns:
    boolean
  - getRuntime
```
public final Ruby getRuntime()
```
    Will return the runtime that this object is associated with.
    
    Specified by:
    
    getRuntime in interface IRubyObject
    
    Returns:
    current runtime
  - getJavaClass
```
public Class getJavaClass()
```
    Will return the Java interface that most closely can represent this object, when working through JAva integration translations.
    
    Specified by:
    
    getJavaClass in interface IRubyObject
    
    Returns:
    Class
  - asJavaString
```
public String asJavaString()
```
    rb_to_id Will try to convert this object to a String using the Ruby "to_str" if the object isn't already a String. If this still doesn't work, will throw a Ruby TypeError.
    
    Specified by:
    
    asJavaString in interface IRubyObject
    
    Returns:
    String the symbol name
  - asString
```
public RubyString asString()
```
    rb_obj_as_string First converts this object into a String using the "to_s" method, infects it with the current taint and returns it. If to_s doesn't return a Ruby String, anyToString() is used instead.
    
    Specified by:
    
    asString in interface IRubyObject
    
    Returns:
  - convertToArray
```
public RubyArray convertToArray()
```
    Tries to convert this object to a Ruby Array using the "to_ary" method.
    
    Specified by:
    
    convertToArray in interface IRubyObject
    
    Returns:
  - convertToHash
```
public RubyHash convertToHash()
```
    Tries to convert this object to a Ruby Hash using the "to_hash" method.
    
    Specified by:
    
    convertToHash in interface IRubyObject
    
    Returns:
  - convertToFloat
```
public RubyFloat convertToFloat()
```
    Tries to convert this object to a Ruby Float using the "to_f" method.
    
    Specified by:
    
    convertToFloat in interface IRubyObject
    
    Returns:
  - convertToInteger
```
public RubyInteger convertToInteger()
```
    Tries to convert this object to a Ruby Integer using the "to_int" method.
    
    Specified by:
    
    convertToInteger in interface IRubyObject
    
    Returns:
  - convertToInteger
```
public RubyInteger convertToInteger(String convertMethod)
```
    Tries to convert this object to a Ruby Integer using the supplied conversion method.
    
    Specified by:
    
    convertToInteger in interface IRubyObject
    
    Returns:
  - convertToString
```
public RubyString convertToString()
```
    Tries to convert this object to a Ruby String using the "to_str" method.
    
    Specified by:
    
    convertToString in interface IRubyObject
    
    Returns:
  - anyToString
```
public IRubyObject anyToString()
```
    Internal method that helps to convert any object into the format of a class name and a hex string inside of #<>.
    
    Specified by:
    
    anyToString in interface IRubyObject
    
    Returns:
  - checkStringType
```
public IRubyObject checkStringType()
```
    rb_check_string_type Tries to return a coerced string representation of this object, using "to_str". If that returns something other than a String or nil, an empty String will be returned.
    
    Specified by:
    
    checkStringType in interface IRubyObject
    
    Returns:
  - checkStringType19
```
public IRubyObject checkStringType19()
```
    rb_check_string_type Tries to return a coerced string representation of this object, using "to_str". If that returns something other than a String or nil, an empty String will be returned.
    
    Specified by:
    
    checkStringType19 in interface IRubyObject
    
    Returns:
  - checkArrayType
```
public IRubyObject checkArrayType()
```
    rb_check_array_type Returns the result of trying to convert this object to an Array with "to_ary".
    
    Specified by:
    
    checkArrayType in interface IRubyObject
    
    Returns:
  - toJava
```
public Object toJava(Class target)
```
    Description copied from interface: IRubyObject
    
    Convert the object to the specified Java class, if possible.
    
    Specified by:
    
    toJava in interface IRubyObject
    
    Parameters:
    target - The target type to which the object should be converted.
    See Also:
    IRubyObject.toJava(java.lang.Class)
  - dup
```
public IRubyObject dup()
```
    Description copied from interface: IRubyObject
    
    RubyMethod dup.
    
    Specified by:
    
    dup in interface IRubyObject
    
    Returns:
  - OBJ_INIT_COPY
```
protected static boolean OBJ_INIT_COPY(IRubyObject obj,
                    IRubyObject orig)
```
  - objInitCopy
```
protected static void objInitCopy(IRubyObject obj,
               IRubyObject orig)
```
  - copySpecialInstanceVariables
```
public void copySpecialInstanceVariables(IRubyObject clone)
```
    Lots of MRI objects keep their state in non-lookupable ivars (e:g. Range, Struct, etc). This method is responsible for dupping our java field equivalents
    
    Specified by:
    
    copySpecialInstanceVariables in interface IRubyObject
  - rbClone
```
public IRubyObject rbClone()
```
    Description copied from interface: IRubyObject
    
    RubyMethod rbClone.
    
    Specified by:
    
    rbClone in interface IRubyObject
    
    Returns:
    IRubyObject
  - getSingletonClassClone
```
protected RubyClass getSingletonClassClone()
```
    rb_singleton_class_clone Will make sure that if the current objects class is a singleton, it will get cloned.
    
    Returns:
    either a real class, or a clone of the current singleton class
  - isModule
```
public boolean isModule()
```
    Specifically polymorphic method that are meant to be overridden by modules to specify that they are modules in an easy way.
    
    Specified by:
    
    isModule in interface IRubyObject
    
    Returns:
    true if an object is Ruby Module instance (note that it will return false for Ruby Classes). If is_a? semantics is required, use (someObject instanceof RubyModule) instead.
  - isClass
```
public boolean isClass()
```
    Specifically polymorphic method that are meant to be overridden by classes to specify that they are classes in an easy way.
    
    Specified by:
    
    isClass in interface IRubyObject
    
    Returns:
    true if an object is Ruby Class instance (note that it will return false for Ruby singleton classes). If is_a? semantics is required, use (someObject instanceof RubyClass/MetaClass) instead.
  - dataWrapStruct
```
public void dataWrapStruct(Object obj)
```
    Description copied from interface: IRubyObject
    
    Our version of Data_Wrap_Struct. This method will just set a private pointer to the object provided. This pointer is transient and will not be accessible from Ruby.
    
    Specified by:
    
    dataWrapStruct in interface IRubyObject
    
    Parameters:
    obj - the object to wrap
    See Also:
    IRubyObject.dataWrapStruct(Object)
  - dataGetStruct
```
public Object dataGetStruct()
```
    Description copied from interface: IRubyObject
    
    Our version of Data_Get_Struct. Returns a wrapped data value if there is one, otherwise returns null.
    
    Specified by:
    
    dataGetStruct in interface IRubyObject
    
    Returns:
    the object wrapped.
    See Also:
    IRubyObject.dataGetStruct()
  - dataGetStructChecked
```
public Object dataGetStructChecked()
```
    Specified by:
    
    dataGetStructChecked in interface IRubyObject
  - id
```
public IRubyObject id()
```
    rb_obj_id Return the internal id of an object.
    
    Specified by:
    
    id in interface IRubyObject
    
    Returns:
  - getObjectId
```
protected long getObjectId()
```
    The logic here is to use the special objectId accessor slot from the parent as a lazy store for an object ID. IDs are generated atomically, in serial, and guaranteed unique for up to 2^63 objects. The special objectId slot is managed separately from the "normal" vars so it does not marshal, clone/dup, or refuse to be initially set when the object is frozen.
  - inspect
```
public IRubyObject inspect()
```
    rb_obj_inspect call-seq: obj.inspect => string Returns a string containing a human-readable representation of obj. If not overridden, uses the to_s method to generate the string. [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" Time.new.inspect #=> "Wed Apr 09 08:54:39 CDT 2003"
    
    Specified by:
    
    inspect in interface IRubyObject
    
    Returns:
    String
  - hashyInspect
```
public IRubyObject hashyInspect()
```
  - rbInspect
```
public static IRubyObject rbInspect(ThreadContext context,
                    IRubyObject obj)
```
  - inspectHashCode
```
protected int inspectHashCode()
```
    For most objects, the hash used in the default #inspect is just the identity hashcode of the actual object. See org.jruby.java.proxies.JavaProxy for a divergent case.
    
    Returns:
    The identity hashcode of this object
  - op_not
```
public IRubyObject op_not(ThreadContext context)
```
  - op_not_equal
```
public IRubyObject op_not_equal(ThreadContext context,
                       IRubyObject other)
```
  - compareTo
```
public int compareTo(IRubyObject other)
```
    Compares this Ruby object with another.
    
    Specified by:
    
    compareTo in interface Comparable<IRubyObject>
    
    Parameters:
    other - another IRubyObject
    
    Returns:
    0 if equal, < 0 if this is less than other, > 0 if this is greater than other
  - op_equal
```
public IRubyObject op_equal(ThreadContext context,
                   IRubyObject obj)
```
    Specified by:
    
    op_equal in interface IRubyObject
  - op_equal_19
```
public IRubyObject op_equal_19(ThreadContext context,
                      IRubyObject obj)
```
    rb_obj_equal Will by default use identity equality to compare objects. This follows the Ruby semantics. The name of this method doesn't follow the convention because hierarchy problems
  - op_eqq
```
public IRubyObject op_eqq(ThreadContext context,
                 IRubyObject other)
```
    Specified by:
    
    op_eqq in interface IRubyObject
  - equal_p19
```
public IRubyObject equal_p19(ThreadContext context,
                    IRubyObject other)
```
  - equalInternal
```
protected static boolean equalInternal(ThreadContext context,
                    IRubyObject that,
                    IRubyObject other)
```
    Helper method for checking equality, first using Java identity equality, and then calling the "==" method.
  - eql
```
public boolean eql(IRubyObject other)
```
    method used for Hash key comparison (specialized for String, Symbol and Fixnum) Will by default just call the Ruby method "eql?"
    
    Specified by:
    
    eql in interface IRubyObject
  - addFinalizer
```
public void addFinalizer(IRubyObject f)
```
    Adds the specified object as a finalizer for this object.
    
    Specified by:
    
    addFinalizer in interface IRubyObject
  - removeFinalizers
```
public void removeFinalizers()
```
    Remove all the finalizers for this object.
    
    Specified by:
    
    removeFinalizers in interface IRubyObject
  - getVariable
```
public Object getVariable(int index)
```
    Specified by:
    
    getVariable in interface IRubyObject
  - setVariable
```
public void setVariable(int index,
               Object value)
```
    Specified by:
    
    setVariable in interface IRubyObject
  - getFFIHandle
```
public final Object getFFIHandle()
```
  - setFFIHandle
```
public final void setFFIHandle(Object value)
```
  - hasVariables
```
public boolean hasVariables()
```
    Returns true if object has any variables
    
    Specified by:
    
    hasVariables in interface IRubyObject
    
    Returns:
    true if object has any variables, else false
    See Also:
    VariableTableManager.hasVariables(org.jruby.RubyBasicObject)
  - getVariableList
```
public List<Variable<Object>> getVariableList()
```
    Gets a list of all variables in this object.
    
    Specified by:
    
    getVariableList in interface IRubyObject
    
    Returns:
    a list of all variables (ivar/cvar/constant/internal)
  - getVariableNameList
```
public List<String> getVariableNameList()
```
    Gets a name list of all variables in this object.
    
    Specified by:
    
    getVariableNameList in interface IRubyObject
    
    Returns:
    a list of all variable names (ivar/cvar/constant/internal)
  - variableTableContains
```
protected boolean variableTableContains(String name)
```
    Checks if the variable table contains a variable of the specified name.
  - variableTableFetch
```
protected Object variableTableFetch(String name)
```
    Fetch an object from the variable table based on the name.
    
    Returns:
    the object or null if not found
  - variableTableStore
```
protected Object variableTableStore(String name,
                        Object value)
```
    Store a value in the variable store under the specific name.
  - variableTableRemove
```
protected Object variableTableRemove(String name)
```
    Removes the entry with the specified name from the variable table, and returning the removed value.
  - variableTableSync
```
protected void variableTableSync(List<Variable<Object>> vars)
```
    Synchronize the variable table with the argument. In real terms this means copy all entries into a newly allocated table.
  - getInternalVariables
```
public InternalVariables getInternalVariables()
```
    Dummy method to avoid a cast, and to avoid polluting the IRubyObject interface with all the instance variable management methods.
    
    Specified by:
    
    getInternalVariables in interface IRubyObject
  - hasInternalVariable
```
public boolean hasInternalVariable(String name)
```
    Description copied from interface: InternalVariables
    
    Returns true if object has the named internal variable. Use only for internal variables (not ivar/cvar/constant).
    
    Specified by:
    
    hasInternalVariable in interface InternalVariables
    
    Parameters:
    name - the name of an internal variable
    
    Returns:
    true if object has the named internal variable.
    See Also:
    InternalVariables.hasInternalVariable(java.lang.String)
  - getInternalVariable
```
public Object getInternalVariable(String name)
```
    Description copied from interface: InternalVariables
    
    Returns the named internal variable if present, else null. Use only for internal variables (not ivar/cvar/constant).
    
    Specified by:
    
    getInternalVariable in interface InternalVariables
    
    Parameters:
    name - the name of an internal variable
    
    Returns:
    the named internal variable if present, else null
    See Also:
    InternalVariables.getInternalVariable(java.lang.String)
  - setInternalVariable
```
public void setInternalVariable(String name,
                       Object value)
```
    Description copied from interface: InternalVariables
    
    Sets the named internal variable to the specified value. Use only for internal variables (not ivar/cvar/constant).
    
    Specified by:
    
    setInternalVariable in interface InternalVariables
    
    Parameters:
    name - the name of an internal variable
    value - the value to be set
    See Also:
    InternalVariables.setInternalVariable(java.lang.String, java.lang.Object)
  - removeInternalVariable
```
public Object removeInternalVariable(String name)
```
    Description copied from interface: InternalVariables
    
    Removes the named internal variable, if present, returning its value. Use only for internal variables (not ivar/cvar/constant).
    
    Specified by:
    
    removeInternalVariable in interface InternalVariables
    
    Parameters:
    name - the name of the variable to remove
    
    Returns:
    the value of the remove variable, if present; else null
    See Also:
    InternalVariables.removeInternalVariable(java.lang.String)
  - syncVariables
```
public void syncVariables(IRubyObject other)
```
    Sync one this object's variables with other's - this is used to make rbClone work correctly.
    
    Specified by:
    
    syncVariables in interface IRubyObject
    
    Parameters:
    other - the source object containing the variables to sync
  - getInstanceVariables
```
public InstanceVariables getInstanceVariables()
```
    Dummy method to avoid a cast, and to avoid polluting the IRubyObject interface with all the instance variable management methods.
    
    Specified by:
    
    getInstanceVariables in interface IRubyObject
  - hasInstanceVariable
```
public boolean hasInstanceVariable(String name)
```
    Description copied from interface: InstanceVariables
    
    Returns true if object has the named instance variable.
    
    Specified by:
    
    hasInstanceVariable in interface InstanceVariables
    
    Parameters:
    name - the name of an instance variable
    
    Returns:
    true if object has the named instance variable.
    See Also:
    InstanceVariables.hasInstanceVariable(java.lang.String)
  - getInstanceVariable
```
public IRubyObject getInstanceVariable(String name)
```
    Description copied from interface: InstanceVariables
    
    Returns the named instance variable if present, else null.
    
    Specified by:
    
    getInstanceVariable in interface InstanceVariables
    
    Parameters:
    name - the name of an instance variable
    
    Returns:
    the named instance variable if present, else null
    See Also:
    InstanceVariables.getInstanceVariable(java.lang.String)
  - setInstanceVariable
```
public IRubyObject setInstanceVariable(String name,
                              IRubyObject value)
```
    rb_iv_set / rb_ivar_set
    
    Specified by:
    
    setInstanceVariable in interface InstanceVariables
    
    Parameters:
    name - the name of an instance variable
    value - the value to be set
    See Also:
    InstanceVariables.setInstanceVariable(java.lang.String, org.jruby.runtime.builtin.IRubyObject)
  - removeInstanceVariable
```
public IRubyObject removeInstanceVariable(String name)
```
    Description copied from interface: InstanceVariables
    
    Removes the named instance variable, if present, returning its value.
    
    Specified by:
    
    removeInstanceVariable in interface InstanceVariables
    
    Parameters:
    name - the name of the variable to remove
    
    Returns:
    the value of the remove variable, if present; else null
    See Also:
    InstanceVariables.removeInstanceVariable(java.lang.String)
  - getInstanceVariableList
```
public List<Variable<IRubyObject>> getInstanceVariableList()
```
    Gets a list of all variables in this object.
    
    Specified by:
    
    getInstanceVariableList in interface InstanceVariables
    
    Returns:
    instance variables
  - getInstanceVariableNameList
```
public List<String> getInstanceVariableNameList()
```
    Gets a name list of all variables in this object.
    
    Specified by:
    
    getInstanceVariableNameList in interface InstanceVariables
    
    Returns:
    instance variable names
  - copyInstanceVariablesInto
```
public void copyInstanceVariablesInto(InstanceVariables other)
```
    Description copied from interface: InstanceVariables
    
    Copies all instance variables from the given object into the receiver
    
    Specified by:
    
    copyInstanceVariablesInto in interface InstanceVariables
    
    See Also:
    InstanceVariables.getInstanceVariableNameList()
  - ensureInstanceVariablesSettable
```
public final void ensureInstanceVariablesSettable()
```
    Makes sure that instance variables can be set on this object, including information about whether this object is frozen, or tainted. Will throw a suitable exception in that case.
  - getNativeTypeIndex
```
@Deprecated
public final int getNativeTypeIndex()
```
    Deprecated.
    
    Description copied from interface: CoreObjectType
    
    Return the ClassIndex value for the native type this object was constructed from. Particularly useful for determining marshalling format. All instances of subclasses of Hash, for example are of Java type RubyHash, and so should utilize RubyHash marshalling logic in addition to user-defined class marshalling logic.
    
    Specified by:
    
    getNativeTypeIndex in interface CoreObjectType
    
    Returns:
    the ClassIndex of the native type this object was constructed from
  - getNativeClassIndex
```
public ClassIndex getNativeClassIndex()
```
    Description copied from interface: CoreObjectType
    
    Return the ClassIndex for the native type this object was constructed from.
    
    Specified by:
    
    getNativeClassIndex in interface CoreObjectType
  - isBuiltin
```
public boolean isBuiltin(String methodName)
```
    A method to determine whether the method named by methodName is a builtin method. This means a method with a JRubyMethod annotation written in Java.
    
    Parameters:
    methodName - to look for.
    
    Returns:
    true if so
  - singleton_method_added19
```
public static IRubyObject singleton_method_added19(ThreadContext context,
                                   IRubyObject recv,
                                   IRubyObject symbolId,
                                   Block block)
```
  - singleton_method_removed19
```
public static IRubyObject singleton_method_removed19(ThreadContext context,
                                     IRubyObject recv,
                                     IRubyObject symbolId,
                                     Block block)
```
  - singleton_method_undefined19
```
public static IRubyObject singleton_method_undefined19(ThreadContext context,
                                       IRubyObject recv,
                                       IRubyObject symbolId,
                                       Block block)
```
  - method_missing19
```
public static IRubyObject method_missing19(ThreadContext context,
                           IRubyObject recv,
                           IRubyObject[] args,
                           Block block)
```
  - send19
```
public IRubyObject send19(ThreadContext context,
                 IRubyObject arg0,
                 Block block)
```
  - send19
```
public IRubyObject send19(ThreadContext context,
                 IRubyObject arg0,
                 IRubyObject arg1,
                 Block block)
```
  - send19
```
public IRubyObject send19(ThreadContext context,
                 IRubyObject arg0,
                 IRubyObject arg1,
                 IRubyObject arg2,
                 Block block)
```
  - send19
```
public IRubyObject send19(ThreadContext context,
                 IRubyObject[] args,
                 Block block)
```
  - instance_eval19
```
public IRubyObject instance_eval19(ThreadContext context,
                          Block block)
```
  - instance_eval19
```
public IRubyObject instance_eval19(ThreadContext context,
                          IRubyObject arg0,
                          Block block)
```
  - instance_eval19
```
public IRubyObject instance_eval19(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1,
                          Block block)
```
  - instance_eval19
```
public IRubyObject instance_eval19(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1,
                          IRubyObject arg2,
                          Block block)
```
  - instance_exec19
```
public IRubyObject instance_exec19(ThreadContext context,
                          IRubyObject[] args,
                          Block block)
```
  - yieldUnder
```
protected IRubyObject yieldUnder(ThreadContext context,
                     RubyModule under,
                     IRubyObject[] args,
                     Block block,
                     EvalType evalType)
```
    Will yield to the specific block changing the self to be the current object instead of the self that is part of the frame saved in the block frame. This method is the basis for the Ruby instance_eval and module_eval methods. The arguments sent in to it in the args array will be yielded to the block. This makes it possible to emulate both instance_eval and instance_exec with this implementation.
  - yieldUnder
```
protected IRubyObject yieldUnder(ThreadContext context,
                     RubyModule under,
                     Block block,
                     EvalType evalType)
```
    Will yield to the specific block changing the self to be the current object instead of the self that is part of the frame saved in the block frame. This method is the basis for the Ruby instance_eval and module_eval methods. The arguments sent in to it in the args array will be yielded to the block. This makes it possible to emulate both instance_eval and instance_exec with this implementation.
  - specificEval
```
public IRubyObject specificEval(ThreadContext context,
                       RubyModule mod,
                       Block block,
                       EvalType evalType)
```
    specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments. If a block is given, this will be yielded in the specific context of this object. If no block is given then a String-like object needs to be the first argument, and this string will be evaluated. Second and third arguments in the args-array is optional, but can contain the filename and line of the string under evaluation.
  - specificEval
```
public IRubyObject specificEval(ThreadContext context,
                       RubyModule mod,
                       IRubyObject arg,
                       Block block,
                       EvalType evalType)
```
    specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments. If a block is given, this will be yielded in the specific context of this object. If no block is given then a String-like object needs to be the first argument, and this string will be evaluated. Second and third arguments in the args-array is optional, but can contain the filename and line of the string under evaluation.
  - specificEval
```
public IRubyObject specificEval(ThreadContext context,
                       RubyModule mod,
                       IRubyObject arg0,
                       IRubyObject arg1,
                       Block block,
                       EvalType evalType)
```
    specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments. If a block is given, this will be yielded in the specific context of this object. If no block is given then a String-like object needs to be the first argument, and this string will be evaluated. Second and third arguments in the args-array is optional, but can contain the filename and line of the string under evaluation.
  - specificEval
```
public IRubyObject specificEval(ThreadContext context,
                       RubyModule mod,
                       IRubyObject arg0,
                       IRubyObject arg1,
                       IRubyObject arg2,
                       Block block,
                       EvalType evalType)
```
    specific_eval Evaluates the block or string inside of the context of this object, using the supplied arguments. If a block is given, this will be yielded in the specific context of this object. If no block is given then a String-like object needs to be the first argument, and this string will be evaluated. Second and third arguments in the args-array is optional, but can contain the filename and line of the string under evaluation.
  - getInstanceEvalClass
```
protected RubyModule getInstanceEvalClass()
```
  - evalUnder
```
public IRubyObject evalUnder(ThreadContext context,
                    RubyModule under,
                    RubyString src,
                    String file,
                    int line,
                    EvalType evalType)
```
    Evaluates the string src with self set to the current object, using the module under as the context.
  - equal_p
```
public IRubyObject equal_p(ThreadContext context,
                  IRubyObject obj)
```
    rb_obj_equal Will use Java identity equality.
  - eql_p
```
public IRubyObject eql_p(IRubyObject obj)
```
    rb_obj_equal Just like "==" and "equal?", "eql?" will use identity equality for Object.
  - op_cmp
```
public IRubyObject op_cmp(ThreadContext context,
                 IRubyObject other)
```
  - initialize_copy
```
public IRubyObject initialize_copy(IRubyObject original)
```
    rb_obj_init_copy Initializes this object as a copy of the original, that is the parameter to this object. Will make sure that the argument actually has the same real class as this object. It shouldn't be possible to initialize an object with something totally different.
  - checkFrozen
```
public void checkFrozen()
```
    The actual method that checks frozen with the default frozen message from MRI. If possible, call this instead of testFrozen(java.lang.String).
  - respond_to_p
```
public final RubyBoolean respond_to_p(IRubyObject mname)
```
    obj_respond_to respond_to?( aSymbol, includePriv=false ) -> true or false Returns true if this object responds to the given method. Private methods are included in the search only if the optional second parameter evaluates to true.
    
    Returns:
    true if this responds to the given method !!! For some reason MRI shows the arity of respond_to? as -1, when it should be -2; that's why this is rest instead of required, optional = 1 Going back to splitting according to method arity. MRI is wrong about most of these anyway, and since we have arity splitting in both the compiler and the interpreter, the performance benefit is important for this method.
  - respond_to_p19
```
public final RubyBoolean respond_to_p19(IRubyObject mname)
```
  - respond_to_p
```
public final RubyBoolean respond_to_p(IRubyObject mname,
                       IRubyObject includePrivate)
```
  - respond_to_p19
```
public final RubyBoolean respond_to_p19(IRubyObject mname,
                         IRubyObject includePrivate)
```
  - hash
```
public RubyFixnum hash()
```
    rb_obj_id Will return the hash code of this object. In comparison to MRI, this method will use the Java identity hash code instead of using rb_obj_id, since the usage of id in JRuby will incur the cost of some. ObjectSpace maintenance.
  - type
```
public RubyClass type()
```
    rb_obj_class Returns the real class of this object, excluding any singleton/meta class in the inheritance chain.
  - type_deprecated
```
public RubyClass type_deprecated()
```
    rb_obj_type The deprecated version of type, that emits a deprecation warning.
  - display
```
public IRubyObject display(ThreadContext context,
                  IRubyObject[] args)
```
    rb_obj_display call-seq: obj.display(port=$>) => nil Prints obj on the given port (default $>). Equivalent to: def display(port=$>) port.write self end For example: 1.display "cat".display [ 4, 5, 6 ].display puts produces: 1cat456
  - tainted_p
```
public RubyBoolean tainted_p(ThreadContext context)
```
    rb_obj_tainted call-seq: obj.tainted? => true or false Returns true if the object is tainted.
  - taint
```
public IRubyObject taint(ThreadContext context)
```
    rb_obj_taint call-seq: obj.taint -> obj Marks obj as tainted---if the $SAFE level is set appropriately, many method calls which might alter the running programs environment will refuse to accept tainted strings.
  - untaint
```
public IRubyObject untaint(ThreadContext context)
```
    rb_obj_untaint call-seq: obj.untaint => obj Removes the taint from obj. Only callable in if more secure than 3.
  - freeze
```
public IRubyObject freeze(ThreadContext context)
```
    rb_obj_freeze call-seq: obj.freeze => obj Prevents further modifications to obj. A TypeError will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also Object#frozen?. a = [ "a", "b", "c" ] a.freeze a << "z" produces: prog.rb:3:in `<<': can't modify frozen array (TypeError) from prog.rb:3
  - frozen_p
```
public RubyBoolean frozen_p(ThreadContext context)
```
    rb_obj_frozen_p call-seq: obj.frozen? => true or false Returns the freeze status of obj. a = [ "a", "b", "c" ] a.freeze #=> ["a", "b", "c"] a.frozen? #=> true
  - instance_of_p
```
public RubyBoolean instance_of_p(ThreadContext context,
                        IRubyObject type)
```
    rb_obj_is_instance_of call-seq: obj.instance_of?(class) => true or false Returns true if obj is an instance of the given class. See also Object#kind_of?.
  - kind_of_p
```
public RubyBoolean kind_of_p(ThreadContext context,
                    IRubyObject type)
```
    rb_obj_is_kind_of call-seq: obj.is_a?(class) => true or false obj.kind_of?(class) => true or false Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj. module M; end class A include M end class B < A; end class C < B; end b = B.new b.instance_of? A #=> false b.instance_of? B #=> true b.instance_of? C #=> false b.instance_of? M #=> false b.kind_of? A #=> true b.kind_of? B #=> true b.kind_of? C #=> false b.kind_of? M #=> true
  - methods
```
public IRubyObject methods(ThreadContext context,
                  IRubyObject[] args)
```
    rb_obj_methods call-seq: obj.methods => array Returns a list of the names of methods publicly accessible in obj. This will include all the methods accessible in obj's ancestors. class Klass def kMethod() end end k = Klass.new k.methods[0..9] #=> ["kMethod", "freeze", "nil?", "is_a?", "class", "instance_variable_set", "methods", "extend", "__send__", "instance_eval"] k.methods.length #=> 42
  - methods19
```
public IRubyObject methods19(ThreadContext context,
                    IRubyObject[] args)
```
  - methods
```
public IRubyObject methods(ThreadContext context,
                  IRubyObject[] args,
                  boolean useSymbols)
```
  - public_methods
```
public IRubyObject public_methods(ThreadContext context,
                         IRubyObject[] args)
```
    rb_obj_public_methods call-seq: obj.public_methods(all=true) => array Returns the list of public methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.
  - public_methods19
```
public IRubyObject public_methods19(ThreadContext context,
                           IRubyObject[] args)
```
  - protected_methods
```
public IRubyObject protected_methods(ThreadContext context,
                            IRubyObject[] args)
```
    rb_obj_protected_methods call-seq: obj.protected_methods(all=true) => array Returns the list of protected methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed. Internally this implementation uses the RubyModule.protected_instance_methods(org.jruby.runtime.builtin.IRubyObject[]) method.
  - protected_methods19
```
public IRubyObject protected_methods19(ThreadContext context,
                              IRubyObject[] args)
```
  - private_methods
```
public IRubyObject private_methods(ThreadContext context,
                          IRubyObject[] args)
```
    rb_obj_private_methods call-seq: obj.private_methods(all=true) => array Returns the list of private methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed. Internally this implementation uses the RubyModule.private_instance_methods(org.jruby.runtime.builtin.IRubyObject[]) method.
  - private_methods19
```
public IRubyObject private_methods19(ThreadContext context,
                            IRubyObject[] args)
```
  - singleton_methods
```
public RubyArray singleton_methods(ThreadContext context,
                          IRubyObject[] args)
```
    rb_obj_singleton_methods call-seq: obj.singleton_methods(all=true) => array Returns an array of the names of singleton methods for obj. If the optional all parameter is true, the list will include methods in modules included in obj. module Other def three() end end class Single def Single.four() end end a = Single.new def a.one() end class << a include Other def two() end end Single.singleton_methods #=> ["four"] a.singleton_methods(false) #=> ["two", "one"] a.singleton_methods #=> ["two", "one", "three"]
  - method
```
public IRubyObject method(IRubyObject symbol)
```
    rb_obj_method call-seq: obj.method(sym) => method Looks up the named method as a receiver in obj, returning a Method object (or raising NameError). The Method object acts as a closure in obj's object instance, so instance variables and the value of self remain available. class Demo def initialize(n)
  - method19
```
public IRubyObject method19(IRubyObject symbol)
```
  - to_s
```
public IRubyObject to_s()
```
    rb_any_to_s call-seq: obj.to_s => string Returns a string representing obj. The default to_s prints the object's class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns ``main.''
  - to_a
```
public RubyArray to_a()
```
    rb_any_to_a call-seq: obj.to_a -> anArray Returns an array representation of obj. For objects of class Object and others that don't explicitly override the method, the return value is an array containing self. However, this latter behavior will soon be obsolete. self.to_a #=> -:1: warning: default `to_a' will be obsolete "hello".to_a #=> ["hello"] Time.new.to_a #=> [39, 54, 8, 9, 4, 2003, 3, 99, true, "CDT"] The default to_a method is deprecated.
  - instance_eval
```
public IRubyObject instance_eval(ThreadContext context,
                        Block block)
```
    rb_obj_instance_eval call-seq: obj.instance_eval(string [, filename [, lineno]] ) => obj obj.instance_eval {| | block } => obj Evaluates a string containing Ruby source code, or the given block, within the context of the receiver (_obj_). In order to set the context, the variable +self+ is set to _obj_ while the code is executing, giving the code access to _obj_'s instance variables. In the version of instance_eval that takes a +String+, the optional second and third parameters supply a filename and starting line number that are used when reporting compilation errors. class Klass def initialize
  - instance_eval
```
public IRubyObject instance_eval(ThreadContext context,
                        IRubyObject arg0,
                        Block block)
```
  - instance_eval
```
public IRubyObject instance_eval(ThreadContext context,
                        IRubyObject arg0,
                        IRubyObject arg1,
                        Block block)
```
  - instance_eval
```
public IRubyObject instance_eval(ThreadContext context,
                        IRubyObject arg0,
                        IRubyObject arg1,
                        IRubyObject arg2,
                        Block block)
```
  - instance_exec
```
public IRubyObject instance_exec(ThreadContext context,
                        IRubyObject[] args,
                        Block block)
```
    rb_obj_instance_exec call-seq: obj.instance_exec(arg...) {|var...| block } => obj Executes the given block within the context of the receiver (_obj_). In order to set the context, the variable +self+ is set to _obj_ while the code is executing, giving the code access to _obj_'s instance variables. Arguments are passed as block parameters. class Klass def initialize
  - extend
```
public IRubyObject extend(IRubyObject[] args)
```
    rb_obj_extend call-seq: obj.extend(module, ...) => obj Adds to _obj_ the instance methods from each module given as a parameter. module Mod def hello "Hello from Mod.\n" end end class Klass def hello "Hello from Klass.\n" end end k = Klass.new k.hello #=> "Hello from Klass.\n" k.extend(Mod) #=> # k.hello #=> "Hello from Mod.\n"
  - send
```
public IRubyObject send(ThreadContext context,
               Block block)
```
    rb_f_send send( aSymbol [, args ]* ) -> anObject Invokes the method identified by aSymbol, passing it any arguments specified. You can use __send__ if the name send clashes with an existing method in this object.
```
 class Klass
   def hello(*args)
     "Hello " + args.join(' ')
   end
 end

 k = Klass.new
 k.send :hello, "gentle", "readers"
 
```
    Returns:
    the result of invoking the method identified by aSymbol.
  - send
```
public IRubyObject send(ThreadContext context,
               IRubyObject arg0,
               Block block)
```
  - send
```
public IRubyObject send(ThreadContext context,
               IRubyObject arg0,
               IRubyObject arg1,
               Block block)
```
  - send
```
public IRubyObject send(ThreadContext context,
               IRubyObject arg0,
               IRubyObject arg1,
               IRubyObject arg2,
               Block block)
```
  - send
```
public IRubyObject send(ThreadContext context,
               IRubyObject[] args,
               Block block)
```
  - nil_p
```
public IRubyObject nil_p(ThreadContext context)
```
    rb_false call_seq: nil.nil? => true .nil? => false Only the object nil responds true to nil?.
  - op_match
```
public IRubyObject op_match(ThreadContext context,
                   IRubyObject arg)
```
    rb_obj_pattern_match call-seq: obj =~ other => false Pattern Match---Overridden by descendents (notably Regexp and String) to provide meaningful pattern-match semantics.
  - op_match19
```
public IRubyObject op_match19(ThreadContext context,
                     IRubyObject arg)
```
  - op_not_match
```
public IRubyObject op_not_match(ThreadContext context,
                       IRubyObject arg)
```
  - instance_variable_defined_p
```
public IRubyObject instance_variable_defined_p(ThreadContext context,
                                      IRubyObject name)
```
    rb_obj_ivar_defined call-seq: obj.instance_variable_defined?(symbol) => true or false Returns true if the given instance variable is defined in obj. class Fred def initialize(p1, p2)
  - instance_variable_get
```
public IRubyObject instance_variable_get(ThreadContext context,
                                IRubyObject name)
```
    rb_obj_ivar_get call-seq: obj.instance_variable_get(symbol) => obj Returns the value of the given instance variable, or nil if the instance variable is not set. The @ part of the variable name should be included for regular instance variables. Throws a NameError exception if the supplied symbol is not valid as an instance variable name. class Fred def initialize(p1, p2)
  - instance_variable_set
```
public IRubyObject instance_variable_set(IRubyObject name,
                                IRubyObject value)
```
    rb_obj_ivar_set call-seq: obj.instance_variable_set(symbol, obj) => obj Sets the instance variable names by symbol to object, thereby frustrating the efforts of the class's author to attempt to provide proper encapsulation. The variable did not have to exist prior to this call. class Fred def initialize(p1, p2)
  - remove_instance_variable
```
public IRubyObject remove_instance_variable(ThreadContext context,
                                   IRubyObject name,
                                   Block block)
```
    rb_obj_remove_instance_variable call-seq: obj.remove_instance_variable(symbol) => obj Removes the named instance variable from obj, returning that variable's value. class Dummy attr_reader :var def initialize
  - instance_variables
```
public RubyArray instance_variables(ThreadContext context)
```
    rb_obj_instance_variables call-seq: obj.instance_variables => array Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable. class Fred attr_accessor :a1 def initialize
  - instance_variables19
```
public RubyArray instance_variables19(ThreadContext context)
```
  - equals
```
public boolean equals(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.
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Override the Object#hashCode method to make sure that the Ruby hash is actually used as the hashcode for Ruby objects. If the Ruby "hash" method doesn't return a number, the Object#hashCode implementation will be used instead.
    
    Overrides:
    
    hashCode in class Object
  - nonFixnumHashCode
```
protected static int nonFixnumHashCode(IRubyObject hashValue)
```
  - validateInstanceVariable
```
protected String validateInstanceVariable(String name)
```
    Checks if the name parameter represents a legal instance variable name, and otherwise throws a Ruby NameError
  - initialize
```
@Deprecated
public IRubyObject initialize()
```
    Deprecated.
  - callSuper
```
@Deprecated
public IRubyObject callSuper(ThreadContext context,
                               IRubyObject[] args,
                               Block block)
```
    Deprecated.
    
    Specified by:
    
    callSuper in interface IRubyObject
  - callMethod
```
@Deprecated
public final IRubyObject callMethod(ThreadContext context,
                                int methodIndex,
                                String name)
```
    Deprecated.
    
    Specified by:
    
    callMethod in interface IRubyObject
  - callMethod
```
@Deprecated
public final IRubyObject callMethod(ThreadContext context,
                                int methodIndex,
                                String name,
                                IRubyObject arg)
```
    Deprecated.
    
    Specified by:
    
    callMethod in interface IRubyObject
  - convertToInteger
```
@Deprecated
public RubyInteger convertToInteger(int methodIndex,
                                      String convertMethod)
```
    Deprecated.
    
    Specified by:
    
    convertToInteger in interface IRubyObject
    
    Returns:
  - getVariableCount
```
@Deprecated
public int getVariableCount()
```
    Deprecated.
    
    Specified by:
    
    getVariableCount in interface IRubyObject
    
    Returns:
    the count of all variables (ivar/cvar/constant/internal)
  - variableTableFastContains
```
@Deprecated
protected boolean variableTableFastContains(String internedName)
```
    Deprecated.
  - variableTableFastFetch
```
@Deprecated
protected Object variableTableFastFetch(String internedName)
```
    Deprecated.
  - variableTableFastStore
```
@Deprecated
protected Object variableTableFastStore(String internedName,
                                       Object value)
```
    Deprecated.
  - fastHasInternalVariable
```
@Deprecated
public boolean fastHasInternalVariable(String internedName)
```
    Deprecated.
    
    Specified by:
    
    fastHasInternalVariable in interface InternalVariables
  - fastGetInternalVariable
```
@Deprecated
public Object fastGetInternalVariable(String internedName)
```
    Deprecated.
    
    Specified by:
    
    fastGetInternalVariable in interface InternalVariables
  - fastSetInternalVariable
```
@Deprecated
public void fastSetInternalVariable(String internedName,
                                      Object value)
```
    Deprecated.
    
    Specified by:
    
    fastSetInternalVariable in interface InternalVariables
  - syncVariables
```
@Deprecated
public void syncVariables(List<Variable<Object>> variables)
```
    Deprecated.
    
    Description copied from interface: IRubyObject
    
    Sets object's variables to those in the supplied list, removing/replacing any previously defined variables. Applies to all variable types (ivar/cvar/constant/internal).
    
    Specified by:
    
    syncVariables in interface IRubyObject
    
    Parameters:
    variables - the variables to be set for object
  - fastHasInstanceVariable
```
@Deprecated
public boolean fastHasInstanceVariable(String internedName)
```
    Deprecated.
    
    Specified by:
    
    fastHasInstanceVariable in interface InstanceVariables
  - fastGetInstanceVariable
```
@Deprecated
public IRubyObject fastGetInstanceVariable(String internedName)
```
    Deprecated.
    
    Specified by:
    
    fastGetInstanceVariable in interface InstanceVariables
  - fastSetInstanceVariable
```
@Deprecated
public IRubyObject fastSetInstanceVariable(String internedName,
                                             IRubyObject value)
```
    Deprecated.
    
    Specified by:
    
    fastSetInstanceVariable in interface InstanceVariables
  - isUntrusted
```
@Deprecated
public boolean isUntrusted()
```
    Deprecated.
    
    Description copied from interface: IRubyObject
    
    RubyMethod isUntrusted.
    
    Specified by:
    
    isUntrusted in interface IRubyObject
    
    Returns:
    boolean
  - setUntrusted
```
@Deprecated
public void setUntrusted(boolean untrusted)
```
    Deprecated.
    
    Description copied from interface: IRubyObject
    
    RubyMethod setUntrusted.
    
    Specified by:
    
    setUntrusted in interface IRubyObject
  - untrusted_p
```
@Deprecated
public RubyBoolean untrusted_p(ThreadContext context)
```
    Deprecated.
  - untrust
```
@Deprecated
public IRubyObject untrust(ThreadContext context)
```
    Deprecated.
  - trust
```
@Deprecated
public IRubyObject trust(ThreadContext context)
```
    Deprecated.
  - getNativeHandle
```
@Deprecated
public final Object getNativeHandle()
```
    Deprecated.
  - setNativeHandle
```
@Deprecated
public final void setNativeHandle(Object value)
```
    Deprecated.

Class RubyBasicObject

Nested Class Summary

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

metaClass

flags

varTable

varTableStamp

VAR_TABLE_OFFSET

STAMP_OFFSET

ERR_INSECURE_SET_INST_VAR

ALL_F

FALSE_F

NIL_F

FROZEN_F

TAINTED_F

FL_USHIFT

USER0_F

USER1_F

USER2_F

USER3_F

USER4_F

USER5_F

USER6_F

USER7_F

USER8_F

USER9_F

USERA_F

REFINED_MODULE_F

IS_OVERLAID_F

COMPARE_BY_IDENTITY_F

NEVER

UNDEF

BASICOBJECT_ALLOCATOR

UNTRUST_F

Constructor Detail

RubyBasicObject

RubyBasicObject

RubyBasicObject

RubyBasicObject

Method Detail

createBasicObjectClass

initialize19

taint

testFrozen

testFrozen

setFlag

getFlag

checkCallMethod

callMethod

callMethod

callMethod

callMethod

callMethod

callMethod

isNil

isTrue

isFalse

isTaint

setTaint

infectBy

isFrozen

setFrozen

isImmediate

isSpecialConst

getMetaClass

getSingletonClass

makeMetaClass

setMetaClass

getType

respondsTo

respondsToMissing

respondsToMissing

getRuntime

getJavaClass

asJavaString