/*******************************************************************************
 * Copyright (c) 2005, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
/*


 */
package org.eclipse.jem.internal.beaninfo.adapters;

import java.io.*;
import java.util.*;

import org.eclipse.emf.common.util.EMap;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.*;
import org.eclipse.emf.ecore.change.*;
import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.jem.internal.beaninfo.*;
import org.eclipse.jem.internal.beaninfo.common.*;
import org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin;
import org.eclipse.jem.internal.beaninfo.core.Utilities;
import org.eclipse.jem.internal.beaninfo.impl.*;
import org.eclipse.jem.internal.proxy.core.*;
import org.eclipse.jem.java.*;

/**
 * This is a utility class for handling the BeanInfo decorators with respect to the overrides (explicit settings) vs. introspected/reflected (implicit
 * settings) It handles the transmission of data from the VM for introspection.
 * @since 1.1.0
 */
public class BeanInfoDecoratorUtility {

	/**
	 * Clear out the implicit settings for FeatureDecorator.
	 * 
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	public static void clear(FeatureDecorator decor) {
		long implicitSettings = decor.getImplicitlySetBits();
		// For each setting, see if it was implicitly set, and if it was, then unset it.
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT) != 0)
			decor.unsetDisplayName();
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT) != 0)
			decor.unsetShortDescription();
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getFeatureDecorator_Category());
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT) != 0)
			decor.unsetExpert();
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT) != 0)
			decor.unsetHidden();
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT) != 0)
			decor.unsetPreferred();
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT) != 0) {
			for (Iterator itr = decor.getAttributes().listIterator(); itr.hasNext();) {
				FeatureAttributeMapEntryImpl entry = (FeatureAttributeMapEntryImpl)itr.next();
				if (entry.getTypedValue().isImplicitValue()) {
					itr.remove();
				}
			}
		}	
		decor
				.setImplicitlySetBits(implicitSettings
						& ~(FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT | FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT
								| FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT | FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT
								| FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT | FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT | FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT));
	}

	/**
	 * Clear out the implicit settings for BeanDecorator
	 * 
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	public static void clear(BeanDecorator decor) {
		clear((FeatureDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		// For each setting, see if it was implicitly set, and if it was, then unset it.
		if ((implicitSettings & BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_CustomizerClass());
		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT) != 0)
			decor.unsetMergeSuperProperties();
		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT) != 0)
			decor.unsetMergeSuperMethods();
		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT) != 0)
			decor.unsetMergeSuperEvents();
		if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedPropertyNames()))
			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedPropertyNames()); // Just clear them. This is our attribute. It should
																							   // not be set overrides.
		if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedMethodNames()))
			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedMethodNames()); // Just clear them. This is our attribute. It should
																							   // not be set overrides.
		if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedEventNames()))
			decor.eUnset(BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedEventNames()); // Just clear them. This is our attribute. It should not
																							// be set overrides.

		decor.setImplicitlySetBits(implicitSettings
				& ~(BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT | BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT
						| BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT | BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT));
	}

	/**
	 * Clear out the implicit settings of the PropertyDecorator.
	 * 
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	public static void clear(PropertyDecorator decor) {
		clear((FeatureDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		// For each setting, see if it was implicitly set, and if it was, then unset it.
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getPropertyDecorator_PropertyEditorClass());
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT) != 0)
			decor.unsetReadMethod();
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT) != 0)
			decor.unsetWriteMethod();
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_FIELD_IMPLICIT) != 0) {
			decor.unsetField();		
			decor.eUnset(BeaninfoPackage.eINSTANCE.getPropertyDecorator_Field());
		}
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT) != 0)
			decor.unsetBound();
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT) != 0)
			decor.unsetConstrained();
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT) != 0)
			decor.unsetDesignTime();
		decor.setImplicitlySetBits(implicitSettings
				& ~(PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT | PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT
						| PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT | PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT
						| PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT | PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT));
	}

	/**
	 * Clear out the implicit settings of the IndexedPropertyDecorator.
	 * 
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	public static void clear(IndexedPropertyDecorator decor) {
		clear((PropertyDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		// For each setting, see if it was implicitly set, and if it was, then unset it.
		if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT) != 0)
			decor.unsetIndexedReadMethod();
		if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT) != 0)
			decor.unsetIndexedWriteMethod();
		decor.setImplicitlySetBits(implicitSettings
				& ~(IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT | IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT));
	}

	/**
	 * Clear the method decorator of any implicit settings.
	 * 
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	public static void clear(MethodDecorator decor) {
		clear((FeatureDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		// For each setting, see if it was implicitly set, and if it was, then unset it.
		if ((implicitSettings & (MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT | MethodDecoratorImpl.METHOD_PARAMETERS_DEFAULT)) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getMethodDecorator_SerParmDesc());
		decor.setImplicitlySetBits(implicitSettings
				& ~(MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT | MethodDecoratorImpl.METHOD_PARAMETERS_DEFAULT));
	}

	/**
	 * Clear the event set decorator of any implicit settings.
	 * 
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	public static void clear(EventSetDecorator decor) {
		clear((FeatureDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		// For each setting, see if it was implicitly set, and if it was, then unset it.
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod());
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_EventAdapterClass());
		if ((implicitSettings & (EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT | EventSetDecoratorImpl.EVENT_LISTENERMETHODS_DEFAULT)) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_SerListMthd());
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod());
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT) != 0)
			decor.unsetInDefaultEventSet();
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT) != 0)
			decor.unsetUnicast();
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT) != 0)
			decor.eUnset(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType());

		decor.setImplicitlySetBits(implicitSettings
				& ~(EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT | EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT
						| EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT | EventSetDecoratorImpl.EVENT_LISTENERMETHODS_DEFAULT
						| EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT | EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT
						| EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT | EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT));

	}

	public static void introspect(IBeanProxy modelBeaninfoProxy, IntrospectCallBack callback) {
		ProxyIntrospectCallBack cb = new ProxyIntrospectCallBack(callback);
		modelBeaninfoProxy.getProxyFactoryRegistry().getCallbackRegistry().registerCallback(modelBeaninfoProxy, cb);
		try {
			BeaninfoProxyConstants.getConstants(modelBeaninfoProxy.getProxyFactoryRegistry()).getSendBeanInfoProxy()
					.invokeCatchThrowableExceptions(modelBeaninfoProxy);
		} finally {
			modelBeaninfoProxy.getProxyFactoryRegistry().getCallbackRegistry().deregisterCallback(modelBeaninfoProxy);
		}

	}

	/**
	 * This call back is for each requested type of record. It allows the callee to process this record.
	 * 
	 * @since 1.1.0
	 */
	public interface IntrospectCallBack {

