Forwarding (Byte Buddy (with dependencies) 0.7 API)

java.lang.Object
- net.bytebuddy.implementation.Forwarding

All Implemented Interfaces:

Implementation
```
public class Forwarding
extends Object
implements Implementation
```
This implementation forwards method invocations to another instance. For this, the intercepted method must be defined on a super type of the given delegation target. Static methods cannot be forwarded as they are not invoked on an instance.

See Also:

MethodDelegation

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`Forwarding.Appender` An appender for implementing a `Forwarding` operation.
`protected static interface`	`Forwarding.PreparationHandler` A handler for preparing a `Forwarding` implementation.

Nested classes/interfaces inherited from interface net.bytebuddy.implementation.Implementation
Implementation.Composable, Implementation.Compound, Implementation.Context, Implementation.Simple, Implementation.SpecialMethodInvocation, Implementation.Target

Field Summary

Fields
Modifier and Type	Field and Description
`protected String`	`fieldName` The name of the field.
`protected TypeDescription`	`fieldType` The type of the field.
`protected Forwarding.PreparationHandler`	`preparationHandler` A handler for preparing the instrumented type and the field invocation operation.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Forwarding(String fieldName, TypeDescription fieldType, Forwarding.PreparationHandler preparationHandler)` Creates a new forwarding implementation.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ByteCodeAppender`	`appender(Implementation.Target implementationTarget)` Creates a byte code appender that determines the implementation of the instrumented type's methods.
`boolean`	`equals(Object other)`
`int`	`hashCode()`
`InstrumentedType`	`prepare(InstrumentedType instrumentedType)` During the preparation phase of an implementation, implementations are eligible to adding fields or methods to the currently instrumented type.
`static Implementation`	`to(Object delegate)` Forwards all intercepted method invocations to the given instance which is stored in a `static` field of the instrumented class.
`static Implementation`	`to(Object delegate, String fieldName)` Forwards all intercepted method invocations to the given instance which is stored in a `static` field of the instrumented class.
`static Implementation`	`toInstanceField(String fieldName, Class<?> fieldType)` Forwards all intercepted method invocations to an instance field of the instrumented class.
`static Implementation`	`toInstanceField(String fieldName, TypeDescription fieldType)` Forwards all intercepted method invocations to an instance field of the instrumented class.
`static Implementation`	`toStaticField(String fieldName, Class<?> fieldType)` Forwards all intercepted method invocations to a `static` field of the instrumented class.
`static Implementation`	`toStaticField(String fieldName, TypeDescription fieldType)` Forwards all intercepted method invocations to a `static` field of the instrumented class.
`String`	`toString()`

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

- Field Detail
  - fieldName
```
protected final String fieldName
```
    The name of the field.
  - fieldType
```
protected final TypeDescription fieldType
```
    The type of the field.
  - preparationHandler
```
protected final Forwarding.PreparationHandler preparationHandler
```
    A handler for preparing the instrumented type and the field invocation operation.
- Constructor Detail
  - Forwarding
```
protected Forwarding(String fieldName,
                     TypeDescription fieldType,
                     Forwarding.PreparationHandler preparationHandler)
```
    Creates a new forwarding implementation.
    
    Parameters:
    
    fieldName - The name of the field.
    
    fieldType - The type of the field.
    
    preparationHandler - A handler for preparing the instrumented type and the field invocation operation.
- Method Detail
  - to
```
public static Implementation to(Object delegate)
```
    Forwards all intercepted method invocations to the given instance which is stored in a static field of the instrumented class. The field name is generated from the instance's hash code.
    
    Parameters:
    
    delegate - The delegate to which all intercepted methods should be forwarded.
    
    Returns:
    
    A corresponding implementation.
  - to
```
public static Implementation to(Object delegate,
                                String fieldName)
```
    Forwards all intercepted method invocations to the given instance which is stored in a static field of the instrumented class.
    
    Parameters:
    
    delegate - The delegate to which all intercepted methods should be forwarded.
    
    fieldName - The name of the field in which the delegate should be stored.
    
    Returns:
    
    A corresponding implementation.
  - toStaticField
```
public static Implementation toStaticField(String fieldName,
                                           Class<?> fieldType)
```
    Forwards all intercepted method invocations to a static field of the instrumented class. The value of this field must be set explicitly.
    
    Parameters:
    
    fieldName - The name of the field in which the delegate should be stored.
    
    fieldType - The type of the field and thus the type of which the delegate is assumed to be of.
    
    Returns:
    
    A corresponding implementation.
  - toStaticField
```
public static Implementation toStaticField(String fieldName,
                                           TypeDescription fieldType)
```
    Forwards all intercepted method invocations to a static field of the instrumented class. The value of this field must be set explicitly.
    
    Parameters:
    
    fieldName - The name of the field in which the delegate should be stored.
    
    fieldType - The type of the field and thus the type of which the delegate is assumed to be of.
    
    Returns:
    
    A corresponding implementation.
  - toInstanceField
```
public static Implementation toInstanceField(String fieldName,
                                             Class<?> fieldType)
```
    Forwards all intercepted method invocations to an instance field of the instrumented class. The value of this field must be set explicitly.
    
    Parameters:
    
    fieldName - The name of the field in which the delegate should be stored.
    
    fieldType - The type of the field and thus the type of which the delegate is assumed to be of.
    
    Returns:
    
    A corresponding implementation.
  - toInstanceField
```
public static Implementation toInstanceField(String fieldName,
                                             TypeDescription fieldType)
```
    Forwards all intercepted method invocations to an instance field of the instrumented class. The value of this field must be set explicitly.
    
    Parameters:
    
    fieldName - The name of the field in which the delegate should be stored.
    
    fieldType - The type of the field and thus the type of which the delegate is assumed to be of.
    
    Returns:
    
    A corresponding implementation.
  - appender
```
public ByteCodeAppender appender(Implementation.Target implementationTarget)
```
    Description copied from interface: Implementation
    
    Creates a byte code appender that determines the implementation of the instrumented type's methods.
    
    Specified by:
    
    appender in interface Implementation
    
    Parameters:
    
    implementationTarget - The target of the current implementation.
    
    Returns:
    
    A byte code appender for implementing methods delegated to this implementation. This byte code appender is also responsible for handling methods that were added by this implementation on the call to Implementation.prepare(InstrumentedType).
  - prepare
```
public InstrumentedType prepare(InstrumentedType instrumentedType)
```
    Description copied from interface: Implementation
    
    During the preparation phase of an implementation, implementations are eligible to adding fields or methods to the currently instrumented type. All methods that are added by this implementation are required to be implemented by the ByteCodeAppender that is emitted on the call to Implementation.appender(Implementation.Target) call. On this method call, loaded type initializers can also be added to the instrumented type.
    
    Specified by:
    
    prepare in interface Implementation
    
    Parameters:
    
    instrumentedType - The instrumented type that is the basis of the ongoing instrumentation.
    
    Returns:
    
    The instrumented type with any applied changes, if any.
  - 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

Class Forwarding

Nested Class Summary

Nested classes/interfaces inherited from interface net.bytebuddy.implementation.Implementation

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

fieldName

fieldType

preparationHandler

Constructor Detail

Forwarding

Method Detail

to

to

toStaticField

toStaticField

toInstanceField

toInstanceField

appender

prepare

equals

hashCode

toString