DynamicMethod (JRuby Core 9.0.0.0 API)

java.lang.Object
- org.jruby.internal.runtime.methods.DynamicMethod

Direct Known Subclasses:

AliasMethod, CompiledIRMethod, DefaultMethod, DelegatingDynamicMethod, HandleMethod, InterpretedIRMethod, JavaMethod, MethodMethod, MethodMissingMethod, MixedModeIRMethod, NativeInvoker, NullMethod, ProcMethod, UndefinedMethod, WrapperMethod
```
public abstract class DynamicMethod
extends Object
```
DynamicMethod represents a method handle in JRuby, to provide both entry points into AST and bytecode interpreters, but also to provide handles to JIT-compiled and hand-implemented Java methods. All methods invokable from Ruby code are referenced by method handles, either directly or through delegation or callback mechanisms.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DynamicMethod.NativeCall

Nested Classes
Modifier and Type	Class and Description
`static class`	`DynamicMethod.NativeCall`

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`builtin` Is this a builtin core method or not
`protected CallConfiguration`	`callConfig` The "call configuration" to use for pre/post call logic.
`protected Object`	`handle` An arbitrarily-typed "method handle" for use by compilers and call sites
`protected RubyModule`	`implementationClass` The Ruby module or class in which this method is immediately defined.
`protected String`	`name` The simple, base name this method was defined under.
`protected DynamicMethod.NativeCall`	`nativeCall` Single-arity native call
`protected DynamicMethod.NativeCall[]`	`nativeCalls` Alternate-arity NativeCalls
`protected boolean`	`notImplemented` Whether this method is "not implemented".
`protected RubyModule`	`protectedClass` The "protected class" used for calculating protected access.
`protected long`	`serialNumber` The serial number for this method object, to globally identify it
`protected Visibility`	`visibility` The visibility of this method.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`DynamicMethod()` A no-arg constructor used only by the UndefinedMethod subclass and CompiledMethod handles.
`protected`	`DynamicMethod(RubyModule implementationClass, Visibility visibility, CallConfiguration callConfig)` Base constructor for dynamic method handles.
`protected`	`DynamicMethod(RubyModule implementationClass, Visibility visibility, CallConfiguration callConfig, String name)` Base constructor for dynamic method handles with names.

Method Summary

