ExceptionMethod (Byte Buddy (with dependencies) 0.7.3 API)

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

All Implemented Interfaces:

ByteCodeAppender, Implementation
```
public class ExceptionMethod
extends Object
implements Implementation, ByteCodeAppender
```
This implementation causes a Throwable to be thrown when the instrumented method is invoked. Be aware that the Java Virtual machine does not care about exception declarations and will throw any Throwable from any method even if the method does not declared a checked exception.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface ExceptionMethod.ConstructionDelegate
A construction delegate is responsible for calling a Throwable's constructor.
- Nested classes/interfaces inherited from interface net.bytebuddy.implementation.Implementation
  Implementation.Composable, Implementation.Compound, Implementation.Context, Implementation.Simple, Implementation.SpecialMethodInvocation, Implementation.Target
- Nested classes/interfaces inherited from interface net.bytebuddy.implementation.bytecode.ByteCodeAppender
  ByteCodeAppender.Compound, ByteCodeAppender.Simple, ByteCodeAppender.Size

Nested Classes
Modifier and Type	Class and Description
`static interface`	`ExceptionMethod.ConstructionDelegate` A construction delegate is responsible for calling a Throwable's constructor.

Constructor Summary

Constructors
Constructor and Description
`ExceptionMethod(TypeDescription throwableType, ExceptionMethod.ConstructionDelegate constructionDelegate)` Creates a new instance of an implementation for throwing throwables.

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.
`ByteCodeAppender.Size`	`apply(MethodVisitor methodVisitor, Implementation.Context implementationContext, MethodDescription instrumentedMethod)` Applies this byte code appender to a type creation process.
`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`	`throwing(Class<? extends Throwable> exceptionType)` Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
`static Implementation`	`throwing(Class<? extends Throwable> exceptionType, String message)` Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
`static Implementation`	`throwing(TypeDescription exceptionType)` Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
`static Implementation`	`throwing(TypeDescription exceptionType, String message)` Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
`String`	`toString()`

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

- Constructor Detail
  - ExceptionMethod
```
public ExceptionMethod(TypeDescription throwableType,
                       ExceptionMethod.ConstructionDelegate constructionDelegate)
```
    Creates a new instance of an implementation for throwing throwables.
    
    Parameters:
    
    throwableType - The type of the exception to be thrown.
    
    constructionDelegate - A delegate that is responsible for calling the isThrowable's constructor.
- Method Detail
  - throwing
```
public static Implementation throwing(Class<? extends Throwable> exceptionType)
```
    Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately. For this to be possible, the given type must define a default constructor which is visible from the instrumented type.
    
    Parameters:
    
    exceptionType - The type of the isThrowable.
    
    Returns:
    
    An implementation that will throw an instance of the isThrowable on each method invocation of the instrumented methods.
  - throwing
```
public static Implementation throwing(TypeDescription exceptionType)
```
    Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately. For this to be possible, the given type must define a default constructor which is visible from the instrumented type.
    
    Parameters:
    
    exceptionType - The type of the isThrowable.
    
    Returns:
    
    An implementation that will throw an instance of the isThrowable on each method invocation of the instrumented methods.
  - throwing
```
public static Implementation throwing(Class<? extends Throwable> exceptionType,
                                      String message)
```
    Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately. For this to be possible, the given type must define a constructor that takes a single String as its argument.
    
    Parameters:
    
    exceptionType - The type of the isThrowable.
    
    message - The string that is handed to the constructor. Usually an exception message.
    
    Returns:
    
    An implementation that will throw an instance of the isThrowable on each method invocation of the instrumented methods.
  - throwing
```
public static Implementation throwing(TypeDescription exceptionType,
                                      String message)
```
    Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately. For this to be possible, the given type must define a constructor that takes a single String as its argument.
    
    Parameters:
    
    exceptionType - The type of the isThrowable.
    
    message - The string that is handed to the constructor. Usually an exception message.
    
    Returns:
    
    An implementation that will throw an instance of the isThrowable on each method invocation of the instrumented methods.
  - 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.
  - 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).
  - apply
```
public ByteCodeAppender.Size apply(MethodVisitor methodVisitor,
                                   Implementation.Context implementationContext,
                                   MethodDescription instrumentedMethod)
```
    Description copied from interface: ByteCodeAppender
    
    Applies this byte code appender to a type creation process.
    
    Specified by:
    
    apply in interface ByteCodeAppender
    
    Parameters:
    
    methodVisitor - The method visitor to which the byte code appender writes its code to.
    
    implementationContext - The implementation context of the current type creation process.
    
    instrumentedMethod - The method that is the target of the instrumentation.
    
    Returns:
    
    The required size for the applied byte code to run.
  - 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 ExceptionMethod

Nested Class Summary

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

Nested classes/interfaces inherited from interface net.bytebuddy.implementation.bytecode.ByteCodeAppender

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ExceptionMethod

Method Detail

throwing

throwing

throwing

throwing

prepare

appender

apply

equals

hashCode

toString