/*******************************************************************************
 * Copyright (c) 2008, 2011 Oracle. 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.jpa.eclipselink.core.internal.context.orm;

import java.util.List;
import java.util.ListIterator;
import java.util.Vector;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IType;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.iterables.CompositeIterable;
import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneIterable;
import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneListIterable;
import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
import org.eclipse.jpt.jpa.core.context.XmlContextNode;
import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkCustomConverter;
import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkObjectTypeConverter;
import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkStructConverter;
import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTypeConverter;
import org.eclipse.jpt.jpa.eclipselink.core.context.orm.OrmEclipseLinkConverterContainer;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.EclipseLinkOrmFactory;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlConverter;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlConvertersHolder;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlObjectTypeConverter;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlStructConverter;
import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlTypeConverter;
import org.eclipse.text.edits.ReplaceEdit;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;

public class OrmEclipseLinkConverterContainerImpl
	extends AbstractOrmXmlContextNode
	implements OrmEclipseLinkConverterContainer
{
	private final XmlConvertersHolder xmlConvertersHolder;

	protected final Vector<OrmEclipseLinkCustomConverter> customConverters = new Vector<OrmEclipseLinkCustomConverter>();
	protected final CustomConverterContainerAdapter customConverterContainerAdapter;

	protected final Vector<OrmEclipseLinkObjectTypeConverter> objectTypeConverters = new Vector<OrmEclipseLinkObjectTypeConverter>();
	protected final ObjectTypeConverterContainerAdapter objectTypeConverterContainerAdapter;

	protected final Vector<OrmEclipseLinkStructConverter> structConverters = new Vector<OrmEclipseLinkStructConverter>();
	protected final StructConverterContainerAdapter structConverterContainerAdapter;

	protected final Vector<OrmEclipseLinkTypeConverter> typeConverters = new Vector<OrmEclipseLinkTypeConverter>();
	protected final TypeConverterContainerAdapter typeConverterContainerAdapter;


	public OrmEclipseLinkConverterContainerImpl(XmlContextNode parent, XmlConvertersHolder xmlConvertersHolder) {
		super(parent);
		this.xmlConvertersHolder = xmlConvertersHolder;

		this.customConverterContainerAdapter = this.buildCustomConverterContainerAdapter();
		this.objectTypeConverterContainerAdapter = this.buildObjectTypeConverterContainerAdapter();
		this.structConverterContainerAdapter = this.buildStructConverterContainerAdapter();
		this.typeConverterContainerAdapter = this.buildTypeConverterContainerAdapter();

		this.initializeCustomConverters();
		this.initializeObjectTypeConverters();
		this.initializeStructConverters();
		this.initializeTypeConverters();
	}


	// ********** synchronize/update **********

	@Override
	public void synchronizeWithResourceModel() {
		super.synchronizeWithResourceModel();
		this.syncCustomConverters();
		this.syncObjectTypeConverters();
		this.syncStructConverters();
		this.syncTypeConverters();
	}

	@Override
	public void update() {
		super.update();
		this.updateNodes(this.getCustomConverters());
		this.updateNodes(this.getObjectTypeConverters());
		this.updateNodes(this.getStructConverters());
		this.updateNodes(this.getTypeConverters());
	}


	// ********** custom converters **********

	@SuppressWarnings("unchecked")
	public ListIterator<OrmEclipseLinkCustomConverter> customConverters() {
		return this.getCustomConverters().iterator();
	}

	public ListIterable<OrmEclipseLinkCustomConverter> getCustomConverters() {
		return new LiveCloneListIterable<OrmEclipseLinkCustomConverter>(this.customConverters);
	}

	public int customConvertersSize() {
		return this.customConverters.size();
	}

	public OrmEclipseLinkCustomConverter addCustomConverter() {
		return this.addCustomConverter(this.customConverters.size());
	}

	public OrmEclipseLinkCustomConverter addCustomConverter(int index) {
		XmlConverter xmlConverter = this.buildXmlCustomConverter();
		OrmEclipseLinkCustomConverter converter = this.addCustomConverter_(index, xmlConverter);
		this.xmlConvertersHolder.getConverters().add(index, xmlConverter);
		return converter;
	}

	protected XmlConverter buildXmlCustomConverter() {
		return EclipseLinkOrmFactory.eINSTANCE.createXmlConverter();
	}

	public void removeCustomConverter(EclipseLinkCustomConverter converter) {
		this.removeCustomConverter(this.customConverters.indexOf(converter));
	}

	public void removeCustomConverter(int index) {
		this.removeCustomConverter_(index);
		this.xmlConvertersHolder.getConverters().remove(index);
	}

	protected void removeCustomConverter_(int index) {
		this.removeItemFromList(index, this.customConverters, CUSTOM_CONVERTERS_LIST);
	}

	public void moveCustomConverter(int targetIndex, int sourceIndex) {
		this.moveItemInList(targetIndex, sourceIndex, this.customConverters, CUSTOM_CONVERTERS_LIST);
		this.xmlConvertersHolder.getConverters().move(targetIndex, sourceIndex);
	}

	protected void initializeCustomConverters() {
		for (XmlConverter xmlConverter : this.getXmlCustomConverters()) {
			this.customConverters.add(this.buildCustomConverter(xmlConverter));
		}
	}

	protected OrmEclipseLinkCustomConverter buildCustomConverter(XmlConverter xmlConverter) {
		return new OrmEclipseLinkCustomConverter(this, xmlConverter);
	}

	protected void syncCustomConverters() {
		ContextContainerTools.synchronizeWithResourceModel(this.customConverterContainerAdapter);
	}

	protected Iterable<XmlConverter> getXmlCustomConverters() {
		// clone to reduce chance of concurrency problems
		return new LiveCloneIterable<XmlConverter>(this.xmlConvertersHolder.getConverters());
	}

	protected void moveCustomConverter_(int index, OrmEclipseLinkCustomConverter converter) {
		this.moveItemInList(index, converter, this.customConverters, CUSTOM_CONVERTERS_LIST);
	}

	protected OrmEclipseLinkCustomConverter addCustomConverter_(int index, XmlConverter xmlConverter) {
		OrmEclipseLinkCustomConverter converter = this.buildCustomConverter(xmlConverter);
		this.addItemToList(index, converter, this.customConverters, CUSTOM_CONVERTERS_LIST);
		return converter;
	}

	protected void removeCustomConverter_(OrmEclipseLinkCustomConverter converter) {
		this.removeCustomConverter_(this.customConverters.indexOf(converter));
	}

	protected CustomConverterContainerAdapter buildCustomConverterContainerAdapter() {
		return new CustomConverterContainerAdapter();
	}

	/**
	 * custom converter container adapter
	 */
	protected class CustomConverterContainerAdapter
		implements ContextContainerTools.Adapter<OrmEclipseLinkCustomConverter, XmlConverter>
	{
		public Iterable<OrmEclipseLinkCustomConverter> getContextElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getCustomConverters();
		}
		public Iterable<XmlConverter> getResourceElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getXmlCustomConverters();
		}
		public XmlConverter getResourceElement(OrmEclipseLinkCustomConverter contextElement) {
			return contextElement.getXmlConverter();
		}
		public void moveContextElement(int index, OrmEclipseLinkCustomConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.moveCustomConverter_(index, element);
		}
		public void addContextElement(int index, XmlConverter resourceElement) {
			OrmEclipseLinkConverterContainerImpl.this.addCustomConverter_(index, resourceElement);
		}
		public void removeContextElement(OrmEclipseLinkCustomConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.removeCustomConverter_(element);
		}
	}


	// ********** object type converters **********

	@SuppressWarnings("unchecked")
	public ListIterator<OrmEclipseLinkObjectTypeConverter> objectTypeConverters() {
		return this.getObjectTypeConverters().iterator();
	}

	public ListIterable<OrmEclipseLinkObjectTypeConverter> getObjectTypeConverters() {
		return new LiveCloneListIterable<OrmEclipseLinkObjectTypeConverter>(this.objectTypeConverters);
	}

	public int objectTypeConvertersSize() {
		return this.objectTypeConverters.size();
	}

	public OrmEclipseLinkObjectTypeConverter addObjectTypeConverter() {
		return this.addObjectTypeConverter(this.objectTypeConverters.size());
	}

	public OrmEclipseLinkObjectTypeConverter addObjectTypeConverter(int index) {
		XmlObjectTypeConverter xmlConverter = this.buildXmlObjectTypeConverter();
		OrmEclipseLinkObjectTypeConverter converter = this.addObjectTypeConverter_(index, xmlConverter);
		this.xmlConvertersHolder.getObjectTypeConverters().add(index, xmlConverter);
		return converter;
	}

	protected XmlObjectTypeConverter buildXmlObjectTypeConverter() {
		return EclipseLinkOrmFactory.eINSTANCE.createXmlObjectTypeConverter();
	}

	public void removeObjectTypeConverter(EclipseLinkObjectTypeConverter converter) {
		this.removeObjectTypeConverter(this.objectTypeConverters.indexOf(converter));
	}

	public void removeObjectTypeConverter(int index) {
		this.removeObjectTypeConverter_(index);
		this.xmlConvertersHolder.getObjectTypeConverters().remove(index);
	}

	protected void removeObjectTypeConverter_(int index) {
		this.removeItemFromList(index, this.objectTypeConverters, OBJECT_TYPE_CONVERTERS_LIST);
	}

	public void moveObjectTypeConverter(int targetIndex, int sourceIndex) {
		this.moveItemInList(targetIndex, sourceIndex, this.objectTypeConverters, OBJECT_TYPE_CONVERTERS_LIST);
		this.xmlConvertersHolder.getObjectTypeConverters().move(targetIndex, sourceIndex);
	}

	protected void initializeObjectTypeConverters() {
		for (XmlObjectTypeConverter xmlConverter : this.getXmlObjectTypeConverters()) {
			this.objectTypeConverters.add(this.buildObjectTypeConverter(xmlConverter));
		}
	}

	protected OrmEclipseLinkObjectTypeConverter buildObjectTypeConverter(XmlObjectTypeConverter xmlConverter) {
		return new OrmEclipseLinkObjectTypeConverter(this, xmlConverter);
	}

	protected void syncObjectTypeConverters() {
		ContextContainerTools.synchronizeWithResourceModel(this.objectTypeConverterContainerAdapter);
	}

	protected Iterable<XmlObjectTypeConverter> getXmlObjectTypeConverters() {
		// clone to reduce chance of concurrency problems
		return new LiveCloneIterable<XmlObjectTypeConverter>(this.xmlConvertersHolder.getObjectTypeConverters());
	}

	protected void moveObjectTypeConverter_(int index, OrmEclipseLinkObjectTypeConverter converter) {
		this.moveItemInList(index, converter, this.objectTypeConverters, OBJECT_TYPE_CONVERTERS_LIST);
	}

	protected OrmEclipseLinkObjectTypeConverter addObjectTypeConverter_(int index, XmlObjectTypeConverter xmlConverter) {
		OrmEclipseLinkObjectTypeConverter converter = this.buildObjectTypeConverter(xmlConverter);
		this.addItemToList(index, converter, this.objectTypeConverters, OBJECT_TYPE_CONVERTERS_LIST);
		return converter;
	}

	protected void removeObjectTypeConverter_(OrmEclipseLinkObjectTypeConverter converter) {
		this.removeObjectTypeConverter_(this.objectTypeConverters.indexOf(converter));
	}

	protected ObjectTypeConverterContainerAdapter buildObjectTypeConverterContainerAdapter() {
		return new ObjectTypeConverterContainerAdapter();
	}

	/**
	 * object type converter container adapter
	 */
	protected class ObjectTypeConverterContainerAdapter
		implements ContextContainerTools.Adapter<OrmEclipseLinkObjectTypeConverter, XmlObjectTypeConverter>
	{
		public Iterable<OrmEclipseLinkObjectTypeConverter> getContextElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getObjectTypeConverters();
		}
		public Iterable<XmlObjectTypeConverter> getResourceElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getXmlObjectTypeConverters();
		}
		public XmlObjectTypeConverter getResourceElement(OrmEclipseLinkObjectTypeConverter contextElement) {
			return contextElement.getXmlConverter();
		}
		public void moveContextElement(int index, OrmEclipseLinkObjectTypeConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.moveObjectTypeConverter_(index, element);
		}
		public void addContextElement(int index, XmlObjectTypeConverter resourceElement) {
			OrmEclipseLinkConverterContainerImpl.this.addObjectTypeConverter_(index, resourceElement);
		}
		public void removeContextElement(OrmEclipseLinkObjectTypeConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.removeObjectTypeConverter_(element);
		}
	}


	// ********** struct converters **********

	@SuppressWarnings("unchecked")
	public ListIterator<OrmEclipseLinkStructConverter> structConverters() {
		return this.getStructConverters().iterator();
	}

	public ListIterable<OrmEclipseLinkStructConverter> getStructConverters() {
		return new LiveCloneListIterable<OrmEclipseLinkStructConverter>(this.structConverters);
	}

	public int structConvertersSize() {
		return this.structConverters.size();
	}

	public OrmEclipseLinkStructConverter addStructConverter() {
		return this.addStructConverter(this.structConverters.size());
	}

	public OrmEclipseLinkStructConverter addStructConverter(int index) {
		XmlStructConverter xmlConverter = this.buildXmlStructConverter();
		OrmEclipseLinkStructConverter converter = this.addStructConverter_(index, xmlConverter);
		this.xmlConvertersHolder.getStructConverters().add(index, xmlConverter);
		return converter;
	}

	protected XmlStructConverter buildXmlStructConverter() {
		return EclipseLinkOrmFactory.eINSTANCE.createXmlStructConverter();
	}

	public void removeStructConverter(EclipseLinkStructConverter converter) {
		this.removeStructConverter(this.structConverters.indexOf(converter));
	}

	public void removeStructConverter(int index) {
		this.removeStructConverter_(index);
		this.xmlConvertersHolder.getStructConverters().remove(index);
	}

	protected void removeStructConverter_(int index) {
		this.removeItemFromList(index, this.structConverters, STRUCT_CONVERTERS_LIST);
	}

	public void moveStructConverter(int targetIndex, int sourceIndex) {
		this.moveItemInList(targetIndex, sourceIndex, this.structConverters, STRUCT_CONVERTERS_LIST);
		this.xmlConvertersHolder.getStructConverters().move(targetIndex, sourceIndex);
	}

	protected void initializeStructConverters() {
		for (XmlStructConverter xmlConverter : this.getXmlStructConverters()) {
			this.structConverters.add(this.buildStructConverter(xmlConverter));
		}
	}

	protected OrmEclipseLinkStructConverter buildStructConverter(XmlStructConverter xmlConverter) {
		return new OrmEclipseLinkStructConverter(this, xmlConverter);
	}

	protected void syncStructConverters() {
		ContextContainerTools.synchronizeWithResourceModel(this.structConverterContainerAdapter);
	}

	protected Iterable<XmlStructConverter> getXmlStructConverters() {
		// clone to reduce chance of concurrency problems
		return new LiveCloneIterable<XmlStructConverter>(this.xmlConvertersHolder.getStructConverters());
	}

	protected void moveStructConverter_(int index, OrmEclipseLinkStructConverter converter) {
		this.moveItemInList(index, converter, this.structConverters, STRUCT_CONVERTERS_LIST);
	}

	protected OrmEclipseLinkStructConverter addStructConverter_(int index, XmlStructConverter xmlConverter) {
		OrmEclipseLinkStructConverter converter = this.buildStructConverter(xmlConverter);
		this.addItemToList(index, converter, this.structConverters, STRUCT_CONVERTERS_LIST);
		return converter;
	}

	protected void removeStructConverter_(OrmEclipseLinkStructConverter converter) {
		this.removeStructConverter_(this.structConverters.indexOf(converter));
	}

	protected StructConverterContainerAdapter buildStructConverterContainerAdapter() {
		return new StructConverterContainerAdapter();
	}

	/**
	 * struct converter container adapter
	 */
	protected class StructConverterContainerAdapter
		implements ContextContainerTools.Adapter<OrmEclipseLinkStructConverter, XmlStructConverter>
	{
		public Iterable<OrmEclipseLinkStructConverter> getContextElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getStructConverters();
		}
		public Iterable<XmlStructConverter> getResourceElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getXmlStructConverters();
		}
		public XmlStructConverter getResourceElement(OrmEclipseLinkStructConverter contextElement) {
			return contextElement.getXmlConverter();
		}
		public void moveContextElement(int index, OrmEclipseLinkStructConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.moveStructConverter_(index, element);
		}
		public void addContextElement(int index, XmlStructConverter resourceElement) {
			OrmEclipseLinkConverterContainerImpl.this.addStructConverter_(index, resourceElement);
		}
		public void removeContextElement(OrmEclipseLinkStructConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.removeStructConverter_(element);
		}
	}


	// ********** type converters **********

	@SuppressWarnings("unchecked")
	public ListIterator<OrmEclipseLinkTypeConverter> typeConverters() {
		return this.getTypeConverters().iterator();
	}

	public ListIterable<OrmEclipseLinkTypeConverter> getTypeConverters() {
		return new LiveCloneListIterable<OrmEclipseLinkTypeConverter>(this.typeConverters);
	}

	public int typeConvertersSize() {
		return this.typeConverters.size();
	}

	public OrmEclipseLinkTypeConverter addTypeConverter() {
		return this.addTypeConverter(this.typeConverters.size());
	}

	public OrmEclipseLinkTypeConverter addTypeConverter(int index) {
		XmlTypeConverter xmlConverter = this.buildXmlTypeConverter();
		OrmEclipseLinkTypeConverter converter = this.addTypeConverter_(index, xmlConverter);
		this.xmlConvertersHolder.getTypeConverters().add(index, xmlConverter);
		return converter;
	}

	protected XmlTypeConverter buildXmlTypeConverter() {
		return EclipseLinkOrmFactory.eINSTANCE.createXmlTypeConverter();
	}

	public void removeTypeConverter(EclipseLinkTypeConverter converter) {
		this.removeTypeConverter(this.typeConverters.indexOf(converter));
	}

	public void removeTypeConverter(int index) {
		this.removeTypeConverter_(index);
		this.xmlConvertersHolder.getTypeConverters().remove(index);
	}

	protected void removeTypeConverter_(int index) {
		this.removeItemFromList(index, this.typeConverters, TYPE_CONVERTERS_LIST);
	}

	public void moveTypeConverter(int targetIndex, int sourceIndex) {
		this.moveItemInList(targetIndex, sourceIndex, this.typeConverters, TYPE_CONVERTERS_LIST);
		this.xmlConvertersHolder.getTypeConverters().move(targetIndex, sourceIndex);
	}

	protected void initializeTypeConverters() {
		for (XmlTypeConverter xmlConverter : this.getXmlTypeConverters()) {
			this.typeConverters.add(this.buildTypeConverter(xmlConverter));
		}
	}

	protected OrmEclipseLinkTypeConverter buildTypeConverter(XmlTypeConverter xmlConverter) {
		return new OrmEclipseLinkTypeConverter(this, xmlConverter);
	}

	protected void syncTypeConverters() {
		ContextContainerTools.synchronizeWithResourceModel(this.typeConverterContainerAdapter);
	}

	protected Iterable<XmlTypeConverter> getXmlTypeConverters() {
		// clone to reduce chance of concurrency problems
		return new LiveCloneIterable<XmlTypeConverter>(this.xmlConvertersHolder.getTypeConverters());
	}

	protected void moveTypeConverter_(int index, OrmEclipseLinkTypeConverter converter) {
		this.moveItemInList(index, converter, this.typeConverters, TYPE_CONVERTERS_LIST);
	}

	protected OrmEclipseLinkTypeConverter addTypeConverter_(int index, XmlTypeConverter xmlConverter) {
		OrmEclipseLinkTypeConverter converter = this.buildTypeConverter(xmlConverter);
		this.addItemToList(index, converter, this.typeConverters, TYPE_CONVERTERS_LIST);
		return converter;
	}

	protected void removeTypeConverter_(OrmEclipseLinkTypeConverter converter) {
		this.removeTypeConverter_(this.typeConverters.indexOf(converter));
	}

	protected TypeConverterContainerAdapter buildTypeConverterContainerAdapter() {
		return new TypeConverterContainerAdapter();
	}

	/**
	 * type converter container adapter
	 */
	protected class TypeConverterContainerAdapter
		implements ContextContainerTools.Adapter<OrmEclipseLinkTypeConverter, XmlTypeConverter>
	{
		public Iterable<OrmEclipseLinkTypeConverter> getContextElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getTypeConverters();
		}
		public Iterable<XmlTypeConverter> getResourceElements() {
			return OrmEclipseLinkConverterContainerImpl.this.getXmlTypeConverters();
		}
		public XmlTypeConverter getResourceElement(OrmEclipseLinkTypeConverter contextElement) {
			return contextElement.getXmlConverter();
		}
		public void moveContextElement(int index, OrmEclipseLinkTypeConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.moveTypeConverter_(index, element);
		}
		public void addContextElement(int index, XmlTypeConverter resourceElement) {
			OrmEclipseLinkConverterContainerImpl.this.addTypeConverter_(index, resourceElement);
		}
		public void removeContextElement(OrmEclipseLinkTypeConverter element) {
			OrmEclipseLinkConverterContainerImpl.this.removeTypeConverter_(element);
		}
	}


	// ********** refactoring **********

	@SuppressWarnings("unchecked")
	public Iterable<ReplaceEdit> createRenameTypeEdits(IType originalType, String newName) {
		return new CompositeIterable<ReplaceEdit>(
			this.createRenameObjectTypeConverterEdits(originalType, newName),
			this.createRenameTypeConverterEdits(originalType, newName),
			this.createRenameStructConverterEdits(originalType, newName),
			this.createRenameCustomConverterEdits(originalType, newName));
	}

	protected Iterable<ReplaceEdit> createRenameObjectTypeConverterEdits(final IType originalType, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkObjectTypeConverter, Iterable<ReplaceEdit>>(getObjectTypeConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkObjectTypeConverter objectTypeConverter) {
					return objectTypeConverter.createRenameTypeEdits(originalType, newName);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createRenameTypeConverterEdits(final IType originalType, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkTypeConverter, Iterable<ReplaceEdit>>(getTypeConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkTypeConverter typeConverter) {
					return typeConverter.createRenameTypeEdits(originalType, newName);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createRenameStructConverterEdits(final IType originalType, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkStructConverter, Iterable<ReplaceEdit>>(getStructConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkStructConverter structConverter) {
					return structConverter.createRenameTypeEdits(originalType, newName);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createRenameCustomConverterEdits(final IType originalType, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkCustomConverter, Iterable<ReplaceEdit>>(getCustomConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkCustomConverter customConverter) {
					return customConverter.createRenameTypeEdits(originalType, newName);
				}
			}
		);
	}

	@SuppressWarnings("unchecked")
	public Iterable<ReplaceEdit> createMoveTypeEdits(IType originalType, IPackageFragment newPackage) {
		return new CompositeIterable<ReplaceEdit>(
			this.createMoveObjectTypeConverterEdits(originalType, newPackage),
			this.createMoveTypeConverterEdits(originalType, newPackage),
			this.createMoveStructConverterEdits(originalType, newPackage),
			this.createMoveCustomConverterEdits(originalType, newPackage));
	}

	protected Iterable<ReplaceEdit> createMoveObjectTypeConverterEdits(final IType originalType, final IPackageFragment newPackage) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkObjectTypeConverter, Iterable<ReplaceEdit>>(getObjectTypeConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkObjectTypeConverter objectTypeConverter) {
					return objectTypeConverter.createMoveTypeEdits(originalType, newPackage);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createMoveTypeConverterEdits(final IType originalType, final IPackageFragment newPackage) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkTypeConverter, Iterable<ReplaceEdit>>(getTypeConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkTypeConverter typeConverter) {
					return typeConverter.createMoveTypeEdits(originalType, newPackage);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createMoveStructConverterEdits(final IType originalType, final IPackageFragment newPackage) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkStructConverter, Iterable<ReplaceEdit>>(getStructConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkStructConverter structConverter) {
					return structConverter.createMoveTypeEdits(originalType, newPackage);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createMoveCustomConverterEdits(final IType originalType, final IPackageFragment newPackage) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkCustomConverter, Iterable<ReplaceEdit>>(getCustomConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkCustomConverter customConverter) {
					return customConverter.createMoveTypeEdits(originalType, newPackage);
				}
			}
		);
	}


	@SuppressWarnings("unchecked")
	public Iterable<ReplaceEdit> createRenamePackageEdits(IPackageFragment originalPackage, String newName) {
		return new CompositeIterable<ReplaceEdit>(
			this.createObjectTypeConverterRenamePackageEdits(originalPackage, newName),
			this.createTypeConverterRenamePackageEdits(originalPackage, newName),
			this.createStructConverterRenamePackageEdits(originalPackage, newName),
			this.createCustomConverterRenamePackageEdits(originalPackage, newName));
	}

	protected Iterable<ReplaceEdit> createObjectTypeConverterRenamePackageEdits(final IPackageFragment originalPackage, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkObjectTypeConverter, Iterable<ReplaceEdit>>(getObjectTypeConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkObjectTypeConverter objectTypeConverter) {
					return objectTypeConverter.createRenamePackageEdits(originalPackage, newName);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createTypeConverterRenamePackageEdits(final IPackageFragment originalPackage, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkTypeConverter, Iterable<ReplaceEdit>>(getTypeConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkTypeConverter typeConverter) {
					return typeConverter.createRenamePackageEdits(originalPackage, newName);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createStructConverterRenamePackageEdits(final IPackageFragment originalPackage, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkStructConverter, Iterable<ReplaceEdit>>(getStructConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkStructConverter structConverter) {
					return structConverter.createRenamePackageEdits(originalPackage, newName);
				}
			}
		);
	}

	protected Iterable<ReplaceEdit> createCustomConverterRenamePackageEdits(final IPackageFragment originalPackage, final String newName) {
		return new CompositeIterable<ReplaceEdit>(
			new TransformationIterable<OrmEclipseLinkCustomConverter, Iterable<ReplaceEdit>>(getCustomConverters()) {
				@Override
				protected Iterable<ReplaceEdit> transform(OrmEclipseLinkCustomConverter customConverter) {
					return customConverter.createRenamePackageEdits(originalPackage, newName);
				}
			}
		);
	}


	// ********** validation **********

	@Override
	public void validate(List<IMessage> messages, IReporter reporter) {
		super.validate(messages, reporter);
		validateCustomConverters(messages, reporter);
		validateObjectTypeConverters(messages, reporter);
		validateStructConverters(messages, reporter);
		validateTypeConverters(messages, reporter);
	}
	
	private void validateCustomConverters(List<IMessage> messages, IReporter reporter) {
		for (OrmEclipseLinkCustomConverter converter : this.getCustomConverters()) {
			converter.validate(messages, reporter);
		}
	}

	private void validateObjectTypeConverters(List<IMessage> messages, IReporter reporter) {
		for (OrmEclipseLinkObjectTypeConverter converter : this.getObjectTypeConverters()) {
			converter.validate(messages, reporter);
		}
	}
	
	private void validateStructConverters(List<IMessage> messages, IReporter reporter) {
		for (OrmEclipseLinkStructConverter converter : this.getStructConverters()) {
			converter.validate(messages, reporter);
		}
	}

	private void validateTypeConverters(List<IMessage> messages, IReporter reporter) {
		for (OrmEclipseLinkTypeConverter converter : this.getTypeConverters()) {
			converter.validate(messages, reporter);
		}
	}

	public TextRange getValidationTextRange() {
		TextRange textRange = this.xmlConvertersHolder.getValidationTextRange();
		return (textRange != null) ? textRange : this.getParent().getValidationTextRange();
	}


	// ********** misc **********

	@Override
	public XmlContextNode getParent() {
		return (XmlContextNode) super.getParent();
	}
}