		/**
		 * Process the BeanDecoratorRecord. The callee can decide what needs to be done with this record. It would return the BeandDecorator that needs
		 * to have the record applied to. If it returns <code>null</code> then the record will be ignored.
		 * <p>
		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
		 * have them on a separate thread.
		 * 
		 * @param record
		 * @return BeanDecorator to be applied to, or <code>null</code> if record is to be ignored.
		 * 
		 * @since 1.1.0
		 */
		public BeanDecorator process(BeanRecord record);

		/**
		 * Process the PropertyRecord. The callee can decide what needs to be done with this record. It would return the PropertyDecorator that needs
		 * to have the record applied to. If it returns <code>null</code> then the record will be ignored.
		 * <p>
		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
		 * have them on a separate thread.
		 * 
		 * @param record
		 * @return PropertyDecorator to be applied to, or <code>null</code> if record is to be ignored.
		 * 
		 * @since 1.1.0
		 */
		public PropertyDecorator process(PropertyRecord record);

		/**
		 * Process the IndexedPropertyRecord. The callee can decide what needs to be done with this record. It would return the
		 * IndexedPropertyDecorator that needs to have the record applied to. If it returns <code>null</code> then the record will be ignored.
		 * 
		 * <p>
		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
		 * have them on a separate thread.
		 * 
		 * @param record
		 * @return PropertyDecorator to be applied to, or <code>null</code> if record is to be ignored. There is a possibility that a straight
		 *         PropertyDecorator can be returned instead (in the case that it was explictly set by overrides as a property but beaninfo thinks it
		 *         is an index. This can be handled by it will only set the PropertyRecord part. It normally should be an IndexedPropertyDecorator
		 *         returned.
		 * 
		 * @since 1.1.0
		 */
		public PropertyDecorator process(IndexedPropertyRecord record);

		/**
		 * Process the MethodRecord. The callee can decide what needs to be done with this record. It would return the MethodDecorator that needs to
		 * have the record applied to. If it returns <code>null</code> then the record will be ignored.
		 * 
		 * <p>
		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
		 * have them on a separate thread.
		 * 
		 * @param record
		 * @return MethodDecorator to be applied to, or <code>null</code> if record is to be ignored.
		 * 
		 * @since 1.1.0
		 */

		public MethodDecorator process(MethodRecord record);

		/**
		 * Process the EventRecord. The callee can decide what needs to be done with this record. It would return the EventSetDecorator that needs to
		 * have the record applied to. If it returns <code>null</code> then the record will be ignored.
		 * 
		 * <p>
		 * Note: This will be called on a separate thread from that which initiated the request. Therefor be careful with any locks because you may
		 * have them on a separate thread.
		 * 
		 * @param record
		 * @return EventSetDecorator to be applied to, or <code>null</code> if record is to be ignored.
		 * 
		 * @since 1.1.0
		 */

		public EventSetDecorator process(EventSetRecord record);
	}

	private static class ProxyIntrospectCallBack implements ICallback {

		private IntrospectCallBack introspectCallback;

