static final class NullPersistenceDelegate extends PersistenceDelegate {

// Note this will be called by all classes when they reach the

// top of their superclass chain.

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

}

protected Expression instantiate(Object oldInstance, Encoder out) { return null; }

public void writeObject(Object oldInstance, Encoder out) {

// System.out.println("NullPersistenceDelegate:writeObject " + oldInstance);

}

}

static final class EnumPersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance == newInstance;

}

protected Expression instantiate(Object oldInstance, Encoder out) {

Enum<?> e = (Enum<?>) oldInstance;

return new Expression(e, Enum.class, "valueOf", new Object[]{e.getDeclaringClass(), e.name()});

}

}

static final class PrimitivePersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

return new Expression(oldInstance, oldInstance.getClass(),

"new", new Object[]{oldInstance.toString()});

}

}

static final class ArrayPersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return (newInstance != null &&

oldInstance.getClass() == newInstance.getClass() && // Also ensures the subtype is correct.

Array.getLength(oldInstance) == Array.getLength(newInstance));

}

protected Expression instantiate(Object oldInstance, Encoder out) {

// System.out.println("instantiate: " + type + " " + oldInstance);

Class<?> oldClass = oldInstance.getClass();

return new Expression(oldInstance, Array.class, "newInstance",

new Object[]{oldClass.getComponentType(),

new Integer(Array.getLength(oldInstance))});

}

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

int n = Array.getLength(oldInstance);

for (int i = 0; i < n; i++) {

Object index = new Integer(i);

// Expression oldGetExp = new Expression(Array.class, "get", new Object[]{oldInstance, index});

// Expression newGetExp = new Expression(Array.class, "get", new Object[]{newInstance, index});

Expression oldGetExp = new Expression(oldInstance, "get", new Object[]{index});

Expression newGetExp = new Expression(newInstance, "get", new Object[]{index});

try {

Object oldValue = oldGetExp.getValue();

Object newValue = newGetExp.getValue();

out.writeExpression(oldGetExp);

if (!Objects.equals(newValue, out.get(oldValue))) {

// System.out.println("Not equal: " + newGetExp + " != " + actualGetExp);

// invokeStatement(Array.class, "set", new Object[]{oldInstance, index, oldValue}, out);

DefaultPersistenceDelegate.invokeStatement(oldInstance, "set", new Object[]{index, oldValue}, out);

}

}

catch (Exception e) {

// System.err.println("Warning:: failed to write: " + oldGetExp);

out.getExceptionListener().exceptionThrown(e);

}

}

}

}

static final class ProxyPersistenceDelegate extends PersistenceDelegate {

protected Expression instantiate(Object oldInstance, Encoder out) {

Class<?> type = oldInstance.getClass();

java.lang.reflect.Proxy p = (java.lang.reflect.Proxy)oldInstance;

// This unappealing hack is not required but makes the

// representation of EventHandlers much more concise.

java.lang.reflect.InvocationHandler ih = java.lang.reflect.Proxy.getInvocationHandler(p);

if (ih instanceof EventHandler) {

EventHandler eh = (EventHandler)ih;

Vector<Object> args = new Vector<>();

args.add(type.getInterfaces()[0]);

args.add(eh.getTarget());

args.add(eh.getAction());

if (eh.getEventPropertyName() != null) {

args.add(eh.getEventPropertyName());

}

if (eh.getListenerMethodName() != null) {

args.setSize(4);

args.add(eh.getListenerMethodName());

}

return new Expression(oldInstance,

EventHandler.class,

"create",

args.toArray());

}

return new Expression(oldInstance,

java.lang.reflect.Proxy.class,

"newProxyInstance",

new Object[]{type.getClassLoader(),

type.getInterfaces(),

ih});

}

}

static final class java_lang_String_PersistenceDelegate extends PersistenceDelegate {

protected Expression instantiate(Object oldInstance, Encoder out) { return null; }

public void writeObject(Object oldInstance, Encoder out) {

// System.out.println("NullPersistenceDelegate:writeObject " + oldInstance);

}

}

static final class java_lang_Class_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

Class<?> c = (Class)oldInstance;

// As of 1.3 it is not possible to call Class.forName("int"),

// so we have to generate different code for primitive types.

// This is needed for arrays whose subtype may be primitive.

