All Superinterfaces:

AnnotationAccess

All Known Implementing Classes:

PlasticClassImpl
```
public interface PlasticClass
extends AnnotationAccess
```
The representation of a class while it is being instrumented and transformed. PlasticClass allows for an imperative style of development: the PlasticClass is provided to other objects; they can query it for relevant fields or methods, and invoke methods that modify the class in various ways. Ultimately, the end result is a ClassInstantiator used to create instances of the fully instrumented and transformed class. The terminology is that a class that is being transformed is "plastic", but the end result is a normal concrete class (albeit in a different class loader). Implements AnnotationAccess to provide access to annotations on the type itself. This class is expressly not thread safe; only a single thread should be responsible for operating on a PlasticClass. TODO: what about annotation inheritance?

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`PlasticClass`	`addToString(String toStringValue)`	Conditionally adds an implementation of `toString()` to the class, but only if it is not already present in the class, or in a (transformed) super-class.
`List<PlasticField>`	`getAllFields()`	Returns all non-introduced fields, in sorted order by name.
`String`	`getClassName()`	Returns the fully qualified class name of the class being transformed.
`<T extends Annotation> List<PlasticField>`	`getFieldsWithAnnotation(Class<T> annotationType)`	Matches all fields (claimed or not) that have the given annotation.
`List<PlasticMethod>`	`getMethods()`	Returns all methods of the class, in sorted order.
`<T extends Annotation> List<PlasticMethod>`	`getMethodsWithAnnotation(Class<T> annotationType)`	Matches methods with the given annotation.
`String`	`getSuperClassName()`	Returns the name of the super-class of the class being transformed.
`List<PlasticField>`	`getUnclaimedFields()`	Returns all unclaimed fields, in sorted order by name.
`PlasticField`	`introduceField(Class fieldType, String suggestedName)`	Convenience method that uses a Java class rather than a type name.
`PlasticField`	`introduceField(String typeName, String suggestedName)`	Introduces a new private field into the class.
`Set<PlasticMethod>`	`introduceInterface(Class interfaceType)`	Introduces each method defined by the interface into the class.
`PlasticMethod`	`introduceMethod(Method method)`	A convenience that creates a `MethodDescription` from the Method and introduces that.
`PlasticMethod`	`introduceMethod(MethodDescription description)`	Returns an existing method declared in this class, or introduces a new method into this class.
`PlasticMethod`	`introduceMethod(MethodDescription description, InstructionBuilderCallback callback)`	Returns an existing method declared in this class, or introduces a new method into this class.
`PlasticMethod`	`introducePrivateMethod(String typeName, String suggestedName, String[] argumentTypes, String[] exceptionTypes)`	Introduces a new private method into the class, ensuring that the method name is unique.
`boolean`	`isInterfaceImplemented(Class interfaceType)`	Returns true if this class, or a super-class, implements the indicated interface.
`boolean`	`isMethodImplemented(MethodDescription description)`	Returns true if this class has an implementation of the indicated method, or a super-class provides a non-abstract implementation.
`PlasticClass`	`onConstruct(ConstructorCallback callback)`	Adds the callback for execution when an instance of the class is instantiated.
`PlasticClass`	`proxyInterface(Class interfaceType, PlasticField field)`	Introduces the interface, and then invokes `PlasticMethod.delegateTo(PlasticField)` on each method defined by the interface.
`PlasticClass`	`proxyInterface(Class interfaceType, PlasticMethod method)`	Introduces the interface, and then invokes `PlasticMethod.delegateTo(PlasticMethod)` on each method defined by the interface.

Methods inherited from interface org.apache.tapestry5.plastic.AnnotationAccess
getAnnotation, hasAnnotation

- Method Detail
  - getClassName
```
String getClassName()
```
    Returns the fully qualified class name of the class being transformed.
  - getFieldsWithAnnotation
```
<T extends Annotation> List<PlasticField> getFieldsWithAnnotation(Class<T> annotationType)
```
    Matches all fields (claimed or not) that have the given annotation. Returns the fields in sorted order.
    
    Returns:
    
    Unmodifiable List of fields.
  - getAllFields
```
List<PlasticField> getAllFields()
```
    Returns all non-introduced fields, in sorted order by name.
    
    Returns:
    
    Unmodifiable list of fields.
  - getUnclaimedFields
```
List<PlasticField> getUnclaimedFields()
```
    Returns all unclaimed fields, in sorted order by name. This does not include introduced fields.
    
    Returns:
    
    Unmodifiable list of fields.
    
    See Also:
    
    PlasticField.claim(Object)
  - introduceField
```
PlasticField introduceField(String typeName,
                            String suggestedName)
```
    Introduces a new private field into the class.
    
    Parameters:
    
    typeName - the Java class name for the field, or (possibly) a primitive type name or an array
    
    suggestedName - the suggested name for the field, which may be modified to ensure that the field name is unique
    
    Returns:
    
    PlasticField for the introduced field
  - introduceField
```
PlasticField introduceField(Class fieldType,
                            String suggestedName)
```
    Convenience method that uses a Java class rather than a type name.
  - introducePrivateMethod