		public ProxyIntrospectCallBack(IntrospectCallBack introspectCallback) {
			this.introspectCallback = introspectCallback;
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, org.eclipse.jem.internal.proxy.core.IBeanProxy)
		 */
		public Object calledBack(int msgID, IBeanProxy parm) {
			return null; // Not used.
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, java.lang.Object)
		 */
		public Object calledBack(int msgID, Object parm) {
			return null; // Not used.
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBack(int, java.lang.Object[])
		 */
		public Object calledBack(int msgID, Object[] parms) {
			return null; // Not used.
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jem.internal.proxy.core.ICallback#calledBackStream(int, java.io.InputStream)
		 */
		public void calledBackStream(int msgID, InputStream is) {
			ObjectInputStream ois;
			try {
				ois = new ObjectInputStream(is);
				while (true) {
					int cmdId = ois.readInt();
					switch (cmdId) {
						case IBeanInfoIntrospectionConstants.BEAN_DECORATOR_SENT:
							try {
								BeanRecord br = (BeanRecord) ois.readObject();
								BeanDecorator bd = introspectCallback.process(br);
								if (bd != null) {
									clear(bd);
									applyRecord(bd, br);
								}
							} catch (IOException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassCastException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassNotFoundException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							}
							break;
						case IBeanInfoIntrospectionConstants.PROPERTY_DECORATORS_SENT:
							try {
								int propCount = ois.readInt();
								for (int i = 0; i < propCount; i++) {
									PropertyRecord pr = (PropertyRecord) ois.readObject();
									if (pr.getClass() == IndexedPropertyRecord.class) {
										IndexedPropertyRecord ipr = (IndexedPropertyRecord) pr;
										PropertyDecorator ip = introspectCallback.process(ipr);
										if (ip != null) {
											// It actually could be either a property decorator or an indexed property decorator. This could happen
											// because the overrides file has explicitly declared a PropertyDecorator, so we can't change it to an
											// Indexed.
											// So in that case we can only fill the property part.
											if (ip.eClass().getClassifierID() == BeaninfoPackage.INDEXED_PROPERTY_DECORATOR)
												applyRecord((IndexedPropertyDecorator) ip, ipr);
											else
												applyRecord(ip, pr); // It was forced to be a property and not indexed.
										}
									} else {
										PropertyDecorator p = introspectCallback.process(pr);
										if (p != null) {
											// It actually could be either a property decorator or an indexed property decorator. This could happen
											// because the overrides file has explicitly declared an IndexedPropertyDecorator, so we can't change it
											// to an
											// Property.
											// So in that case we can only fill the property part.
											applyRecord(p, pr);
										}
									}
								}
							} catch (IOException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassNotFoundException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassCastException e) {
								// In case we got bad data sent in.
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} finally {
							}
							break;

						case IBeanInfoIntrospectionConstants.METHOD_DECORATORS_SENT:
							try {
								int opCount = ois.readInt();
								for (int i = 0; i < opCount; i++) {
									MethodRecord mr = (MethodRecord) ois.readObject();
									MethodDecorator m = introspectCallback.process(mr);
									if (m != null)
										applyRecord(m, mr);
								}
							} catch (IOException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassNotFoundException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassCastException e) {
								// In case we got bad data sent in.
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							}
							break;

						case IBeanInfoIntrospectionConstants.EVENT_DECORATORS_SENT:
							try {
								int opCount = ois.readInt();
								for (int i = 0; i < opCount; i++) {
									EventSetRecord evr = (EventSetRecord) ois.readObject();
									EventSetDecorator e = introspectCallback.process(evr);
									if (e != null)
										applyRecord(e, evr);
								}
							} catch (IOException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassNotFoundException e) {
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							} catch (ClassCastException e) {
								// In case we got bad data sent in.
								BeaninfoPlugin.getPlugin().getLogger().log(e);
							}
							break;

						case IBeanInfoIntrospectionConstants.DONE:
							return;	// Good. This is a good stop.
							
						default:
							return;	// This is invalid. Should of gotton something.
					}
				}
			} catch (IOException e) {
				BeaninfoPlugin.getPlugin().getLogger().log(e);
			}
		}
	}

	/**
	 * Apply the feature record to the feature decorator. This is protected because this is an abstract and should never be called by itself.
	 * <p>
	 * 
	 * @param decor
	 * @param record
	 * 
	 * @since 1.1.0
	 */
	protected static void applyRecord(FeatureDecorator decor, FeatureRecord record) {
		// Subclasses will clear their decor, which will automatically clear the FeatureDecor part for us.
		long implicitSettings = decor.getImplicitlySetBits();
		if (record.displayName != null && !decor.isSetDisplayName()) {
			decor.setDisplayName(record.displayName);
			implicitSettings |= FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT;
		}
		if (record.shortDescription != null && !decor.isSetShortDescription()) {
			decor.setShortDescription(record.shortDescription);
			implicitSettings |= FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT;
		}
		if (record.category != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getFeatureDecorator_Category())) {
			decor.setCategory(record.category);
			implicitSettings |= FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT;
		}
		if (!decor.isSetExpert()) {
			if (decor.isExpert() != record.expert)
				decor.setExpert(record.expert); // Don't want to explicitly set it if it is equal to default (this will put less out to the cache file
												// and so will parse and apply faster).
			implicitSettings |= FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT;
		}
		if (!decor.isSetHidden()) {
			if (decor.isHidden() != record.hidden)
				decor.setHidden(record.hidden);
			implicitSettings |= FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT;
		}
		if (!decor.isSetPreferred()) {
			if (decor.isPreferred() != record.preferred)
				decor.setPreferred(record.preferred);
			implicitSettings |= FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT;
		}
		if (record.attributeNames != null && !decor.isAttributesExplicitEmpty()) {
			// This is a list, so we need to read an fill in.
			EMap attrs = decor.getAttributes();
			for (int i = 0; i < record.attributeNames.length; i++) {
				FeatureAttributeMapEntryImpl entry = (FeatureAttributeMapEntryImpl) ((BeaninfoFactoryImpl) BeaninfoFactory.eINSTANCE)
						.createFeatureAttributeMapEntry();
				entry.setTypedKey(record.attributeNames[i]);
				FeatureAttributeValue fv = record.attributeValues[i];
				fv.setImplicitValue(true);
				entry.setTypedValue(fv);
				attrs.add(entry);
			}
			implicitSettings |= FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT;
		}

		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Apply the bean record to the bean decorator.
	 * 
	 * @param decor
	 * @param record
	 * 
	 * @since 1.1.0
	 */
	public static void applyRecord(BeanDecorator decor, BeanRecord record) {
		applyRecord((FeatureDecorator) decor, record);

		long implicitSettings = decor.getImplicitlySetBits();
		if (record.customizerClassName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getBeanDecorator_CustomizerClass())) {
			decor.setCustomizerClass(createJavaClassProxy(record.customizerClassName));
			implicitSettings |= BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT;
		}
		if (!decor.isSetMergeSuperProperties()) {
			if (decor.isMergeSuperProperties() != record.mergeInheritedProperties)
				decor.setMergeSuperProperties(record.mergeInheritedProperties);
			implicitSettings |= BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT;
		}
		if (!decor.isSetMergeSuperMethods()) {
			if (decor.isMergeSuperMethods() != record.mergeInheritedOperations)
				decor.setMergeSuperMethods(record.mergeInheritedOperations);
			implicitSettings |= BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT;
		}
		if (!decor.isSetMergeSuperEvents()) {
			if (decor.isMergeSuperEvents() != record.mergeInheritedEvents)
				decor.setMergeSuperEvents(record.mergeInheritedEvents);
			implicitSettings |= BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT;
		}
		if (record.notInheritedPropertyNames != null) {
			// This is always applied. This isn't a client override so we can just slam it.
			decor.getNotInheritedPropertyNames().addAll(Arrays.asList(record.notInheritedPropertyNames));
		}
		if (record.notInheritedOperationNames != null) {
			// This is always applied. This isn't a client override so we can just slam it.
			decor.getNotInheritedMethodNames().addAll(Arrays.asList(record.notInheritedOperationNames));
		}
		if (record.notInheritedEventNames != null) {
			// This is always applied. This isn't a client override so we can just slam it.
			decor.getNotInheritedEventNames().addAll(Arrays.asList(record.notInheritedEventNames));
		}

		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Apply the PropertyRecord to the PropertyDecorator.
	 * 
	 * @param decor
	 * @param record
	 * 
	 * @since 1.1.0
	 */
	public static void applyRecord(PropertyDecorator decor, PropertyRecord record) {
		applyRecord((FeatureDecorator) decor, record);

		applyOnly(decor, record);
	}

	/*
	 * Apply only to property decorator part. Allows IndexedProperty to apply just the Property part and not do duplicate work
	 */
	private static void applyOnly(PropertyDecorator decor, PropertyRecord record) {
		long implicitSettings = decor.getImplicitlySetBits();
		if (record.propertyEditorClassName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getPropertyDecorator_PropertyEditorClass())) {
			decor.setPropertyEditorClass(createJavaClassProxy(record.propertyEditorClassName));
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT;
		}
		if (record.readMethod != null && !decor.isSetReadMethod()) {
			decor.setReadMethod(createJavaMethodProxy(record.readMethod));
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT;
		}
		if (record.writeMethod != null && !decor.isSetWriteMethod()) {
			decor.setWriteMethod(createJavaMethodProxy(record.writeMethod));
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT;
		}
		if (record.field != null && !decor.isSetField()) {
			decor.setField(createJavaFieldProxy(record.field));
			if (decor.isFieldReadOnly() != record.field.readOnly)
				decor.setFieldReadOnly(record.field.readOnly);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_FIELD_IMPLICIT;
		}		
		if (!decor.isSetBound()) {
			if (decor.isBound() != record.bound)
				decor.setBound(record.bound);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT;
		}
		if (!decor.isSetConstrained()) {
			if (decor.isConstrained() != record.constrained)
				decor.setConstrained(record.constrained);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT;
		}
		if (record.designTime != null && !decor.isSetDesignTime()) {
			// Design time is slightly different than the other booleans because
			// explicitly set to true/false is important versus not explicitly set at all (which is false).
			decor.setDesignTime(record.designTime.booleanValue());
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT;
		}

		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.

	}

