net.bytebuddy.implementation.bind.annotation

Class Pipe.Binder

java.lang.Object

net.bytebuddy.implementation.bind.annotation.Pipe.Binder

All Implemented Interfaces:

MethodLookupEngine, MethodLookupEngine.Factory, TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe>

Enclosing class:

Pipe

public static class Pipe.Binder
extends Object
implements TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe>, MethodLookupEngine.Factory, MethodLookupEngine

A TargetMethodAnnotationDrivenBinder.ParameterBinder for binding the Pipe annotation.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	Pipe.Binder.PrecomputedFinding A precomputed finding for an installed type of a Pipe.Binder.
protected static class	Pipe.Binder.Redirection An auxiliary type for performing the redirection of a method invocation as requested by the Pipe annotation.

Nested classes/interfaces inherited from interface net.bytebuddy.dynamic.scaffold.MethodLookupEngine

MethodLookupEngine.ConflictingInterfaceMethod, MethodLookupEngine.Default, MethodLookupEngine.Factory, MethodLookupEngine.Finding, MethodLookupEngine.OverridenClassMethod

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Binder(MethodDescription forwardingMethod) Creates a new binder.

Method Summary

Modifier and Type	Method and Description
MethodDelegationBinder.ParameterBinding<?>	bind(AnnotationDescription.Loadable<Pipe> annotation, MethodDescription source, ParameterDescription target, Implementation.Target implementationTarget, Assigner assigner) Creates a parameter binding for the given target parameter.
boolean	equals(Object other)
Class<Pipe>	getHandledType() The annotation type that is handled by this parameter binder.
int	hashCode()
static TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe>	install(Class<?> type) Installs a given type for use on a Pipe annotation.
static TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe>	install(TypeDescription typeDescription) Installs a given type for use on a Pipe annotation.
MethodLookupEngine	make(boolean extractDefaultMethods) Returns a MethodLookupEngine.
MethodLookupEngine.Finding	process(TypeDescription typeDescription) Retrieves all methods that can be called on a given type.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

Binder

protected Binder(MethodDescription forwardingMethod)

Creates a new binder. This constructor is not doing any validation of the forwarding method and its declaring type. Such validation is normally performed by the install(Class) method.

Parameters:

forwardingMethod - The method which implements the behavior of forwarding a method invocation. This method needs to define a single non-static method with an Object to Object mapping.

Method Detail

install

public static TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe> install(Class<?> type)

Installs a given type for use on a Pipe annotation. The given type must be an interface without any super interfaces and a single method which maps an Object type to another Object type. The use of generics is permitted.

Parameters:

type - The type to install.

Returns:

A binder for the Pipe annotation.

install

public static TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe> install(TypeDescription typeDescription)

Installs a given type for use on a Pipe annotation. The given type must be an interface without any super interfaces and a single method which maps an Object type to another Object type. The use of generics is permitted.

Parameters:

typeDescription - The type to install.

Returns:

A binder for the Pipe annotation.

getHandledType

public Class<Pipe> getHandledType()

Description copied from interface: TargetMethodAnnotationDrivenBinder.ParameterBinder

The annotation type that is handled by this parameter binder.

Specified by:

getHandledType in interface TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe>

Returns:

The Annotation.annotationType() handled by this parameter binder.

bind

public MethodDelegationBinder.ParameterBinding<?> bind(AnnotationDescription.Loadable<Pipe> annotation,
                                                       MethodDescription source,
                                                       ParameterDescription target,
                                                       Implementation.Target implementationTarget,
                                                       Assigner assigner)

Description copied from interface: TargetMethodAnnotationDrivenBinder.ParameterBinder

Creates a parameter binding for the given target parameter.

Specified by:

bind in interface TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe>

Parameters:

annotation - The annotation that was cause for the delegation to this argument binder.

source - The intercepted source method.

target - Tge target parameter that is subject to be bound to intercepting the source method.

implementationTarget - The target of the current implementation that is subject to this binding.

assigner - An assigner that can be used for applying the binding.

Returns:

A parameter binding for the requested target method parameter.

make

public MethodLookupEngine make(boolean extractDefaultMethods)

Description copied from interface: MethodLookupEngine.Factory

Returns a MethodLookupEngine.

Specified by:

make in interface MethodLookupEngine.Factory

Parameters:

extractDefaultMethods - true if interface default methods should be resolved.

Returns:

A MethodLookupEngine.

process

public MethodLookupEngine.Finding process(TypeDescription typeDescription)

Description copied from interface: MethodLookupEngine

Retrieves all methods that can be called on a given type. The resulting list of methods must not contain any duplicates when considering byte code signatures. Furthermore, if a method is overriden, a method must be contained in its most specific version. In the process, class methods must shadow interface methods of identical signature. As an only deviation from the JVM's Class.getMethods(), methods of identical signature of incompatible interfaces must only be returned once. These methods should be represented by some sort of virtual method description which is fully aware of its state. All virtually invokable methods must be contained in this lookup. Static methods, constructors and private methods must however only be contained for the actual class's type.

The

Specified by:

process in interface MethodLookupEngine

Parameters:

typeDescription - The type for which all invokable methods should be looked up.

Returns:

The looked up methods for the given type.

equals

public boolean equals(Object other)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object