import java.util.Arrays;

import org.eclipse.jdt.internal.corext.util.MethodsSourcePositionComparator;

import java.util.Arrays;

import org.eclipse.jdt.internal.corext.util.MethodsSourcePositionComparator;

			Arrays.sort(methodsToImplement, new MethodsSourcePositionComparator(fType));

import java.util.Arrays;

import org.eclipse.jdt.internal.corext.util.DelegateEntryComparator;

				Arrays.sort(fDelegatesToCreate, new DelegateEntryComparator());

import java.util.Arrays;

import java.util.HashSet;

import java.util.Set;

package org.eclipse.jdt.internal.corext.util;

import java.util.Comparator;

import org.eclipse.jdt.core.IField;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.ISourceRange;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.core.dom.IVariableBinding;

import org.eclipse.jdt.internal.corext.codemanipulation.AddDelegateMethodsOperation.DelegateEntry;

/**

 * A comparator which sorts instances of DelegateEntry according to order in which delegate methods

 * should be generated in a type. More formally, if <code>T</code> is a class and <code>d1</code>

 * and <code>d2</code> are two DelegateEntries representing delegate methods which are about to be

 * added to <code>T</code> then according to this comparator <code>d1</code> is less than

 * <code>d2</code> iff one of following holds:

 * <ul>

 * <li><code>d1</code> and <code>d2</code> represent methods delegated to the same field of

 * <code>T</code>, that field's type has a source attachment and method of <code>d1</code> appears

 * in that source before method of <code>d2</code></li>

 * <li><code>d1</code> and <code>d2</code> represent methods delegated to the same field of

 * <code>T</code>, that field's type doesn't have a source attachment and name of method of

 * <code>d1</code> alphabetically precedes name of method of <code>d2</code></li>

 * <li><code>d1</code> and <code>d2</code> represent methods delegated to different fields

 * <code>f1</code> and <code>f2</code>; field <code>f1</code> is declared before <code>f2</code> in

 * type <code>T</code></li>

 * </ul>

 */

public class DelegateEntryComparator implements Comparator {

	public DelegateEntryComparator() {

	}

	public int compare(Object o1, Object o2) {

		if (!(o1 instanceof DelegateEntry)) {

			return -1;

		}

		if (!(o2 instanceof DelegateEntry)) {

			return -1;

		}

		DelegateEntry firstEntry= (DelegateEntry)o1;

		DelegateEntry secondEntry= (DelegateEntry)o2;

		IVariableBinding firstVariable= firstEntry.field;

		IVariableBinding secondVariable= secondEntry.field;

		if (firstVariable.equals(secondVariable)) {

			try {

				IMethod firstMethod= (IMethod)firstEntry.delegateMethod.getJavaElement();

				IMethod secondMethod= (IMethod)secondEntry.delegateMethod.getJavaElement();

				ISourceRange firstSourceRange= firstMethod.getSourceRange();

				ISourceRange secondSourceRange= secondMethod.getSourceRange();

				if (firstSourceRange == null || secondSourceRange == null) {

					return firstMethod.getElementName().compareTo(secondMethod.getElementName());

				} else {

					return firstSourceRange.getOffset() - secondSourceRange.getOffset();

				}

			} catch (JavaModelException e) {

				return -1;

			}

		}

		IField firstField= (IField)firstVariable.getJavaElement();

		IField secondField= (IField)secondVariable.getJavaElement();

		try {

			return firstField.getSourceRange().getOffset() - secondField.getSourceRange().getOffset();

		} catch (JavaModelException e) {

			return -1;

		}

	}

}

package org.eclipse.jdt.internal.corext.util;

import java.util.Comparator;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.ISourceRange;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.core.dom.IMethodBinding;

import org.eclipse.jdt.core.dom.ITypeBinding;