Methods
Modifier and Type	Method and Description
`protected static RubyModule`	`calculateProtectedClass(RubyModule cls)` Calculate, based on given RubyModule, which class in its hierarchy should be used to determine protected access.
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name)` Arity 0, no block
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name, Block block)` Arity 0, with block; calls through IRubyObject[] path
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name, IRubyObject arg0)` Arity 1, no block
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args)` A default implementation of n-arity, non-block 'call' method, which simply calls the n-arity, block-receiving version with the arg list and Block.NULL_BLOCK.
`abstract IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block)` The minimum 'call' method required for a dynamic method handle.
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name, IRubyObject arg0, Block block)` Arity 1, with block; calls through IRubyObject[] path
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name, IRubyObject arg0, IRubyObject arg1)` Arity 2, no block
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name, IRubyObject arg0, IRubyObject arg1, Block block)` Arity 2, with block; calls through IRubyObject[] path
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2)` Arity 3, no block
`IRubyObject`	`call(ThreadContext context, IRubyObject self, RubyModule klazz, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block)` Arity 3, with block; calls through IRubyObject[] path
`abstract DynamicMethod`	`dup()` Duplicate this method, returning DynamicMethod referencing the same code and with the same attributes.
`Arity`	`getArity()` Retrieve the arity of this method, used for reporting arity to Ruby code.
`CallConfiguration`	`getCallConfig()` Get the CallConfiguration used for pre/post logic for this method handle.
`Object`	`getHandle()` Get the "handle" associated with this DynamicMethod.
`RubyModule`	`getImplementationClass()` Retrieve the class or module on which this method is implemented, used for 'super' logic among others.
`MethodData`	`getMethodData()` Additional metadata about this method.
`String`	`getName()` Get the base name this method was defined as.
`DynamicMethod.NativeCall`	`getNativeCall()`
`DynamicMethod.NativeCall`	`getNativeCall(int args, boolean block)`
`protected RubyModule`	`getProtectedClass()` Retrieve the pre-calculated "protected class" used for access checks.
`DynamicMethod`	`getRealMethod()` Get the "real" method contained within this method.
`long`	`getSerialNumber()` Get the global serial number for this method object
`Visibility`	`getVisibility()` Get the visibility of this method.
`protected void`	`init(RubyModule implementationClass, Visibility visibility, CallConfiguration callConfig)`
`boolean`	`isBuiltin()`
`boolean`	`isCallableFrom(IRubyObject caller, CallType callType)` Determine whether this method is callable from the given object using the given call type.
`boolean`	`isImplementedBy(RubyModule other)`
`boolean`	`isNative()` Returns true if this method is backed by native (i.e.
`boolean`	`isNotImplemented()` Whether this method is "not implemented".
`boolean`	`isNull()` Whether this method is the "null" method, used to stop method name resolution loops.
`boolean`	`isUndefined()` Whether this method is the "undefined" method, used to represent a missing or undef'ed method.
`void`	`setCallConfig(CallConfiguration callConfig)` Set the CallConfiguration used for pre/post logic for this method handle.
`void`	`setHandle(Object handle)` Set the "handle" associated with this DynamicMethod.
`void`	`setImplementationClass(RubyModule implClass)` Set the class on which this method is implemented, used for 'super' logic, among others.
`void`	`setIsBuiltin(boolean isBuiltin)`
`void`	`setName(String name)` Set the base name for this method.
`void`	`setNativeCall(Class nativeTarget, String nativeName, Class nativeReturn, Class[] nativeSignature, boolean statik)` Set the single-arity NativeCall for this method.
`void`	`setNativeCall(Class nativeTarget, String nativeName, Class nativeReturn, Class[] nativeSignature, boolean statik, boolean java)` Set the single-arity NativeCall for this method.
`void`	`setNativeCall(int args, boolean block, DynamicMethod.NativeCall nativeCall)`
`void`	`setNotImplemented(boolean setNotImplemented)` Set whether this method is "not implemented".
`void`	`setVisibility(Visibility visibility)` Set the visibility of this method.

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

- Field Detail
  - implementationClass
```
protected RubyModule implementationClass
```
    The Ruby module or class in which this method is immediately defined.
  - protectedClass
```
protected RubyModule protectedClass
```
    The "protected class" used for calculating protected access.
  - visibility
```
protected Visibility visibility
```
    The visibility of this method.
  - callConfig
```
protected CallConfiguration callConfig
```
    The "call configuration" to use for pre/post call logic.
  - serialNumber
```
protected long serialNumber
```
    The serial number for this method object, to globally identify it
  - builtin
```
protected boolean builtin
```
    Is this a builtin core method or not
  - nativeCall
```
protected DynamicMethod.NativeCall nativeCall
```
    Single-arity native call
  - nativeCalls
```
protected DynamicMethod.NativeCall[] nativeCalls
```
    Alternate-arity NativeCalls
  - name
```
protected String name
```
    The simple, base name this method was defined under. May be null.
  - notImplemented
```
protected boolean notImplemented
```
    Whether this method is "not implemented".
  - handle
```
protected Object handle
```
    An arbitrarily-typed "method handle" for use by compilers and call sites
- Constructor Detail
  - DynamicMethod
```
protected DynamicMethod(RubyModule implementationClass,
             Visibility visibility,
             CallConfiguration callConfig)
```
    Base constructor for dynamic method handles.
    
    Parameters:
    implementationClass - The class to which this method will be immediately bound
    visibility - The visibility assigned to this method
    callConfig - The CallConfiguration to use for this method's pre/post invocation logic.
  - DynamicMethod
```
protected DynamicMethod(RubyModule implementationClass,
             Visibility visibility,
             CallConfiguration callConfig,
             String name)
```
    Base constructor for dynamic method handles with names.
    
    Parameters:
    implementationClass - The class to which this method will be immediately bound
    visibility - The visibility assigned to this method
    callConfig - The CallConfiguration to use for this method's pre/post invocation logic.
  - DynamicMethod
```
protected DynamicMethod()
```
    A no-arg constructor used only by the UndefinedMethod subclass and CompiledMethod handles. instanceof assertions make sure this is so.
- Method Detail
  - init
```
protected void init(RubyModule implementationClass,
        Visibility visibility,
        CallConfiguration callConfig)
```
  - getSerialNumber
```
public long getSerialNumber()
```
    Get the global serial number for this method object
    
    Returns:
    This method object's serial number
  - isBuiltin
```
public boolean isBuiltin()
```
  - setIsBuiltin
```
public void setIsBuiltin(boolean isBuiltin)
```
  - call
```
public abstract IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule clazz,
               String name,
               IRubyObject[] args,
               Block block)
```
    The minimum 'call' method required for a dynamic method handle. Subclasses must implement this method, but may implement the other signatures to provide faster, non-boxing call paths. Typically subclasses will implement this method to check variable arity calls, then performing a specific-arity invocation to the appropriate method or performing variable-arity logic in-line.
    
    Parameters:
    context - The thread context for the currently executing thread
    self - The 'self' or 'receiver' object to use for this call
    clazz - The Ruby class against which this method is binding
    name - The incoming name used to invoke this method
    args - The argument list to this invocation
    block - The block passed to this invocation
    
    Returns:
    The result of the call
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule clazz,
               String name,
               IRubyObject[] args)
