java.lang.Object
- org.eclipse.persistence.dynamic.DynamicClassWriter

All Implemented Interfaces:

EclipseLinkClassWriter
```
public class DynamicClassWriter
extends Object
implements EclipseLinkClassWriter
```
Write the byte codes of a dynamic entity class. The class writer will create the byte codes for a dynamic class that subclasses any provided class replicating its constructors and writeReplace method (if one exists).
The intent is to provide a common writer for dynamic JPA entities but also allow for subclasses of this to be used in more complex writing situations such as SDO and DBWS.
Instances of this class and any subclasses are maintained within the DynamicClassLoader.getClassWriters() and DynamicClassLoader.defaultWriter for the life of the class loader so it is important that no unnecessary state be maintained that may effect memory usage.

Since:

EclipseLink 1.2

Author:

dclarke, mnorman

Field Summary

Fields
Modifier and Type	Field	Description
`protected static String`	`CLINIT`
`protected static String`	`DYNAMIC_PROPERTIES_MANAGER_CLASSNAME_SLASHES`
`static int[]`	`ICONST`
`protected static String`	`INIT`
`protected Class<?>`	`parentClass`
`protected String`	`parentClassName`	Name of parent class.

Constructor Summary

Constructors
Constructor	Description
`DynamicClassWriter()`
`DynamicClassWriter(Class<?> parentClass)`
`DynamicClassWriter(String parentClassName)`	Create using a loader and class name so that the parent class can be lazily loaded when the writer is used to generate a dynamic class.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`addFields(org.eclipse.persistence.internal.libraries.asm.ClassWriter cw, String parentClassType)`	Allow subclasses to add additional state to the dynamic entity.
`protected void`	`addInterface(String intf)`	Allow subclasses to add additional interfaces to the dynamic entity.
`protected void`	`addMethods(org.eclipse.persistence.internal.libraries.asm.ClassWriter cw, String parentClassType)`	Allow subclasses to add additional methods to the dynamic entity.
`protected DynamicClassWriter`	`createCopy(Class<?> parentClass)`	Create a copy of this `DynamicClassWriter` but with a different parent class.
`protected byte[]`	`createEnum(DynamicClassLoader.EnumInfo enumInfo)`
`protected String[]`	`getInterfaces()`	Interfaces the dynamic entity class implements.
`Class<?>`	`getParentClass()`
`String`	`getParentClassName()`
`boolean`	`isCompatible(EclipseLinkClassWriter writer)`	Verify that the provided writer is compatible with the current writer.
`String`	`toString()`
`protected boolean`	`verify(Class<?> dynamicClass, ClassLoader loader)`	Verify that the provided class meets the requirements of the writer.
`byte[]`	`writeClass(DynamicClassLoader loader, String className)`

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

- Field Detail
  - DYNAMIC_PROPERTIES_MANAGER_CLASSNAME_SLASHES
```
protected static final String DYNAMIC_PROPERTIES_MANAGER_CLASSNAME_SLASHES
```
  - INIT
```
protected static final String INIT
```
    See Also:
    
    Constant Field Values
  - CLINIT
```
protected static final String CLINIT
```
    See Also:
    
    Constant Field Values
  - parentClass
```
protected Class<?> parentClass
```
  - parentClassName
```
protected String parentClassName
```
    Name of parent class. This is used only when the parent class is not known at the time the dynamic class writer is registered. This is generally only required when loading from an XML mapping file where the order of class access is not known.
  - ICONST
```
public static int[] ICONST
```
- Constructor Detail
  - DynamicClassWriter
```
public DynamicClassWriter()
```
  - DynamicClassWriter
```
public DynamicClassWriter(Class<?> parentClass)
```
  - DynamicClassWriter
```
public DynamicClassWriter(String parentClassName)
```
    Create using a loader and class name so that the parent class can be lazily loaded when the writer is used to generate a dynamic class.
    The loader must not be null and the parentClassName must not be null and not an empty String. The parentClassName will be converted to a class using the provided loader lazily.
    
    See Also:
    
    getParentClass(), DynamicException.illegalDynamicClassWriter(DynamicClassLoader, String)
- Method Detail
  - getParentClass
```
public Class<?> getParentClass()
```
    Specified by:
    
    getParentClass in interface EclipseLinkClassWriter
  - getParentClassName
```
public String getParentClassName()
```
    Specified by:
    
    getParentClassName in interface EclipseLinkClassWriter
  - writeClass
```
public byte[] writeClass(DynamicClassLoader loader,
                         String className)
                  throws ClassNotFoundException
```
    Specified by:
    
    writeClass in interface EclipseLinkClassWriter
    
    Throws:
    
    ClassNotFoundException
  - addInterface
```
protected void addInterface(String intf)
```
    Allow subclasses to add additional interfaces to the dynamic entity.
    
    Parameters:
    
    intf - additional interface
  - addFields
```
protected void addFields(org.eclipse.persistence.internal.libraries.asm.ClassWriter cw,
                         String parentClassType)
```
    Allow subclasses to add additional state to the dynamic entity.
    
    Parameters:
    
    cw -
    
    parentClassType -
  - addMethods
```
protected void addMethods(org.eclipse.persistence.internal.libraries.asm.ClassWriter cw,
                          String parentClassType)
```
    Allow subclasses to add additional methods to the dynamic entity.
    
    Parameters:
    
    cw -
    
    parentClassType -
  - createEnum
```
protected byte[] createEnum(DynamicClassLoader.EnumInfo enumInfo)
```
  - verify
```
protected boolean verify(Class<?> dynamicClass,
                         ClassLoader loader)
                  throws ClassNotFoundException
```
    Verify that the provided class meets the requirements of the writer. In the case of DynamicClassWriter this will ensure that the class is a subclass of the parentClass
    
    Parameters:
    
    dynamicClass -
    
    Throws:
    
    ClassNotFoundException
  - getInterfaces
```
protected String[] getInterfaces()
```
    Interfaces the dynamic entity class implements. By default this is none but in the case of SDO a concrete interface must be implemented. Subclasses should override this as required.
    
    Returns:
    
    Interfaces implemented by Dynamic class. May be null
  - createCopy
```
protected DynamicClassWriter createCopy(Class<?> parentClass)
```
    Create a copy of this DynamicClassWriter but with a different parent class.
    
    See Also:
    
    DynamicClassLoader.addClass(String, Class)
  - isCompatible
```
public boolean isCompatible(EclipseLinkClassWriter writer)
```
    Verify that the provided writer is compatible with the current writer. Returning true means that the bytes that would be created using this writer are identical with what would come from the provided writer.
    Used in DynamicClassLoader.addClass(String, EclipseLinkClassWriter) to verify if a duplicate request of the same className can proceed and return the same class that may already exist.
    
    Specified by:
    
    isCompatible in interface EclipseLinkClassWriter
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class DynamicClassWriter

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DYNAMIC_PROPERTIES_MANAGER_CLASSNAME_SLASHES

INIT

CLINIT

parentClass

parentClassName

ICONST

Constructor Detail

DynamicClassWriter

DynamicClassWriter

DynamicClassWriter

Method Detail

getParentClass

getParentClassName

writeClass

addInterface

addFields

addMethods

createEnum

verify

getInterfaces

createCopy

isCompatible

toString