/**

 * A comparator which sorts methods (IMethodBinding) of a type passed as constructor argument,

 * according to their order in source files. More formally, if <code>m1</code> and <code>m2</code>

 * are methods of type <code>T</code> then according to this comparator <code>m1</code> is less than

 * <code>m2</code> iff one of following holds:

 * <ul>

 * <li><code>m1</code> and <code>m2</code> are defined in the same type (<code>T</code> or any

 * supertype of <code>T</code>), that type has a source attachment and <code>m1</code> appears

 * before <code>m2</code> in source of that type</li>

 * <li><code>m1</code> and <code>m2</code> are defined in the same type (<code>T</code> or any

 * supertype of <code>T</code>), that type doesn't have a source attachment and name of

 * <code>m1</code> alphabetically precedes name of <code>m2</code></li>

 * <li><code>m1</code> is defined in <code>T</code> and <code>m2</code> is defined in any supertype

 * of <code>T</code></li>

 * <li><code>m1</code> is defined in a superclass of <code>T</code> and <code>m2</code> is defined

 * in a superinterface of <code>T</code></li>

 * <li><code>m1</code> and <code>m2</code> are defined in different superclasses of <code>T</code>

 * and a class which defines <code>m2</code> extends class which defines <code>m1</code>

 * <li><code>m1</code> and <code>m2</code> are defined in different superinterfaces of

 * <code>T</code> and an interface which defines <code>m1</code> appears before an interface which

 * defines <code>m2</code> in <code>implements</code> clause of declaration of type <code>T</code></li>

 * </ul>

 */

public class MethodsSourcePositionComparator implements Comparator {

	private final ITypeBinding fTypeBinding;

	public MethodsSourcePositionComparator(ITypeBinding typeBinding) {

		if (typeBinding == null) {

			throw new IllegalArgumentException();

		}

		fTypeBinding= typeBinding;

	}

	public int compare(Object o1, Object o2) {

		if (!(o1 instanceof IMethodBinding)) {

			return -1;

		}

		if (!(o2 instanceof IMethodBinding)) {

			return -1;

		}

		IMethodBinding firstMethodBinding= (IMethodBinding)o1;

		IMethodBinding secondMethodBinding= (IMethodBinding)o2;

		ITypeBinding firstMethodType= firstMethodBinding.getDeclaringClass();

		ITypeBinding secondMethodType= secondMethodBinding.getDeclaringClass();

		if (firstMethodType.equals(secondMethodType)) {

			return compareInTheSameType(firstMethodBinding, secondMethodBinding);

		}

		if (firstMethodType.equals(fTypeBinding)) {

			return -1;

		}

		if (secondMethodType.equals(fTypeBinding)) {

			return 1;

		}

		ITypeBinding type= fTypeBinding;

		int count= 0, firstCount= -1, secondCount= -1;

		while ((type= type.getSuperclass()) != null) {

			if (firstMethodType.equals(type)) {

				firstCount= count;

			}

			if (secondMethodType.equals(type)) {

				secondCount= count;

			}

			count++;

		}

		if (firstCount != -1 && secondCount != -1) {

			return -(firstCount - secondCount);

		}

		if (firstCount != -1 && secondCount == -1) {

			return -1;

		}

		if (firstCount == -1 && secondCount != -1) {

			return 1;

		}

		ITypeBinding[] interfaces= fTypeBinding.getInterfaces();

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

			if (firstMethodType.equals(interfaces[i])) {

				return -1;

			}

			if (secondMethodType.equals(interfaces[i])) {

				return 1;

			}

		}

		return 0;

	}

	private int compareInTheSameType(IMethodBinding firstMethodBinding, IMethodBinding secondMethodBinding) {

		try {

			IMethod firstMethod= (IMethod)firstMethodBinding.getJavaElement();

			IMethod secondMethod= (IMethod)secondMethodBinding.getJavaElement();

			if (firstMethod == null || secondMethod == null) {

				return -1;

			}

			ISourceRange firstSourceRange= firstMethod.getSourceRange();

			ISourceRange secondSourceRange= secondMethod.getSourceRange();

			if (firstSourceRange == null || secondSourceRange == null) {

				return firstMethod.getElementName().compareTo(secondMethod.getElementName());

			} else {

				return firstSourceRange.getOffset() - secondSourceRange.getOffset();

			}

		} catch (JavaModelException e) {

			return -1;

		}

	}

}