```
    A default implementation of n-arity, non-block 'call' method, which simply calls the n-arity, block-receiving version with the arg list and Block.NULL_BLOCK.
    
    Parameters:
    context - The thread context for the currently executing thread
    self - The 'self' or 'receiver' object to use for this call
    clazz - The Ruby class against which this method is binding
    name - The incoming name used to invoke this method
    args - The first argument to this invocation
    
    Returns:
    The result of the call
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name)
```
    Arity 0, no block
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name,
               Block block)
```
    Arity 0, with block; calls through IRubyObject[] path
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name,
               IRubyObject arg0)
```
    Arity 1, no block
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name,
               IRubyObject arg0,
               Block block)
```
    Arity 1, with block; calls through IRubyObject[] path
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name,
               IRubyObject arg0,
               IRubyObject arg1)
```
    Arity 2, no block
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name,
               IRubyObject arg0,
               IRubyObject arg1,
               Block block)
```
    Arity 2, with block; calls through IRubyObject[] path
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name,
               IRubyObject arg0,
               IRubyObject arg1,
               IRubyObject arg2)
```
    Arity 3, no block
  - call
```
public IRubyObject call(ThreadContext context,
               IRubyObject self,
               RubyModule klazz,
               String name,
               IRubyObject arg0,
               IRubyObject arg1,
               IRubyObject arg2,
               Block block)
```
    Arity 3, with block; calls through IRubyObject[] path
  - dup
```
public abstract DynamicMethod dup()
```
    Duplicate this method, returning DynamicMethod referencing the same code and with the same attributes. It is not required that this method produce a new object if the semantics of the DynamicMethod subtype do not require such.
    
    Returns:
    An identical DynamicMethod object to the target.
  - isCallableFrom
```
public boolean isCallableFrom(IRubyObject caller,
                     CallType callType)
```
    Determine whether this method is callable from the given object using the given call type.
    
    Parameters:
    caller - The calling object
    callType - The type of call
    
    Returns:
    true if the call would not violate visibility; false otherwise
  - calculateProtectedClass
```
protected static RubyModule calculateProtectedClass(RubyModule cls)
```
    Calculate, based on given RubyModule, which class in its hierarchy should be used to determine protected access.
    
    Parameters:
    cls - The class from which to calculate
    
    Returns:
    The class to be used for protected access checking.
  - getProtectedClass
```
protected RubyModule getProtectedClass()
```
    Retrieve the pre-calculated "protected class" used for access checks.
    
    Returns:
    The "protected class" for access checks.
  - getImplementationClass
```
public RubyModule getImplementationClass()
```
    Retrieve the class or module on which this method is implemented, used for 'super' logic among others.
    
    Returns:
    The class on which this method is implemented
  - isImplementedBy
```
public boolean isImplementedBy(RubyModule other)
```
  - setImplementationClass
```
public void setImplementationClass(RubyModule implClass)
```
    Set the class on which this method is implemented, used for 'super' logic, among others.
    
    Parameters:
    implClass - The class on which this method is implemented
  - getVisibility
```
public Visibility getVisibility()
```
    Get the visibility of this method.
    
    Returns:
    The visibility of this method
  - setVisibility
```
public void setVisibility(Visibility visibility)
```
    Set the visibility of this method.
    
    Parameters:
    visibility - The visibility of this method
  - isUndefined
```
public final boolean isUndefined()
```
    Whether this method is the "undefined" method, used to represent a missing or undef'ed method. Only returns true for UndefinedMethod instances, of which there should be only one (a singleton).
    
    Returns:
    true if this method is the undefined method; false otherwise
  - isNull
