org.dynalang.dynalink.beans

Class BeansLinker

java.lang.Object

org.dynalang.dynalink.beans.BeansLinker

All Implemented Interfaces:

GuardingDynamicLinker

public class BeansLinker
extends Object
implements GuardingDynamicLinker

A linker for POJOs. Normally used as the ultimate fallback linker by the DynamicLinkerFactory so it is given the chance to link calls to all objects that no other language runtime recognizes. Specifically, this linker will:

• expose all public methods of form setXxx(), getXxx(), and isXxx() as property setters and getters for dyn:setProp and dyn:getProp operations;
• expose all property getters and setters declared by the class' BeanInfo;
• expose all public methods and methods declared by the class' BeanInfo for invocation through dyn:callMethod operation;
• expose all public methods and methods declared by the class' BeanInfo for retrieval for dyn:getMethod operation; the methods thus retrieved can then be invoked using dyn:call;
• expose all public fields as properties, unless there are getters or setters for the properties of the same name;
• expose dyn:getLength, dyn:getElem and dyn:setElem on native Java arrays, as well as List and Map objects; (dyn:getLength works on any Collection);
• expose a virtual property named length on Java arrays;
• expose dyn:new on instances of StaticClass as calls to constructors, including those static class objects that represent Java arrays (their constructors take a single int parameter representing the length of the array to create);
• expose static methods, fields, and properties of classes in a similar manner to how instance method, fields, and properties are exposed, on StaticClass objects.
• expose a virtual property named static on instances of Class to access their StaticClass.

Overloaded method resolution is performed automatically for property setters, methods, and constructors. Additionally, manual overloaded method selection is supported by having a call site specify a name for a method that contains an explicit signature, i.e. dyn:getMethod:parseInt(String,int). You can use non-qualified class names in such signatures regardless of those classes' packages, they will match any class with the same non-qualified name. You only have to use a fully qualified class name in case non-qualified class names would cause selection ambiguity (that is extremely rare).

Variable argument invocation is handled for both methods and constructors.

Currently, only public fields and methods are supported. Any Lookup objects passed in the LinkRequests are ignored and MethodHandles.publicLookup() is used instead.

Author:

Attila Szegedi

Constructor Summary

Constructors

Constructor and Description
BeansLinker() Creates a new POJO linker.

Method Summary

Methods

Modifier and Type	Method and Description
GuardedInvocation	getGuardedInvocation(LinkRequest request, LinkerServices linkerServices) Creates a guarded invocation appropriate for a particular invocation with the specified arguments at a call site.
static TypeBasedGuardingDynamicLinker	getLinkerForClass(Class<?> clazz) Returns a bean linker for a particular single class.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BeansLinker

public BeansLinker()

Creates a new POJO linker.

Method Detail

getLinkerForClass

public static TypeBasedGuardingDynamicLinker getLinkerForClass(Class<?> clazz)

Returns a bean linker for a particular single class. Useful when you need to override or extend the behavior of linking for some classes in your language runtime's linker, but still want to delegate to the default behavior in some cases.

Parameters:

clazz - the class

Returns:

a bean linker for that class

getGuardedInvocation

public GuardedInvocation getGuardedInvocation(LinkRequest request,
                                     LinkerServices linkerServices)
                                       throws Exception

Description copied from interface: GuardingDynamicLinker

Creates a guarded invocation appropriate for a particular invocation with the specified arguments at a call site.

Specified by:

getGuardedInvocation in interface GuardingDynamicLinker

Parameters:

request - the object describing the request for linking a particular invocation

linkerServices - linker services

Returns:

a guarded invocation with a method handle suitable for the arguments, as well as a guard condition that if fails should trigger relinking. Must return null if it can't resolve the invocation. If the returned invocation is unconditional (which is actually quite rare), the guard in the return value can be null. The invocation can also have a switch point for asynchronous invalidation of the linkage. If the linker does not recognize any native language runtime contexts in arguments, or does recognize its own, but receives a call site descriptor without its recognized context in the arguments, it should invoke LinkRequest.withoutRuntimeContext() and link for that.

Throws:

Exception - if the operation fails for whatever reason