org.apache.tapestry5.internal.plastic

## Class PlasticClassImpl

- java.lang.Object
- - org.apache.tapestry5.internal.plastic.Lockable
  - - org.apache.tapestry5.internal.plastic.PlasticClassImpl

- All Implemented Interfaces:
    org.apache.tapestry5.internal.plastic.asm.Opcodes, InternalPlasticClassTransformation, AnnotationAccess, PlasticClass, PlasticClassTransformation

      public class PlasticClassImpl
      extends Lockable
      implements PlasticClass, InternalPlasticClassTransformation, org.apache.tapestry5.internal.plastic.asm.Opcodes

- - ### Field Summary

    - ### Fields inherited from interface org.apache.tapestry5.internal.plastic.asm.Opcodes

      `AALOAD, AASTORE, ACC_ABSTRACT, ACC_ANNOTATION, ACC_BRIDGE, ACC_DEPRECATED, ACC_ENUM, ACC_FINAL, ACC_INTERFACE, ACC_MANDATED, ACC_NATIVE, ACC_PRIVATE, ACC_PROTECTED, ACC_PUBLIC, ACC_STATIC, ACC_STRICT, ACC_SUPER, ACC_SYNCHRONIZED, ACC_SYNTHETIC, ACC_TRANSIENT, ACC_VARARGS, ACC_VOLATILE, ACONST_NULL, ALOAD, ANEWARRAY, ARETURN, ARRAYLENGTH, ASM4, ASM5, ASTORE, ATHROW, BALOAD, BASTORE, BIPUSH, CALOAD, CASTORE, CHECKCAST, D2F, D2I, D2L, DADD, DALOAD, DASTORE, DCMPG, DCMPL, DCONST_0, DCONST_1, DDIV, DLOAD, DMUL, DNEG, DOUBLE, DREM, DRETURN, DSTORE, DSUB, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1, DUP2_X2, F_APPEND, F_CHOP, F_FULL, F_NEW, F_SAME, F_SAME1, F2D, F2I, F2L, FADD, FALOAD, FASTORE, FCMPG, FCMPL, FCONST_0, FCONST_1, FCONST_2, FDIV, FLOAD, FLOAT, FMUL, FNEG, FREM, FRETURN, FSTORE, FSUB, GETFIELD, GETSTATIC, GOTO, H_GETFIELD, H_GETSTATIC, H_INVOKEINTERFACE, H_INVOKESPECIAL, H_INVOKESTATIC, H_INVOKEVIRTUAL, H_NEWINVOKESPECIAL, H_PUTFIELD, H_PUTSTATIC, I2B, I2C, I2D, I2F, I2L, I2S, IADD, IALOAD, IAND, IASTORE, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5, ICONST_M1, IDIV, IF_ACMPEQ, IF_ACMPNE, IF_ICMPEQ, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, IF_ICMPLT, IF_ICMPNE, IFEQ, IFGE, IFGT, IFLE, IFLT, IFNE, IFNONNULL, IFNULL, IINC, ILOAD, IMUL, INEG, INSTANCEOF, INTEGER, INVOKEDYNAMIC, INVOKEINTERFACE, INVOKESPECIAL, INVOKESTATIC, INVOKEVIRTUAL, IOR, IREM, IRETURN, ISHL, ISHR, ISTORE, ISUB, IUSHR, IXOR, JSR, L2D, L2F, L2I, LADD, LALOAD, LAND, LASTORE, LCMP, LCONST_0, LCONST_1, LDC, LDIV, LLOAD, LMUL, LNEG, LONG, LOOKUPSWITCH, LOR, LREM, LRETURN, LSHL, LSHR, LSTORE, LSUB, LUSHR, LXOR, MONITORENTER, MONITOREXIT, MULTIANEWARRAY, NEW, NEWARRAY, NOP, NULL, POP, POP2, PUTFIELD, PUTSTATIC, RET, RETURN, SALOAD, SASTORE, SIPUSH, SWAP, T_BOOLEAN, T_BYTE, T_CHAR, T_DOUBLE, T_FLOAT, T_INT, T_LONG, T_SHORT, TABLESWITCH, TOP, UNINITIALIZED_THIS, V1_1, V1_2, V1_3, V1_4, V1_5, V1_6, V1_7, V1_8`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PlasticClassImpl(org.apache.tapestry5.internal.plastic.asm.tree.ClassNode classNode, org.apache.tapestry5.internal.plastic.asm.tree.ClassNode implementationClassNode, PlasticClassPool pool, InheritanceData parentInheritanceData, StaticContext parentStaticContext, boolean proxy)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and 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.
    `ClassInstantiator` | `createInstantiator()` Terminates the class transformation process, finishes any final bookkeeping, and returns an object used to instantiate the transformed class.
    `PlasticClassHandleShim` | `createShimInstance()`
    `List<PlasticField>` | `getAllFields()` Returns all non-introduced fields, in sorted order by name.
    `<T extends Annotation> T` | `getAnnotation(Class<T> annotationType)` Returns an instantiated annotation, or null if the target does not have the indicated annotation.
    `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.
    `PlasticClass` | `getPlasticClass()` Returns the PlasticClass being transformed.
    `String` | `getSuperClassName()` Returns the name of the super-class of the class being transformed.
    `Class<?>` | `getTransformedClass()`
    `List<PlasticField>` | `getUnclaimedFields()` Returns all unclaimed fields, in sorted order by name.
    `<T extends Annotation> boolean` | `hasAnnotation(Class<T> annotationType)` Checks to see if the target has an annotation of the given type.
    `void` | `installShim(PlasticClassHandleShim shim)`
    `PlasticField` | `introduceField(Class fieldType, String suggestedName)` Convenience method that uses a Java class rather than a type name.
    `PlasticField` | `introduceField(String className, 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.
    `String` | `toString()`

    - ### Methods inherited from class org.apache.tapestry5.internal.plastic.Lockable

      `check, lock`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### PlasticClassImpl

          public PlasticClassImpl(org.apache.tapestry5.internal.plastic.asm.tree.ClassNode classNode,
                          org.apache.tapestry5.internal.plastic.asm.tree.ClassNode implementationClassNode,
                          PlasticClassPool pool,
                          InheritanceData parentInheritanceData,
                          StaticContext parentStaticContext,
                          boolean proxy)

      Parameters:
        `classNode` -
        `implementationClassNode` -
        `pool` -
        `parentInheritanceData` -
        `parentStaticContext` -
        `proxy` -

  - ### Method Detail

    - #### hasAnnotation

          public <T extends Annotation> boolean hasAnnotation(Class<T> annotationType)

      Description copied from interface: `AnnotationAccess`
      Checks to see if the target has an annotation of the given type.
      Specified by:
        `hasAnnotation` in interface `AnnotationAccess`

    - #### getAnnotation

          public <T extends Annotation> T getAnnotation(Class<T> annotationType)

      Description copied from interface: `AnnotationAccess`
      Returns an instantiated annotation, or null if the target does not have the indicated annotation.
      Specified by:
        `getAnnotation` in interface `AnnotationAccess`

    - #### proxyInterface

          public PlasticClass proxyInterface(Class interfaceType,
                                    PlasticField field)

      Description copied from interface: `PlasticClass`
      Introduces the interface, and then invokes `PlasticMethod.delegateTo(PlasticField)` on each method defined by the interface.
      Specified by:
        `proxyInterface` in interface `PlasticClass`
      Parameters:
        `interfaceType` - defines the interface to proxy
        `field` - field containing an object to delegate to
      Returns:
        this plastic class, for further configuration

    - #### createInstantiator

          public ClassInstantiator createInstantiator()

      Description copied from interface: `PlasticClassTransformation`
      Terminates the class transformation process, finishes any final bookkeeping, and returns an object used to instantiate the transformed class. Once this method is invoked, no other methods of the `PlasticClass` (or related objects) can be invoked.

      The returned ClassInstantiator has an empty `InstanceContext` map. Use `ClassInstantiator.with(Class, Object)` to create a new ClassInstantiator with new InstanceContext entries.

      Specified by:
        `createInstantiator` in interface `PlasticClassTransformation`

    - #### getFieldsWithAnnotation

          public <T extends Annotation> List<PlasticField> getFieldsWithAnnotation(Class<T> annotationType)

      Description copied from interface: `PlasticClass`
      Matches all fields (claimed or not) that have the given annotation. Returns the fields in sorted order.
      Specified by:
        `getFieldsWithAnnotation` in interface `PlasticClass`
      Returns:
        Unmodifiable List of fields.

    - #### getAllFields

          public List<PlasticField> getAllFields()

      Description copied from interface: `PlasticClass`
      Returns all non-introduced fields, in sorted order by name.
      Specified by:
        `getAllFields` in interface `PlasticClass`
      Returns:
        Unmodifiable list of fields.

    - #### getUnclaimedFields

          public List<PlasticField> getUnclaimedFields()

      Description copied from interface: `PlasticClass`
      Returns all unclaimed fields, in sorted order by name. This does not include introduced fields.
      Specified by:
        `getUnclaimedFields` in interface `PlasticClass`
      Returns:
        Unmodifiable list of fields.
      See Also:
        `PlasticField.claim(Object)`

    - #### introducePrivateMethod

          public PlasticMethod introducePrivateMethod(String typeName,
                                             String suggestedName,
                                             String[] argumentTypes,
                                             String[] exceptionTypes)

      Description copied from interface: `PlasticClass`
      Introduces a new private method into the class, ensuring that the method name is unique.
      Specified by:
        `introducePrivateMethod` in interface `PlasticClass`
      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

    - #### introduceField

          public PlasticField introduceField(String className,
                                    String suggestedName)

      Description copied from interface: `PlasticClass`
      Introduces a new private field into the class.
      Specified by:
        `introduceField` in interface `PlasticClass`
      Parameters:
        `className` - 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

          public PlasticField introduceField(Class fieldType,
                                    String suggestedName)

      Description copied from interface: `PlasticClass`
      Convenience method that uses a Java class rather than a type name.
      Specified by:
        `introduceField` in interface `PlasticClass`

    - #### getMethodsWithAnnotation

          public <T extends Annotation> List<PlasticMethod> getMethodsWithAnnotation(Class<T> annotationType)

      Description copied from interface: `PlasticClass`
      Matches methods with the given annotation.
      Specified by:
        `getMethodsWithAnnotation` in interface `PlasticClass`
      Returns:
        Unmodifiable list of methods, in sorted order.

    - #### getMethods

          public List<PlasticMethod> getMethods()

      Description copied from interface: `PlasticClass`
      Returns all methods of the class, in sorted order. This does not include static methods, or any introduced methods.
      Specified by:
        `getMethods` in interface `PlasticClass`
      Returns:
        Unmodifiable list of methods.

    - #### introduceMethod

          public PlasticMethod introduceMethod(MethodDescription description)

      Description copied from interface: `PlasticClass`
      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.
      Specified by:
        `introduceMethod` in interface `PlasticClass`
      Parameters:
        `description` - describes the method name, visibility, return value, etc.
      Returns:
        a new (or previously created) PlasticMethod for the method

    - #### introduceMethod

          public PlasticMethod introduceMethod(MethodDescription description,
                                      InstructionBuilderCallback callback)

      Description copied from interface: `PlasticClass`
      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.
      Specified by:
        `introduceMethod` in interface `PlasticClass`
      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

    - #### introduceMethod

          public PlasticMethod introduceMethod(Method method)

      Description copied from interface: `PlasticClass`
      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.
      Specified by:
        `introduceMethod` in interface `PlasticClass`
      Parameters:
        `method` - to introduce
      Returns:
        new (or previously created) PlasticMethod

    - #### installShim

          public void installShim(PlasticClassHandleShim shim)

    - #### createShimInstance

          public PlasticClassHandleShim createShimInstance()

    - #### getPlasticClass

          public PlasticClass getPlasticClass()

      Description copied from interface: `PlasticClassTransformation`
      Returns the PlasticClass being transformed.
      Specified by:
        `getPlasticClass` in interface `PlasticClassTransformation`
      Returns:
        PlasticClass instance

    - #### getTransformedClass

          public Class<?> getTransformedClass()

      Specified by:
        `getTransformedClass` in interface `InternalPlasticClassTransformation`

    - #### getClassName

          public String getClassName()

      Description copied from interface: `PlasticClass`
      Returns the fully qualified class name of the class being transformed.
      Specified by:
        `getClassName` in interface `PlasticClass`

    - #### introduceInterface

          public Set<PlasticMethod> introduceInterface(Class interfaceType)

      Description copied from interface: `PlasticClass`
      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.
      Specified by:
        `introduceInterface` in interface `PlasticClass`

    - #### addToString

          public PlasticClass addToString(String toStringValue)

      Description copied from interface: `PlasticClass`
      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.
      Specified by:
        `addToString` in interface `PlasticClass`
      Parameters:
        `toStringValue` - the fixed value to be returned from invoking toString()
      Returns:
        this plastic class, for further configuration

    - #### isMethodImplemented

          public boolean isMethodImplemented(MethodDescription description)

      Description copied from interface: `PlasticClass`
      Returns true if this class has an implementation of the indicated method, or a super-class provides a non-abstract implementation.
      Specified by:
        `isMethodImplemented` in interface `PlasticClass`

    - #### isInterfaceImplemented

          public boolean isInterfaceImplemented(Class interfaceType)

      Description copied from interface: `PlasticClass`
      Returns true if this class, or a super-class, implements the indicated interface.
      Specified by:
        `isInterfaceImplemented` in interface `PlasticClass`
      Returns:
        true if the interface is implemented

    - #### getSuperClassName

          public String getSuperClassName()

      Description copied from interface: `PlasticClass`
      Returns the name of the super-class of the class being transformed.
      Specified by:
        `getSuperClassName` in interface `PlasticClass`

    - #### onConstruct

          public PlasticClass onConstruct(ConstructorCallback callback)

      Description copied from interface: `PlasticClass`
      Adds the callback for execution when an instance of the class is instantiated.
      Specified by:
        `onConstruct` in interface `PlasticClass`
      Parameters:
        `callback` - to execute at instance construction time

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

${project.version} - Copyright © 2003-2014 The Apache Software Foundation.