if (c.isPrimitive()) {

Field field = null;

try {

field = PrimitiveWrapperMap.getType(c.getName()).getDeclaredField("TYPE");

} catch (NoSuchFieldException ex) {

System.err.println("Unknown primitive type: " + c);

}

return new Expression(oldInstance, field, "get", new Object[]{null});

}

else if (oldInstance == String.class) {

return new Expression(oldInstance, "", "getClass", new Object[]{});

}

else if (oldInstance == Class.class) {

return new Expression(oldInstance, String.class, "getClass", new Object[]{});

}

else {

Expression newInstance = new Expression(oldInstance, Class.class, "forName", new Object[] { c.getName() });

newInstance.loader = c.getClassLoader();

return newInstance;

}

}

}

static final class java_lang_reflect_Field_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

Field f = (Field)oldInstance;

return new Expression(oldInstance,

f.getDeclaringClass(),

"getField",

new Object[]{f.getName()});

}

}

static final class java_lang_reflect_Method_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

Method m = (Method)oldInstance;

return new Expression(oldInstance,

m.getDeclaringClass(),

"getMethod",

new Object[]{m.getName(), m.getParameterTypes()});

}

}

static class java_util_Date_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

if (!super.mutatesTo(oldInstance, newInstance)) {

return false;

}

Date oldDate = (Date)oldInstance;

Date newDate = (Date)newInstance;

return oldDate.getTime() == newDate.getTime();

}

protected Expression instantiate(Object oldInstance, Encoder out) {

Date date = (Date)oldInstance;

return new Expression(date, date.getClass(), "new", new Object[] {date.getTime()});

}

}