```
public final boolean isNull()
```
    Whether this method is the "null" method, used to stop method name resolution loops. Only returns true for NullMethod instances, of which there should be only one (a singleton).
    
    Returns:
    true if this method is the undefined method; false otherwise
  - getArity
```
public Arity getArity()
```
    Retrieve the arity of this method, used for reporting arity to Ruby code. This arity may or may not reflect the actual specific or variable arities of the referenced method.
    
    Returns:
    The arity of the method, as reported to Ruby consumers.
  - getRealMethod
```
public DynamicMethod getRealMethod()
```
    Get the "real" method contained within this method. This simply returns self except in cases where a method is wrapped to give it a new name or new implementation class (AliasMethod, WrapperMethod, ...).
    
    Returns:
    The "real" method associated with this one
  - getCallConfig
```
public CallConfiguration getCallConfig()
```
    Get the CallConfiguration used for pre/post logic for this method handle.
    
    Returns:
    The CallConfiguration for this method handle
  - setCallConfig
```
public void setCallConfig(CallConfiguration callConfig)
```
    Set the CallConfiguration used for pre/post logic for this method handle.
    
    Parameters:
    callConfig - The CallConfiguration for this method handle
  - setNativeCall
```
public void setNativeCall(Class nativeTarget,
                 String nativeName,
                 Class nativeReturn,
                 Class[] nativeSignature,
                 boolean statik,
                 boolean java)
```
    Set the single-arity NativeCall for this method. All signatures for the non-single-arity getNativeCall will also be set to this value.
    
    Parameters:
    nativeTarget - native method target
    nativeName - native method name
    nativeReturn - native method return
    nativeSignature - native method arguments
    statik - static?
    java - plain Java method?
  - setNativeCall
```
public void setNativeCall(Class nativeTarget,
                 String nativeName,
                 Class nativeReturn,
                 Class[] nativeSignature,
                 boolean statik)
```
    Set the single-arity NativeCall for this method. All signatures for the non-single-arity getNativeCall will also be set to this value.
    
    Parameters:
    nativeTarget - native method target
    nativeName - native method name
    nativeReturn - native method return
    nativeSignature - native method arguments
    statik - static?
  - getNativeCall
```
public DynamicMethod.NativeCall getNativeCall()
```
  - getNativeCall
```
public DynamicMethod.NativeCall getNativeCall(int args,
                                     boolean block)
```
  - setNativeCall
```
public void setNativeCall(int args,
                 boolean block,
                 DynamicMethod.NativeCall nativeCall)
```
  - isNative
```
public boolean isNative()
```
    Returns true if this method is backed by native (i.e. Java) code.
    
    Returns:
    true If backed by Java code or JVM bytecode; false otherwise
  - getName
```
public String getName()
```
    Get the base name this method was defined as.
    
    Returns:
    the base name for the method
  - setName
```
public void setName(String name)
```
    Set the base name for this method.
    
    Parameters:
    name - the name to set
  - getHandle
```
public Object getHandle()
```
    Get the "handle" associated with this DynamicMethod.
    
    Returns:
    the handle
  - setHandle
```
public void setHandle(Object handle)
```
    Set the "handle" associated with this DynamicMethod.
    
    Parameters:
    handle - the handle
  - isNotImplemented
```
public boolean isNotImplemented()
```
    Whether this method is "not implemented". This is primarily to support Ruby 1.9's behavior of respond_to? yielding false if the feature in question is unsupported (but still having the method defined).
  - getMethodData
```
public MethodData getMethodData()
```
    Additional metadata about this method.
  - setNotImplemented
```
public void setNotImplemented(boolean setNotImplemented)
```
    Set whether this method is "not implemented".

Class DynamicMethod

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

implementationClass

protectedClass

visibility

callConfig

serialNumber

builtin

nativeCall

nativeCalls

name

notImplemented

handle

Constructor Detail

DynamicMethod

DynamicMethod

DynamicMethod

Method Detail

init

getSerialNumber

isBuiltin

setIsBuiltin

call

call

call

call

call

call

call

call

call

call

dup

isCallableFrom

calculateProtectedClass

getProtectedClass

getImplementationClass

isImplementedBy

setImplementationClass

getVisibility

setVisibility

isUndefined

isNull

getArity

getRealMethod

getCallConfig

setCallConfig

setNativeCall

setNativeCall

getNativeCall

getNativeCall

setNativeCall

isNative

getName

setName

getHandle

setHandle

isNotImplemented

getMethodData

setNotImplemented