	public static void applyRecord(IndexedPropertyDecorator decor, IndexedPropertyRecord record) {
		applyRecord((FeatureDecorator) decor, record);
		applyOnly(decor, record);

		long implicitSettings = decor.getImplicitlySetBits();
		if (record.indexedReadMethod != null && !decor.isSetIndexedReadMethod()) {
			decor.setIndexedReadMethod(createJavaMethodProxy(record.indexedReadMethod));
			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT;
		}
		if (record.indexedWriteMethod != null && !decor.isSetIndexedWriteMethod()) {
			decor.setIndexedWriteMethod(createJavaMethodProxy(record.indexedWriteMethod));
			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT;
		}
		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Apply the method record to the method decorator.
	 * 
	 * @param decor
	 * @param record
	 * 
	 * @since 1.1.0
	 */
	public static void applyRecord(MethodDecorator decor, MethodRecord record) {
		applyRecord((FeatureDecorator) decor, record);

		long implicitSettings = decor.getImplicitlySetBits();
		if (record.parameters != null && !decor.isParmsExplicitEmpty()
				&& !decor.eIsSet(BeaninfoPackage.eINSTANCE.getMethodDecorator_ParameterDescriptors())) {
			// This is a list, so we need to read an fill in.
			List parms = decor.getSerParmDesc(); // So as not to have it implicitly fill it in, which it would if we called getParameterDescriptors.
			for (int i = 0; i < record.parameters.length; i++) {
				ParameterDecorator parm = BeaninfoFactory.eINSTANCE.createParameterDecorator();
				applyRecord(parm, record.parameters[i]);
				parms.add(parm);
			}
			implicitSettings |= MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT;
			implicitSettings &= ~MethodDecoratorImpl.METHOD_PARAMETERS_DEFAULT; // Should of already been cleared, but be safe.
		}

		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	public static void applyRecord(ParameterDecorator decor, ParameterRecord record) {
		applyRecord((FeatureDecorator) decor, record);

		long implicitSettings = decor.getImplicitlySetBits();
		if (record.name != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getParameterDecorator_Name())) {
			decor.setName(record.name);
			implicitSettings |= ParameterDecoratorImpl.PARAMETER_NAME_IMPLICIT;
		}
		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Apply the event set record to the event set decorator.
	 * 
	 * @param decor
	 * @param record
	 * 
	 * @since 1.1.0
	 */
	public static void applyRecord(EventSetDecorator decor, EventSetRecord record) {
		applyRecord((FeatureDecorator) decor, record);

		long implicitSettings = decor.getImplicitlySetBits();
		if (record.addListenerMethod != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod())) {
			decor.setAddListenerMethod(createJavaMethodProxy(record.addListenerMethod));
			implicitSettings |= EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT;
		}
		if (record.eventAdapterClassName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_EventAdapterClass())) {
			decor.setEventAdapterClass(createJavaClassProxy(record.eventAdapterClassName));
			implicitSettings |= EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT;
		}
		if (record.listenerMethodDescriptors != null && !decor.isListenerMethodsExplicitEmpty()
				&& !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerMethods())) {
			List methods = decor.getSerListMthd(); // So as not to have it implicitly fill it in, which it would if we called getListenerMethods.
			for (int i = 0; i < record.listenerMethodDescriptors.length; i++) {
				BeaninfoFactory bfact = BeaninfoFactory.eINSTANCE;
				MethodRecord mr = record.listenerMethodDescriptors[i];
				Method method = createJavaMethodProxy(mr.methodForDescriptor);
				// We need a method proxy, and a method decorator.
				MethodProxy mproxy = bfact.createMethodProxy();
				mproxy.setMethod(method);
				mproxy.setName(mr.name);
				MethodDecorator md = bfact.createMethodDecorator();
				applyRecord(md, mr);
				mproxy.getEAnnotations().add(md);
				methods.add(mproxy);
			}
			implicitSettings |= EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT;
			implicitSettings &= ~EventSetDecoratorImpl.EVENT_LISTENERMETHODS_DEFAULT; // Should of already been cleared, but be safe.
		}
		if (record.listenerTypeName != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType())) {
			decor.setListenerType(createJavaClassProxy(record.listenerTypeName));
			implicitSettings |= EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT;
		}
		if (record.removeListenerMethod != null && !decor.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod())) {
			decor.setRemoveListenerMethod(createJavaMethodProxy(record.removeListenerMethod));
			implicitSettings |= EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT;
		}
		if (!decor.isSetInDefaultEventSet()) {
			if (record.inDefaultEventSet != decor.isInDefaultEventSet())
				decor.setInDefaultEventSet(record.inDefaultEventSet);
			implicitSettings |= EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT;
		}
		if (!decor.isSetUnicast()) {
			if (record.unicast != decor.isUnicast())
				decor.setUnicast(record.unicast);
			implicitSettings |= EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT;
		}

		decor.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Create a java class proxy for the given name. By being a proxy we don't need to actually have the resource set. Nor do we need to fluff one up
	 * until someone actually asks for it.
	 * <p>
	 * The jniName must refer to a JavaClass or errors could occur later on.
	 * 
	 * @param jniName
	 *            classname in JNI format.
	 * @return JavaClass proxy or <code>null</code> if not a java class (it may be a type).
	 * 
	 * @since 1.1.0
	 */
	public static JavaClass createJavaClassProxy(String jniName) {
		JavaHelpers jh = createJavaTypeProxy(jniName);
		return jh instanceof JavaClass ? (JavaClass) jh : null;
	}

	/**
	 * Create a JavaHelpers proxy for the given name. By being a proxy we don't need to actually have the resource set. Nor do we need to fluff one up
	 * until someone actually asks for it.
	 * 
	 * @param jniName
	 *            typename in JNI format.
	 * @return JavaHelper proxy.
	 * 
	 * @since 1.1.0
	 */
	public static JavaHelpers createJavaTypeProxy(String jniName) {
		String formalName = MapJNITypes.getFormalTypeName(jniName);

		URI uri = Utilities.getJavaClassURI(formalName);
		JavaHelpers jh = null;
		if (MapJNITypes.isFormalTypePrimitive(formalName))
			jh = JavaRefFactory.eINSTANCE.createJavaDataType();
		else
			jh = JavaRefFactory.eINSTANCE.createJavaClass();
		((InternalEObject) jh).eSetProxyURI(uri);
		return jh;
	}

	public static Method createJavaMethodProxy(ReflectMethodRecord method) {
		String[] parmTypes = method.parameterTypeNames != null ? new String[method.parameterTypeNames.length] : null;
		if (parmTypes != null)
			for (int i = 0; i < method.parameterTypeNames.length; i++) {
				parmTypes[i] = MapJNITypes.getFormalTypeName(method.parameterTypeNames[i]);
			}
		URI uri = Utilities.getMethodURI(MapJNITypes.getFormalTypeName(method.className), method.methodName, parmTypes);
		Method methodEMF = JavaRefFactory.eINSTANCE.createMethod();
		((InternalEObject) methodEMF).eSetProxyURI(uri);
		return methodEMF;
	}
	
	public static Field createJavaFieldProxy(ReflectFieldRecord field) {
		URI uri = Utilities.getFieldURI(MapJNITypes.getFormalTypeName(field.className), field.fieldName);
		Field fieldEMF = JavaRefFactory.eINSTANCE.createField();
		((InternalEObject) fieldEMF).eSetProxyURI(uri);
		return fieldEMF;
	}	

	/**
	 * Set the properties on the PropertyDecorator. These come from reflection. Since this is a private interface between BeaninfoClassAdapter and
	 * this class, not all possible settings need to be mentioned. Only the ones that can be set by reflection. It is assumed that clear has already
	 * been done so that there are no old implicit settings. It will check if properties are set already before setting so that don't wipe out
	 * explicit settings.
	 * 
	 * @param prop
	 * @param bound
	 * @param constrained
	 * @param getter
	 * @param setter
	 * 
	 * @since 1.1.0
	 */
	public static void setProperties(PropertyDecorator prop, boolean bound, boolean constrained, Method getter, Method setter) {
		long implicitSettings = prop.getImplicitlySetBits();
		if (getter != null && !prop.isSetReadMethod()) {
			prop.setReadMethod(getter);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT;
		}
		if (setter != null && !prop.isSetWriteMethod()) {
			prop.setWriteMethod(setter);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT;
		}
		if (!prop.isSetBound()) {
			if (prop.isBound() != bound)
				prop.setBound(bound);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT;
		}
		if (!prop.isSetConstrained()) {
			if (prop.isConstrained() != constrained)
				prop.setConstrained(constrained);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT;
		}
		prop.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Set the properties on the IndexedPropertyDecorator. These come from reflection. It is only the indexed portion. The base property portion
	 * should have already been set. Since this is a private interface between BeaninfoClassAdapter and this class, not all possible settings need to
	 * be mentioned. Only the ones that can be set by reflection. It is assumed that clear has already been done so that there are no old implicit
	 * settings. It will check if properties are set already before setting so that don't wipe out explicit settings.
	 * 
	 * @param prop
	 * @param indexedGetter
	 * @param indexedSetter
	 * 
	 * @since 1.1.0
	 */
	public static void setProperties(IndexedPropertyDecorator prop, Method indexedGetter, Method indexedSetter) {
		long implicitSettings = prop.getImplicitlySetBits();
		if (indexedGetter != null && !prop.isSetIndexedReadMethod()) {
			prop.setIndexedReadMethod(indexedGetter);
			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT;
		}
		if (indexedSetter != null && !prop.isSetIndexedWriteMethod()) {
			prop.setIndexedWriteMethod(indexedSetter);
			implicitSettings |= IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT;
		}
		prop.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Set the properties on the EventSetDecorator. These come from reflection. Since this is a private interface between BeaninfoClassAdapter and
	 * this class, not all possible settings need to be mentioned. Only the ones that can be set by reflection. It is assumed that clear has already
	 * been done so that there are no old implicit settings. It will check if properties are set already before setting so that don't wipe out
	 * explicit settings.
	 * 
	 * @param event
	 * @param bound
	 * @param constrained
	 * @param getter
	 * @param setter
	 * 
	 * @since 1.1.0
	 */
	public static void setProperties(EventSetDecorator event, Method addListenerMethod, Method removeListenerMethod, boolean unicast,
			JavaClass listenerType) {
		long implicitSettings = event.getImplicitlySetBits();
		if (addListenerMethod != null && !event.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod())) {
			event.setAddListenerMethod(addListenerMethod);
			implicitSettings |= EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT;
		}
		if (removeListenerMethod != null && !event.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod())) {
			event.setRemoveListenerMethod(removeListenerMethod);
			implicitSettings |= EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT;
		}
		if (!event.isSetUnicast()) {
			if (event.isUnicast() != unicast)
				event.setUnicast(unicast);
			implicitSettings |= PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT;
		}
		if (listenerType != null && !event.eIsSet(BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType())) {
			event.setListenerType(listenerType);
			implicitSettings |= EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT;
		}

		event.setImplicitlySetBits(implicitSettings); // Now save was implicitly set.
	}

	/**
	 * Build the appropriate change record for the bean decorator. Either it is an add of a new bean decorator or it is the setting of the implicit
	 * settings on an non-implicit bean decorator.
	 * @param cd
	 * @param bd
	 * 
	 * @since 1.1.0
	 */
	public static void buildChange(ChangeDescription cd, BeanDecorator bd) {
		// Only do anything if merge introspection. If no merge introspection, then there is no change needed.
		if (bd.isMergeIntrospection()) {
			if (bd.getImplicitDecoratorFlag() != ImplicitItem.NOT_IMPLICIT_LITERAL) {
				// It is implicit, so do an add to end, new value.
				doAddToEnd(cd, getFeatureChangeList(cd, bd.getEModelElement()), EcorePackage.eINSTANCE.getEModelElement_EAnnotations(), bd, true);
			} else {
				// Just do sets on implicit changed ones
				buildNonImplicitChange(cd, getFeatureChangeList(cd, bd), bd);
			}
		}

	}

	/**
	 * Build the appropriate change record for the property decorator. Either it is an add of a new property decorator or it is the setting of the implicit
	 * settings on an non-implicit property decorator. The same is true of the feature that it decorates. It may be new or it may be an existing one.
	 * @param cd
	 * @param pd
	 * 
	 * @since 1.1.0
	 */
	public static void buildChange(ChangeDescription cd, PropertyDecorator pd) {
		// Only do changes if merge introspection. If not merging, then there are no changes.
		if (pd.isMergeIntrospection()) {
			boolean indexed = pd.eClass().getClassifierID() == BeaninfoPackage.INDEXED_PROPERTY_DECORATOR;
			EStructuralFeature feature = (EStructuralFeature) pd.getEModelElement();
			switch (pd.getImplicitDecoratorFlag().getValue()) {
				case ImplicitItem.IMPLICIT_DECORATOR:
					// The decorator is implicit, so clone it, and apply to feature, and then do the standard property applies to the feature.
					List fcs = getFeatureChangeList(cd, feature);
					doAddToEnd(cd, fcs, pd.eContainingFeature(), pd, true);
					buildNonImplicitChange(cd, fcs, feature, indexed);
					break;
				case ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE:
					// The decorator AND feature are implicit. Just clone them and add to the class.
					doAddToEnd(cd, getFeatureChangeList(cd, feature.eContainer()), feature.eContainingFeature(), feature, true);
					break;
				case ImplicitItem.NOT_IMPLICIT:
					// Neither the feature nor the decorator are implicit. So need to do applies against them.
					buildNonImplicitChange(cd, getFeatureChangeList(cd, pd), pd, indexed);
					buildNonImplicitChange(cd, getFeatureChangeList(cd, feature), feature, indexed);
					break;
			}
		}
	}
	
	/**
	 * Build the appropriate change record for the event set decorator. Either it is an add of a new event set decorator or it is the setting of the implicit
	 * settings on an non-implicit event set decorator. The same is true of the feature that it decorates. It may be new or it may be an existing one.
	 * @param cd
	 * @param ed
	 * 
	 * @since 1.1.0
	 */
	public static void buildChange(ChangeDescription cd, EventSetDecorator ed) {
		// Only build changes if merge introspection. If not merge then there are no changes.
		if (ed.isMergeIntrospection()) {
			JavaEvent event = (JavaEvent) ed.getEModelElement();
			switch (ed.getImplicitDecoratorFlag().getValue()) {
				case ImplicitItem.IMPLICIT_DECORATOR:
					// The decorator is implicit, so clone it, and apply to feature, and then do the standard property applies to the feature.
					List fcs = getFeatureChangeList(cd, event);
					doAddToEnd(cd, fcs, ed.eContainingFeature(), ed, true);
					buildNonImplicitChange(cd, fcs, event);
					break;
				case ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE:
					// The decorator AND feature are implicit. Just clone them and add to the class.
					doAddToEnd(cd, getFeatureChangeList(cd, event.eContainer()), event.eContainingFeature(), event, true);
					break;
				case ImplicitItem.NOT_IMPLICIT:
					// Neither the feature nor the decorator are implicit. So need to do applies against them.
					buildNonImplicitChange(cd, getFeatureChangeList(cd, ed), ed);
					buildNonImplicitChange(cd, getFeatureChangeList(cd, event), event);
					break;
			}
		}
	}

	/**
	 * Build the appropriate change record for the method decorator. Either it is an add of a new method decorator or it is the setting of the implicit
	 * settings on an non-implicit method decorator. The same is true of the operation that it decorates. It may be new or it may be an existing one.
	 * @param cd
	 * @param md
	 * 
	 * @since 1.1.0
	 */
	public static void buildChange(ChangeDescription cd, MethodDecorator md) {
		// Only do any builds if merge introspection. If not merge introspection then nothing should be changed.
		if (md.isMergeIntrospection()) {
			EOperation oper = (EOperation) md.getEModelElement();
			switch (md.getImplicitDecoratorFlag().getValue()) {
				case ImplicitItem.IMPLICIT_DECORATOR:
					// The decorator is implicit, so clone it, and apply to feature, and then do the standard property applies to the feature.
					List fcs = getFeatureChangeList(cd, oper);
					doAddToEnd(cd, fcs, md.eContainingFeature(), md, true);
					buildNonImplicitChange(cd, fcs, oper);
					break;
				case ImplicitItem.IMPLICIT_DECORATOR_AND_FEATURE:
					// The decorator AND feature are implicit. Just clone them and add to the class.
					doAddToEnd(cd, getFeatureChangeList(cd, oper.eContainer()), oper.eContainingFeature(), oper, true);
					break;
				case ImplicitItem.NOT_IMPLICIT:
					// Neither the feature nor the decorator are implicit. So need to do applies against them.
					buildNonImplicitChange(cd, getFeatureChangeList(cd, md), md);
					buildNonImplicitChange(cd, getFeatureChangeList(cd, oper), oper);
					break;
			}
		}
	}
	
	private final static Integer ZERO = new Integer(0);
	private final static Integer ONE = new Integer(1);
	private final static Integer MINUS_ONE = new Integer(-1);
	
	/**
	 * Build the non-implicit changes into the feature. This creates changes for the implicit settings
	 * that always occur for a property decorator.
	 *  
	 * @param cd
	 * @param fcs FeatureChanges list for the feature.
	 * @param feature
	 * @param indexed <code>true</code> if this is for an indexed feature.
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, EStructuralFeature feature, boolean indexed) {
		doSet(cd, fcs, EcorePackage.eINSTANCE.getENamedElement_Name(), feature.getName(), false);
		doSet(cd, fcs, EcorePackage.eINSTANCE.getEStructuralFeature_Transient(), Boolean.FALSE, false);
		doSet(cd, fcs, EcorePackage.eINSTANCE.getEStructuralFeature_Volatile(), Boolean.FALSE, false);
		doSet(cd, fcs, EcorePackage.eINSTANCE.getEStructuralFeature_Changeable(), Boolean.valueOf(feature.isChangeable()), false);
		doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_EType(), feature.getEType(), false);
		if (!indexed) {
			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_LowerBound(), ZERO, false);
			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_UpperBound(), ONE, false);
		} else {
			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_LowerBound(), ZERO, false);
			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_UpperBound(), MINUS_ONE, false);
			doSet(cd, fcs, EcorePackage.eINSTANCE.getETypedElement_Unique(), Boolean.TRUE, false);
		}
	}

	/**
	 * Build the non-implicit changes into the event. This creates changes for the implicit settings
	 * that always occur for an event set decorator.
	 *  
	 * @param cd
	 * @param fcs FeatureChanges list for the feature.
	 * @param event
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, JavaEvent event) {
		doSet(cd, fcs, EcorePackage.eINSTANCE.getENamedElement_Name(), event.getName(), false);
	}

	/**
	 * Build the non-implicit changes into the operation. This creates changes for the implicit settings
	 * that always occur for an method decorator.
	 *  
	 * @param cd
	 * @param fcs FeatureChanges list for the feature.
	 * @param oper
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, EOperation oper) {
		doSet(cd, fcs, EcorePackage.eINSTANCE.getENamedElement_Name(), oper.getName(), false);
		try {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getMethodProxy_Method(), ((MethodProxy) oper).getMethod(), false);	// This is a method that is not in this resource, so no clone.
		} catch (ClassCastException e) {
			// It will be a MethodProxy 99.9% of the time, so save by not doing instanceof.
		}
	}

	/**
	 * Build up the changes for a non-implicit feature decorator. This means create changes for implicit set features.
	 * 
	 * @param cd
	 * @param fcs
	 *            the FeatureChanges list for the given decorator.
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, FeatureDecorator decor) {
		long implicitSettings = decor.getImplicitlySetBits();
		if (implicitSettings != 0)
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_ImplicitlySetBits(), new Long(implicitSettings), false);
		
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_DISPLAYNAME_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_DisplayName(), decor.getDisplayName(), false);
		}
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_SHORTDESC_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_ShortDescription(), decor.getShortDescription(), false);
		}
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_CATEGORY_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Category(), decor.getCategory(), false);
		}
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_EXPERT_IMPLICIT) != 0 && decor.isSetExpert()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Expert(), Boolean.valueOf(decor.isExpert()), false);
		}
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_HIDDEN_IMPLICIT) != 0 && decor.isSetHidden()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Hidden(), Boolean.valueOf(decor.isHidden()), false);
		}
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_PREFERRED_IMPLICIT) != 0 && decor.isSetPreferred()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Preferred(), Boolean.valueOf(decor.isPreferred()), false);
		}
		if ((implicitSettings & FeatureDecoratorImpl.FEATURE_ATTRIBUTES_IMPLICIT) != 0) {
			for (Iterator itr = decor.getAttributes().listIterator(); itr.hasNext();) {
				FeatureAttributeMapEntryImpl entry = (FeatureAttributeMapEntryImpl)itr.next();
				if (entry.getTypedValue().isImplicitValue()) {
					doAddToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getFeatureDecorator_Attributes(), entry, true);
				}
			}
		}
	}

	/**
	 * Build up the changes for a non-implicit bean decorator. This means create changes for implicit set features.
	 * 
	 * @param cd
	 * @param fcs
	 *            the FeatureChanges list for the given decorator.
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, BeanDecorator decor) {
		buildNonImplicitChange(cd, fcs, (FeatureDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		if ((implicitSettings & BeanDecoratorImpl.BEAN_CUSTOMIZER_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_CustomizerClass(), decor.getCustomizerClass(), false); // Customizer class is
																															 // not in this resource,
																															 // so we don't clone it.
		}
		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_PROPERTIES_IMPLICIT) != 0 && decor.isSetMergeSuperProperties()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_MergeSuperProperties(), Boolean.valueOf(decor.isMergeSuperProperties()), false);
		}
		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_OPERATIONS_IMPLICIT) != 0 && decor.isSetMergeSuperMethods()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_MergeSuperMethods(), Boolean.valueOf(decor.isMergeSuperMethods()), false);
		}
		if ((implicitSettings & BeanDecoratorImpl.BEAN_MERGE_INHERITED_EVENTS_IMPLICIT) != 0 && decor.isSetMergeSuperEvents()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_MergeSuperEvents(), Boolean.valueOf(decor.isMergeSuperEvents()), false);
		}
		if (!decor.getNotInheritedPropertyNames().isEmpty()) {
			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedPropertyNames(), decor.getNotInheritedPropertyNames(), false);
		}
		if (!decor.getNotInheritedMethodNames().isEmpty()) {
			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedMethodNames(), decor.getNotInheritedMethodNames(), false);
		}
		if (!decor.getNotInheritedEventNames().isEmpty()) {
			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getBeanDecorator_NotInheritedEventNames(), decor.getNotInheritedEventNames(), false);
		}
	}

	/**
	 * Build up the changes for a non-implicit property decorator. This means create changes for implicit set features.
	 * 
	 * @param cd
	 * @param fcs
	 *            the FeatureChanges list for the given decorator.
	 * @param decor
	 * @param indexed <code>true</code> if this is an indexed property decorator.
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, PropertyDecorator decor, boolean indexed) {
		buildNonImplicitChange(cd, fcs, decor);
		long implicitSettings = decor.getImplicitlySetBits();
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_EDITOR_CLASS_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_PropertyEditorClass(), decor.getPropertyEditorClass(), false); // Property Editor class is
																															 // not in this resource,
																															 // so we don't clone it.
		}
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_READMETHOD_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_ReadMethod(), decor.getReadMethod(), false); 
		}
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_WRITEMETHOD_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_WriteMethod(), decor.getWriteMethod(), false); 
		}
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_FIELD_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_Field(), decor.getField(), false); 
			if (decor.eIsSet(BeaninfoPackage.eINSTANCE.getPropertyDecorator_FieldReadOnly()))
				doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_FieldReadOnly(), Boolean.valueOf(decor.isFieldReadOnly()), false);
		}		
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_BOUND_IMPLICIT) != 0 && decor.isSetBound()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_Bound(), Boolean.valueOf(decor.isBound()), false);
		}
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_CONSTRAINED_IMPLICIT) != 0 && decor.isSetConstrained()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_Constrained(), Boolean.valueOf(decor.isConstrained()), false);
		}
		if ((implicitSettings & PropertyDecoratorImpl.PROPERTY_DESIGNTIME_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getPropertyDecorator_DesignTime(), Boolean.valueOf(decor.isDesignTime()), false);
		}
		
		if (indexed) {
			IndexedPropertyDecorator ipd = (IndexedPropertyDecorator) decor;
			if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_READMETHOD_IMPLICIT) != 0) {
				doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getIndexedPropertyDecorator_IndexedReadMethod(), ipd.getIndexedReadMethod(), false); 
			}
			if ((implicitSettings & IndexedPropertyDecoratorImpl.INDEXED_WRITEMETHOD_IMPLICIT) != 0) {
				doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getIndexedPropertyDecorator_IndexedWriteMethod(), ipd.getIndexedWriteMethod(), false); 
			}
		}
	}
	
	/**
	 * Build up the changes for a non-implicit event set decorator. This means create changes for implicit set features.
	 * 
	 * @param cd
	 * @param fcs
	 *            the FeatureChanges list for the given decorator.
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, EventSetDecorator decor) {
		buildNonImplicitChange(cd, fcs, (FeatureDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADDLISTENERMETHOD_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_AddListenerMethod(), decor.getAddListenerMethod(), false); // listener method is
																															 // not in this resource,
																															 // so we don't clone it.
		}
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_ADAPTERCLASS_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_EventAdapterClass(), decor.getEventAdapterClass(), false);
		}
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_LISTENERMETHODS_IMPLICIT) != 0) {
			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_SerListMthd(), decor.getSerListMthd(), true);	// These need to be cloned because they are contained here.
		}
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_LISTENERTYPE_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_ListenerType(), decor.getListenerType(), false);
		}
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_REMOVELISTENERMETHOD_IMPLICIT) != 0) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_RemoveListenerMethod(), decor.getRemoveListenerMethod(), false);
		}
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_DEFAULTEVENTSET_IMPLICIT) != 0 && decor.isSetInDefaultEventSet()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_InDefaultEventSet(), Boolean.valueOf(decor.isInDefaultEventSet()), false);
		}
		if ((implicitSettings & EventSetDecoratorImpl.EVENT_UNICAST_IMPLICIT) != 0 && decor.isSetUnicast()) {
			doSet(cd, fcs, BeaninfoPackage.eINSTANCE.getEventSetDecorator_Unicast(), Boolean.valueOf(decor.isUnicast()), false);
		}
	}

	/**
	 * Build up the changes for a non-implicit method decorator. This means create changes for implicit set features.
	 * 
	 * @param cd
	 * @param fcs
	 *            the FeatureChanges list for the given decorator.
	 * @param decor
	 * 
	 * @since 1.1.0
	 */
	protected static void buildNonImplicitChange(ChangeDescription cd, List fcs, MethodDecorator decor) {
		buildNonImplicitChange(cd, fcs, (FeatureDecorator) decor);
		long implicitSettings = decor.getImplicitlySetBits();
		if ((implicitSettings & MethodDecoratorImpl.METHOD_PARAMETERS_IMPLICIT) != 0) {
			doAddAllToEnd(cd, fcs, BeaninfoPackage.eINSTANCE.getMethodDecorator_SerParmDesc(), decor.getSerParmDesc(), true); 
		}
	}


	/**
	 * Get the feature change list for an object. Create it one if necessary.
	 * 
	 * @param cd
	 * @param object
	 * @return feature change list.
	 * 
	 * @since 1.1.0
	 */
	protected static List getFeatureChangeList(ChangeDescription cd, EObject object) {
		List fcs = cd.getObjectChanges().get(object); // Get the feature changes if any.
		if (fcs == null) {
			Map.Entry entry = ChangeFactory.eINSTANCE.createEObjectToChangesMapEntry(object);
			cd.getObjectChanges().add(entry);
			fcs = (List) entry.getValue();
		}
		return fcs;
	}

	/**
	 * Return the FeatureChange record for a feature wrt/object. Create one if necessary. If it creates it, it will mark it as "set". All of our
	 * changes here are set kind of changes, not unset kind.
	 * 
	 * @param fcs
	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
	 * @param feature
	 * @return feature change
	 * 
	 * @since 1.1.0
	 */
	protected static FeatureChange getFeatureChange(List fcs, EStructuralFeature feature) {
		if (!fcs.isEmpty()) {
			for (int i = 0; i < fcs.size(); i++) {
				FeatureChange fc = (FeatureChange) fcs.get(i);
				if (fc.getFeature() == feature)
					return fc;
			}
		}

		// Either new object changes or no feature change found. Create one.
		FeatureChange fc = ChangeFactory.eINSTANCE.createFeatureChange(feature, null, true);
		fcs.add(fc);
		return fc;
	}

	/**
	 * Create a change for add to end of the given feature (must be isMany()). If newObject is true, then this means this is not a pointer to an
	 * existing object and so it must be cloned. It is assumed that there will be no further changes to this object because those will not be known
	 * about.
	 * 
	 * @param cd
	 * @param fcs
	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
	 * @param feature
	 *            the feature being added to.
	 * @param addedValue
	 *            the value being added.
	 * @param newValue
	 *            <code>true</code> if new object in the resource, a clone will be made. <code>false</code> if an existing object. Must be an
	 *            EObject for cloning. Best if not true for non-eobjects.
	 * @return the addedValue or the clone if it was cloned.
	 * 
	 * @since 1.1.0
	 */
	protected static Object doAddToEnd(ChangeDescription cd, List fcs, EStructuralFeature feature, Object addedValue, boolean newValue) {
		FeatureChange fc = getFeatureChange(fcs, feature);
		if (newValue) {
			try {
				addedValue = EcoreUtil.copy((EObject) addedValue);
				cd.getObjectsToAttach().add((EObject)addedValue);
			} catch (ClassCastException e) {
				// Normally should not occur, but if it does, it means we can't clone, so don't clone.
			}
		}
		List lcs = fc.getListChanges();
		// Find the one with add and -1, i.e. add to end. There should only be one.
		ListChange lc = null;
		for (int i = 0; i < lcs.size(); i++) {
			ListChange lca = (ListChange) lcs.get(i);
			if (lca.getKind() == ChangeKind.ADD_LITERAL && lca.getIndex() == -1) {
				lc = lca;
				break;
			}
		}
		if (lc == null) {
			lc = ChangeFactory.eINSTANCE.createListChange();
			lcs.add(lc);
		}

		lc.getValues().add(addedValue);
		return addedValue;
	}

	/**
	 * Create a change for add all to end of the given feature (must be isMany()). If newValue is true, then this means this is not a pointer to
	 * existing objects and so it must be cloned. It is assumed that there will be no further changes to this object because those will not be known
	 * about.
	 * 
	 * @param cd
	 * @param fcs
	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
	 * @param feature
	 *            the feature being added to.
	 * @param addedValues
	 *            the values being added.
	 * @param newValue
	 *            <code>true</code> if new objects in the resource, clones will be made. <code>false</code> if an existing object. Must be EObject
	 *            for cloning. Best if not true for non-eobjects.
	 * @return the addedValues or the clones if it was cloned.
	 * 
	 * @since 1.1.0
	 */
	protected static Object doAddAllToEnd(ChangeDescription cd, List fcs, EStructuralFeature feature, Collection addedValues, boolean newValue) {
		FeatureChange fc = getFeatureChange(fcs, feature);
		if (newValue) {
			try {
				addedValues = EcoreUtil.copyAll(addedValues);
				cd.getObjectsToAttach().addAll(addedValues);
			} catch (ClassCastException e) {
				// Normally should not occur, but if it does, it means we can't clone, so don't clone.
			}
		}
		List lcs = fc.getListChanges();
		// Find the one with add and -1, i.e. add to end. There should only be one.
		ListChange lc = null;
		for (int i = 0; i < lcs.size(); i++) {
			ListChange lca = (ListChange) lcs.get(i);
			if (lca.getKind() == ChangeKind.ADD_LITERAL && lca.getIndex() == -1) {
				lc = lca;
				break;
			}
		}
		if (lc == null) {
			lc = ChangeFactory.eINSTANCE.createListChange();
			lcs.add(lc);
		}

		lc.getValues().addAll(addedValues);
		return addedValues;
	}

	/**
	 * Create a change for set a given feature (must be !isMany()). If newValue is true, then this means this is not a pointer to an existing object
	 * and so it must be cloned. It is assumed that there will be no further changes to this object because those will not be known about.
	 * <p>
	 * Any further sets to this feature will result in the previous setting being lost.
	 * 
	 * @param cd
	 * @param fcs
	 *            feature change list from the ChangeDescripion.getObjectChanges for the given object.
	 * @param feature
	 *            the feature being set to.
	 * @param setValue
	 *            the value being set.
	 * @param newValue
	 *            <code>true</code> if new object in the resource, a clone will be made. <code>false</code> if an existing object. Must be an
	 *            EObject for cloning. Best if not true for non-eobjects.
	 * @return the setValue or the clone if it was cloned.
	 * 
	 * @since 1.1.0
	 */
	protected static Object doSet(ChangeDescription cd, List fcs, EStructuralFeature feature, Object setValue, boolean newValue) {

		FeatureChange fc = getFeatureChange(fcs, feature);
		if (newValue) {
			try {
				setValue = EcoreUtil.copy((EObject) setValue);
				cd.getObjectsToAttach().add((EObject)setValue);
			} catch (ClassCastException e) {
				// Normally should not occur, but if it does, it means we can't clone, so don't clone.
			}
		}

		if (setValue instanceof EObject)
			fc.setReferenceValue((EObject) setValue);
		else
			fc.setDataValue(EcoreUtil.convertToString((EDataType) feature.getEType(), setValue));
		return setValue;
	}
}