```
PlasticMethod introducePrivateMethod(String typeName,
                                     String suggestedName,
                                     String[] argumentTypes,
                                     String[] exceptionTypes)
```
    Introduces a new private method into the class, ensuring that the method name is unique.
    
    Parameters:
    
    typeName - return type of method
    
    suggestedName - suggested name for the method; the actual method name may be modified to ensure uniqueness
    
    argumentTypes - types of any arguments (may be null)
    
    exceptionTypes - type of any checked exceptions (may be null)
    
    Returns:
    
    new method, with default implementation
  - getMethodsWithAnnotation
```
<T extends Annotation> List<PlasticMethod> getMethodsWithAnnotation(Class<T> annotationType)
```
    Matches methods with the given annotation.
    
    Returns:
    
    Unmodifiable list of methods, in sorted order.
  - getMethods
```
List<PlasticMethod> getMethods()
```
    Returns all methods of the class, in sorted order. This does not include static methods, or any introduced methods.
    
    Returns:
    
    Unmodifiable list of methods.
  - introduceMethod
```
PlasticMethod introduceMethod(MethodDescription description)
```
    Returns an existing method declared in this class, or introduces a new method into this class. The method is created with default behavior. If the method overrides a non-private, non-abstract method implemented in a transformed super class, the the default behavior is to invoke that method and return its value. Otherwise, the default behavior is to ignore parameters and return 0, false, or null. Void methods will invoke the super-class implementation (if it exists) and return no value. It is allowed for the method description to indicate an abstract method; however the abstract flag will be removed, and a non-abstract method will be created.
    
    Parameters:
    
    description - describes the method name, visibility, return value, etc.
    
    Returns:
    
    a new (or previously created) PlasticMethod for the method
    
    Throws:
    
    IllegalArgumentException - if the method is abstract or static
  - introduceMethod
```
PlasticMethod introduceMethod(MethodDescription description,
                              InstructionBuilderCallback callback)
```
    Returns an existing method declared in this class, or introduces a new method into this class. The method is created with default behavior. It is allowed for the method description to indicate an abstract method; however the abstract flag will be removed, and a non-abstract method will be created.
    
    Parameters:
    
    description - describes the method name, visibility, return value, etc.
    
    callback - used to create the implementation of the method
    
    Returns:
    
    a new (or previously created) PlasticMethod for the method
    
    Throws:
    
    IllegalArgumentException - if the method is abstract or static
  - introduceMethod
```
PlasticMethod introduceMethod(Method method)
```
    A convenience that creates a MethodDescription from the Method and introduces that. This is often invoked when walking the methods of an interface and introducing each of those methods. Introduced methods are always concrete, not abstract. The abstract flag on the method modifiers will always be stripped off, which is handy when introducing methods from an interface.
    
    Parameters:
    
    method - to introduce
    
    Returns:
    
    new (or previously created) PlasticMethod
  - introduceInterface
```
Set<PlasticMethod> introduceInterface(Class interfaceType)
```
    Introduces each method defined by the interface into the class. Determines which new methods must be introduced in order to ensure that all methods of the interface are implemented. The newly introduced methods, if any, are returned.
  - proxyInterface
```
PlasticClass proxyInterface(Class interfaceType,
                            PlasticField field)
```
    Introduces the interface, and then invokes PlasticMethod.delegateTo(PlasticField) on each method defined by the interface.
    
    Parameters:
    
    interfaceType - defines the interface to proxy
    
    field - field containing an object to delegate to
    
    Returns:
    
    this plastic class, for further configuration
  - proxyInterface
```
PlasticClass proxyInterface(Class interfaceType,
                            PlasticMethod method)
```
    Introduces the interface, and then invokes PlasticMethod.delegateTo(PlasticMethod) on each method defined by the interface.
    
    Parameters:
    
    interfaceType - defines the interface to proxy
    
    method - method to delegate to
    
    Returns:
    
    this plastic class, for further configuration
    
    Since:
    
    5.4.4
  - addToString
```
PlasticClass addToString(String toStringValue)
```
    Conditionally adds an implementation of toString() to the class, but only if it is not already present in the class, or in a (transformed) super-class.
    
    Parameters:
    
    toStringValue - the fixed value to be returned from invoking toString()
    
    Returns:
    
    this plastic class, for further configuration
  - isMethodImplemented
```
boolean isMethodImplemented(MethodDescription description)
```
    Returns true if this class has an implementation of the indicated method, or a super-class provides a non-abstract implementation.
  - isInterfaceImplemented
```
boolean isInterfaceImplemented(Class interfaceType)
```
    Returns true if this class, or a super-class, implements the indicated interface.
    
    Parameters:
    
    interfaceType -
    
    Returns:
    
    true if the interface is implemented
  - getSuperClassName
```
String getSuperClassName()
```
    Returns the name of the super-class of the class being transformed.
  - onConstruct
```
PlasticClass onConstruct(ConstructorCallback callback)
```
    Adds the callback for execution when an instance of the class is instantiated.
    
    Parameters:
    
    callback - to execute at instance construction time

Interface PlasticClass

Method Summary

Methods inherited from interface org.apache.tapestry5.plastic.AnnotationAccess

Method Detail

getClassName

getFieldsWithAnnotation

getAllFields

getUnclaimedFields

introduceField

introduceField

introducePrivateMethod

getMethodsWithAnnotation

getMethods

introduceMethod

introduceMethod

introduceMethod

introduceInterface

proxyInterface

proxyInterface

addToString

isMethodImplemented

isInterfaceImplemented

getSuperClassName

onConstruct