static final class java_sql_Timestamp_PersistenceDelegate extends java_util_Date_PersistenceDelegate {

private static final Method getNanosMethod = getNanosMethod();

private static Method getNanosMethod() {

try {

Class<?> c = Class.forName("java.sql.Timestamp", true, null);

return c.getMethod("getNanos");

} catch (ClassNotFoundException e) {

return null;

} catch (NoSuchMethodException e) {

throw new AssertionError(e);

}

}

/**

private static int getNanos(Object obj) {

if (getNanosMethod == null)

throw new AssertionError("Should not get here");

try {

return (Integer)getNanosMethod.invoke(obj);

} catch (InvocationTargetException e) {

Throwable cause = e.getCause();

if (cause instanceof RuntimeException)

throw (RuntimeException)cause;

if (cause instanceof Error)

throw (Error)cause;

throw new AssertionError(e);

} catch (IllegalAccessException iae) {

throw new AssertionError(iae);

}

}

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

// assumes oldInstance and newInstance are Timestamps

int nanos = getNanos(oldInstance);

if (nanos != getNanos(newInstance)) {

out.writeStatement(new Statement(oldInstance, "setNanos", new Object[] {nanos}));

}

}

}

private static abstract class java_util_Collections extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

if (!super.mutatesTo(oldInstance, newInstance)) {

return false;

}

if ((oldInstance instanceof List) || (oldInstance instanceof Set) || (oldInstance instanceof Map)) {

return oldInstance.equals(newInstance);

}

Collection<?> oldC = (Collection<?>) oldInstance;

Collection<?> newC = (Collection<?>) newInstance;

return (oldC.size() == newC.size()) && oldC.containsAll(newC);

}

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

// do not initialize these custom collections in default way

}

static final class EmptyList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

return new Expression(oldInstance, Collections.class, "emptyList", null);

}

}

static final class EmptySet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

return new Expression(oldInstance, Collections.class, "emptySet", null);

}

}

static final class EmptyMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

return new Expression(oldInstance, Collections.class, "emptyMap", null);

}

}

static final class SingletonList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

List<?> list = (List<?>) oldInstance;

return new Expression(oldInstance, Collections.class, "singletonList", new Object[]{list.get(0)});

}

}

static final class SingletonSet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Set<?> set = (Set<?>) oldInstance;

return new Expression(oldInstance, Collections.class, "singleton", new Object[]{set.iterator().next()});

}

}

static final class SingletonMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Map<?,?> map = (Map<?,?>) oldInstance;

Object key = map.keySet().iterator().next();

return new Expression(oldInstance, Collections.class, "singletonMap", new Object[]{key, map.get(key)});

}

}

static final class UnmodifiableCollection_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

List<?> list = new ArrayList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "unmodifiableCollection", new Object[]{list});

}

}

static final class UnmodifiableList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

List<?> list = new LinkedList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});

}

}

static final class UnmodifiableRandomAccessList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

List<?> list = new ArrayList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});

}

}

static final class UnmodifiableSet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Set<?> set = new HashSet<>((Set<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "unmodifiableSet", new Object[]{set});

}

}

static final class UnmodifiableSortedSet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

SortedSet<?> set = new TreeSet<>((SortedSet<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "unmodifiableSortedSet", new Object[]{set});

}

}

static final class UnmodifiableMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Map<?,?> map = new HashMap<>((Map<?,?>) oldInstance);

return new Expression(oldInstance, Collections.class, "unmodifiableMap", new Object[]{map});

}

}

static final class UnmodifiableSortedMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

SortedMap<?,?> map = new TreeMap<>((SortedMap<?,?>) oldInstance);

return new Expression(oldInstance, Collections.class, "unmodifiableSortedMap", new Object[]{map});

}

}

static final class SynchronizedCollection_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

List<?> list = new ArrayList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "synchronizedCollection", new Object[]{list});

}

}

static final class SynchronizedList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

List<?> list = new LinkedList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});

}

}

static final class SynchronizedRandomAccessList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

List<?> list = new ArrayList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});

}

}

static final class SynchronizedSet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Set<?> set = new HashSet<>((Set<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "synchronizedSet", new Object[]{set});

}

}

static final class SynchronizedSortedSet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

SortedSet<?> set = new TreeSet<>((SortedSet<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "synchronizedSortedSet", new Object[]{set});

}

}

static final class SynchronizedMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Map<?,?> map = new HashMap<>((Map<?,?>) oldInstance);

return new Expression(oldInstance, Collections.class, "synchronizedMap", new Object[]{map});

}

}

static final class SynchronizedSortedMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

SortedMap<?,?> map = new TreeMap<>((SortedMap<?,?>) oldInstance);

return new Expression(oldInstance, Collections.class, "synchronizedSortedMap", new Object[]{map});

}

}

static final class CheckedCollection_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");

List<?> list = new ArrayList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "checkedCollection", new Object[]{list, type});

}

}

static final class CheckedList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");

List<?> list = new LinkedList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "checkedList", new Object[]{list, type});

}

}

static final class CheckedRandomAccessList_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");

List<?> list = new ArrayList<>((Collection<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "checkedList", new Object[]{list, type});

}

}

static final class CheckedSet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");

Set<?> set = new HashSet<>((Set<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "checkedSet", new Object[]{set, type});

}

}

static final class CheckedSortedSet_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");

SortedSet<?> set = new TreeSet<>((SortedSet<?>) oldInstance);

return new Expression(oldInstance, Collections.class, "checkedSortedSet", new Object[]{set, type});

}

}

static final class CheckedMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Object keyType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.keyType");

Object valueType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.valueType");

Map<?,?> map = new HashMap<>((Map<?,?>) oldInstance);

return new Expression(oldInstance, Collections.class, "checkedMap", new Object[]{map, keyType, valueType});

}

}

static final class CheckedSortedMap_PersistenceDelegate extends java_util_Collections {

protected Expression instantiate(Object oldInstance, Encoder out) {

Object keyType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.keyType");

Object valueType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.valueType");

SortedMap<?,?> map = new TreeMap<>((SortedMap<?,?>) oldInstance);

return new Expression(oldInstance, Collections.class, "checkedSortedMap", new Object[]{map, keyType, valueType});

}

}

}

static final class java_util_EnumMap_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return super.mutatesTo(oldInstance, newInstance) && (getType(oldInstance) == getType(newInstance));

}

protected Expression instantiate(Object oldInstance, Encoder out) {

return new Expression(oldInstance, EnumMap.class, "new", new Object[] {getType(oldInstance)});

}

private static Object getType(Object instance) {

return MetaData.getPrivateFieldValue(instance, "java.util.EnumMap.keyType");

}

}

static final class java_util_EnumSet_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return super.mutatesTo(oldInstance, newInstance) && (getType(oldInstance) == getType(newInstance));

}

protected Expression instantiate(Object oldInstance, Encoder out) {

return new Expression(oldInstance, EnumSet.class, "noneOf", new Object[] {getType(oldInstance)});

}

private static Object getType(Object instance) {

return MetaData.getPrivateFieldValue(instance, "java.util.EnumSet.elementType");

}

}

static class java_util_Collection_PersistenceDelegate extends DefaultPersistenceDelegate {

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

java.util.Collection<?> oldO = (java.util.Collection)oldInstance;

java.util.Collection<?> newO = (java.util.Collection)newInstance;

if (newO.size() != 0) {

invokeStatement(oldInstance, "clear", new Object[]{}, out);

}

for (Iterator<?> i = oldO.iterator(); i.hasNext();) {

invokeStatement(oldInstance, "add", new Object[]{i.next()}, out);

}

}

}

static class java_util_List_PersistenceDelegate extends DefaultPersistenceDelegate {

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

java.util.List<?> oldO = (java.util.List<?>)oldInstance;

java.util.List<?> newO = (java.util.List<?>)newInstance;

int oldSize = oldO.size();

int newSize = (newO == null) ? 0 : newO.size();

if (oldSize < newSize) {

invokeStatement(oldInstance, "clear", new Object[]{}, out);

newSize = 0;

}

for (int i = 0; i < newSize; i++) {

Object index = new Integer(i);

Expression oldGetExp = new Expression(oldInstance, "get", new Object[]{index});

Expression newGetExp = new Expression(newInstance, "get", new Object[]{index});

try {

Object oldValue = oldGetExp.getValue();

Object newValue = newGetExp.getValue();

out.writeExpression(oldGetExp);

if (!Objects.equals(newValue, out.get(oldValue))) {

invokeStatement(oldInstance, "set", new Object[]{index, oldValue}, out);

}

}

catch (Exception e) {

out.getExceptionListener().exceptionThrown(e);

}

}

for (int i = newSize; i < oldSize; i++) {

invokeStatement(oldInstance, "add", new Object[]{oldO.get(i)}, out);

}

}

}

static class java_util_Map_PersistenceDelegate extends DefaultPersistenceDelegate {

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

// System.out.println("Initializing: " + newInstance);

java.util.Map<?,?> oldMap = (java.util.Map)oldInstance;

java.util.Map<?,?> newMap = (java.util.Map)newInstance;

// Remove the new elements.

// Do this first otherwise we undo the adding work.

if (newMap != null) {

for (Object newKey : newMap.keySet().toArray()) {

// PENDING: This "key" is not in the right environment.

if (!oldMap.containsKey(newKey)) {

invokeStatement(oldInstance, "remove", new Object[]{newKey}, out);

}

}

}

// Add the new elements.

for ( Object oldKey : oldMap.keySet() ) {

Expression oldGetExp = new Expression(oldInstance, "get", new Object[]{oldKey});

// Pending: should use newKey.

Expression newGetExp = new Expression(newInstance, "get", new Object[]{oldKey});

try {

Object oldValue = oldGetExp.getValue();

Object newValue = newGetExp.getValue();

out.writeExpression(oldGetExp);

if (!Objects.equals(newValue, out.get(oldValue))) {

invokeStatement(oldInstance, "put", new Object[]{oldKey, oldValue}, out);

} else if ((newValue == null) && !newMap.containsKey(oldKey)) {

// put oldValue(=null?) if oldKey is absent in newMap

invokeStatement(oldInstance, "put", new Object[]{oldKey, oldValue}, out);

}

}

catch (Exception e) {

out.getExceptionListener().exceptionThrown(e);

}

}

}

}

static final class java_util_AbstractCollection_PersistenceDelegate extends java_util_Collection_PersistenceDelegate {}

static final class java_util_AbstractList_PersistenceDelegate extends java_util_List_PersistenceDelegate {}

static final class java_util_AbstractMap_PersistenceDelegate extends java_util_Map_PersistenceDelegate {}

static final class java_util_Hashtable_PersistenceDelegate extends java_util_Map_PersistenceDelegate {}

static final class java_beans_beancontext_BeanContextSupport_PersistenceDelegate extends java_util_Collection_PersistenceDelegate {}

static final class java_awt_Insets_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

Insets insets = (Insets) oldInstance;

Object[] args = new Object[] {

insets.top,

insets.left,

insets.bottom,

insets.right,

};

return new Expression(insets, insets.getClass(), "new", args);

}

}

static final class java_awt_Font_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

Font font = (Font) oldInstance;

int count = 0;

String family = null;

int style = Font.PLAIN;

int size = 12;

Map<TextAttribute, ?> basic = font.getAttributes();

Map<TextAttribute, Object> clone = new HashMap<>(basic.size());

for (TextAttribute key : basic.keySet()) {

Object value = basic.get(key);

if (value != null) {

clone.put(key, value);

}

if (key == TextAttribute.FAMILY) {

if (value instanceof String) {

count++;

family = (String) value;

}

}

else if (key == TextAttribute.WEIGHT) {

if (TextAttribute.WEIGHT_REGULAR.equals(value)) {

count++;

} else if (TextAttribute.WEIGHT_BOLD.equals(value)) {

count++;

style |= Font.BOLD;

}

}

else if (key == TextAttribute.POSTURE) {

if (TextAttribute.POSTURE_REGULAR.equals(value)) {

count++;

} else if (TextAttribute.POSTURE_OBLIQUE.equals(value)) {

count++;

style |= Font.ITALIC;

}

} else if (key == TextAttribute.SIZE) {

if (value instanceof Number) {

Number number = (Number) value;

size = number.intValue();

if (size == number.floatValue()) {

count++;

}

}

}

}

Class<?> type = font.getClass();

if (count == clone.size()) {

return new Expression(font, type, "new", new Object[]{family, style, size});

}

if (type == Font.class) {

return new Expression(font, type, "getFont", new Object[]{clone});

}

return new Expression(font, type, "new", new Object[]{Font.getFont(clone)});

}

}

static final class java_awt_AWTKeyStroke_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

AWTKeyStroke key = (AWTKeyStroke) oldInstance;

char ch = key.getKeyChar();

int code = key.getKeyCode();

int mask = key.getModifiers();

boolean onKeyRelease = key.isOnKeyRelease();

Object[] args = null;

if (ch == KeyEvent.CHAR_UNDEFINED) {

args = !onKeyRelease

? new Object[]{code, mask}

: new Object[]{code, mask, onKeyRelease};

} else if (code == KeyEvent.VK_UNDEFINED) {

if (!onKeyRelease) {

args = (mask == 0)

? new Object[]{ch}

: new Object[]{ch, mask};

} else if (mask == 0) {

args = new Object[]{ch, onKeyRelease};

}

}

if (args == null) {

throw new IllegalStateException("Unsupported KeyStroke: " + key);

}

Class<?> type = key.getClass();

String name = type.getName();

// get short name of the class

int index = name.lastIndexOf('.') + 1;

if (index > 0) {

name = name.substring(index);

}

return new Expression( key, type, "get" + name, args );

}

}

static class StaticFieldsPersistenceDelegate extends PersistenceDelegate {

protected void installFields(Encoder out, Class<?> cls) {

if (Modifier.isPublic(cls.getModifiers()) && isPackageAccessible(cls)) {

Field fields[] = cls.getFields();

for(int i = 0; i < fields.length; i++) {

Field field = fields[i];

// Don't install primitives, their identity will not be preserved

// by wrapping.

if (Object.class.isAssignableFrom(field.getType())) {

out.writeExpression(new Expression(field, "get", new Object[]{null}));

}

}

}

}

protected Expression instantiate(Object oldInstance, Encoder out) {

throw new RuntimeException("Unrecognized instance: " + oldInstance);

}

public void writeObject(Object oldInstance, Encoder out) {

if (out.getAttribute(this) == null) {

out.setAttribute(this, Boolean.TRUE);

installFields(out, oldInstance.getClass());

}

super.writeObject(oldInstance, out);

}

}

static final class java_awt_SystemColor_PersistenceDelegate extends StaticFieldsPersistenceDelegate {}

static final class java_awt_font_TextAttribute_PersistenceDelegate extends StaticFieldsPersistenceDelegate {}

static final class java_awt_MenuShortcut_PersistenceDelegate extends PersistenceDelegate {

protected boolean mutatesTo(Object oldInstance, Object newInstance) {

return oldInstance.equals(newInstance);

}

protected Expression instantiate(Object oldInstance, Encoder out) {

java.awt.MenuShortcut m = (java.awt.MenuShortcut)oldInstance;

return new Expression(oldInstance, m.getClass(), "new",

new Object[]{new Integer(m.getKey()), Boolean.valueOf(m.usesShiftModifier())});

}

}

static final class java_awt_Component_PersistenceDelegate extends DefaultPersistenceDelegate {

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

super.initialize(type, oldInstance, newInstance, out);

java.awt.Component c = (java.awt.Component)oldInstance;

java.awt.Component c2 = (java.awt.Component)newInstance;

// The "background", "foreground" and "font" properties.

// The foreground and font properties of Windows change from

// null to defined values after the Windows are made visible -

// special case them for now.

if (!(oldInstance instanceof java.awt.Window)) {

Object oldBackground = c.isBackgroundSet() ? c.getBackground() : null;

Object newBackground = c2.isBackgroundSet() ? c2.getBackground() : null;

if (!Objects.equals(oldBackground, newBackground)) {

invokeStatement(oldInstance, "setBackground", new Object[] { oldBackground }, out);

}

Object oldForeground = c.isForegroundSet() ? c.getForeground() : null;

Object newForeground = c2.isForegroundSet() ? c2.getForeground() : null;

if (!Objects.equals(oldForeground, newForeground)) {

invokeStatement(oldInstance, "setForeground", new Object[] { oldForeground }, out);

}

Object oldFont = c.isFontSet() ? c.getFont() : null;

Object newFont = c2.isFontSet() ? c2.getFont() : null;

if (!Objects.equals(oldFont, newFont)) {

invokeStatement(oldInstance, "setFont", new Object[] { oldFont }, out);

}

}

// Bounds

java.awt.Container p = c.getParent();

if (p == null || p.getLayout() == null) {

// Use the most concise construct.

boolean locationCorrect = c.getLocation().equals(c2.getLocation());

boolean sizeCorrect = c.getSize().equals(c2.getSize());

if (!locationCorrect && !sizeCorrect) {

invokeStatement(oldInstance, "setBounds", new Object[]{c.getBounds()}, out);

}

else if (!locationCorrect) {

invokeStatement(oldInstance, "setLocation", new Object[]{c.getLocation()}, out);

}

else if (!sizeCorrect) {

invokeStatement(oldInstance, "setSize", new Object[]{c.getSize()}, out);

}

}

}

}

static final class java_awt_Container_PersistenceDelegate extends DefaultPersistenceDelegate {

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

super.initialize(type, oldInstance, newInstance, out);

// Ignore the children of a JScrollPane.

// Pending(milne) find a better way to do this.

if (oldInstance instanceof javax.swing.JScrollPane) {

return;

}

java.awt.Container oldC = (java.awt.Container)oldInstance;

java.awt.Component[] oldChildren = oldC.getComponents();

java.awt.Container newC = (java.awt.Container)newInstance;

java.awt.Component[] newChildren = (newC == null) ? new java.awt.Component[0] : newC.getComponents();

BorderLayout layout = ( oldC.getLayout() instanceof BorderLayout )

? ( BorderLayout )oldC.getLayout()

: null;

JLayeredPane oldLayeredPane = (oldInstance instanceof JLayeredPane)

? (JLayeredPane) oldInstance

: null;

// Pending. Assume all the new children are unaltered.

for(int i = newChildren.length; i < oldChildren.length; i++) {

Object[] args = ( layout != null )

? new Object[] {oldChildren[i], layout.getConstraints( oldChildren[i] )}

: (oldLayeredPane != null)

? new Object[] {oldChildren[i], oldLayeredPane.getLayer(oldChildren[i]), Integer.valueOf(-1)}

: new Object[] {oldChildren[i]};

invokeStatement(oldInstance, "add", args, out);

}

}

}

static final class java_awt_Choice_PersistenceDelegate extends DefaultPersistenceDelegate {

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

super.initialize(type, oldInstance, newInstance, out);

java.awt.Choice m = (java.awt.Choice)oldInstance;

java.awt.Choice n = (java.awt.Choice)newInstance;

for (int i = n.getItemCount(); i < m.getItemCount(); i++) {

invokeStatement(oldInstance, "add", new Object[]{m.getItem(i)}, out);

}

}

}

static final class java_awt_Menu_PersistenceDelegate extends DefaultPersistenceDelegate {

protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

super.initialize(type, oldInstance, newInstance, out);

java.awt.Menu m = (java.awt.Menu)oldInstance;

java.awt.Menu n = (java.awt.Menu)newInstance;

for (int i = n.getItemCount(); i < m.getItemCount(); i++) {

invokeStatement(oldInstance, "add", new Object[]{m.getItem(i)}, out);