tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/Comparator.java

/*******************************************************************************
 * Copyright (c) 2000, 2015 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
 *     Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
 *******************************************************************************/
package org.eclipse.core.tests.resources;

import java.util.*;
import org.eclipse.core.resources.ICommand;

/**
 * This class provides static comparison methods for various core
 * objects that do not implement equals.
 */
public class Comparator {
	public static boolean equals(byte[] b0, byte[] b1) {
		if (b0 == b1) {
			return true;
		}

		if (b0 == null || b1 == null) {
			return false;
		}

		if (b0.length != b1.length) {
			return false;
		}

		for (int i = 0; i < b0.length; ++i) {
			if (b0[i] != b1[i]) {
				return false;
			}
		}

		return true;
	}

	public static boolean equals(Object[] obj0, Object[] obj1) {
		return equals(obj0, obj1, true);
	}

	public static boolean equals(Object[] obj0, Object[] obj1, boolean isOrderImportant) {
		if (obj0 == obj1) {
			return true;
		}

		if (obj0 == null || obj1 == null) {
			return false;
		}

		if (obj0.length != obj1.length) {
			return false;
		}

		if (isOrderImportant) {
			for (int i = 0; i < obj0.length; ++i) {
				if (!equals(obj0[i], obj1[i])) {
					return false;
				}
			}
		} else {
			boolean[] checkList = new boolean[obj0.length];
			for (int i = 0; i < checkList.length; ++i) {
				checkList[i] = false;
			}

			for (Object element : obj0) {
				boolean found = false;
				for (int j = 0; !found && j < obj1.length; ++j) {
					if (!checkList[j] && equals(element, obj1[j])) {
						checkList[j] = true;
						found = true;
					}
				}
				if (!found) {
					return false;
				}
			}
		}

		return true;
	}

	public static boolean equals(ICommand[] cs0, ICommand[] cs1) {
		if (cs0 == cs1) {
			return true;
		}
		if (cs0 == null || cs1 == null) {
			return false;
		}
		if (cs0.length != cs1.length) {
			return false;
		}
		for (int i = 0; i < cs0.length; ++i) {
			if (!cs0[i].getBuilderName().equals(cs1[i].getBuilderName())) {
				return false;
			}
			if (!equals(cs0[i].getArguments(), cs1[i].getArguments())) {
				return false;
			}
		}
		return true;
	}

	public static boolean equals(Object obj0, Object obj1) {
		if (obj0 == obj1) {
			return true;
		}

		if (obj0 == null || obj1 == null) {
			return false;
		}

		if (obj0 instanceof byte[] && obj1 instanceof byte[]) {
			return equals((byte[]) obj0, (byte[]) obj1);
		} else if (obj0 instanceof Enumeration && obj1 instanceof Enumeration) {
			return equals((Enumeration<?>) obj0, (Enumeration<?>) obj1);
		} else if (obj0 instanceof Hashtable && obj1 instanceof Hashtable) {
			return equals((Hashtable<?, ?>) obj0, (Hashtable<?, ?>) obj1);
		} else if (obj0 instanceof ICommand[] && obj1 instanceof ICommand[]) {
			return equals((ICommand[]) obj0, (ICommand[]) obj1);
		} else if (obj0 instanceof Object[] && obj1 instanceof Object[]) {
			return equals((Object[]) obj0, (Object[]) obj1);
		} else if (obj0 instanceof Vector && obj1 instanceof Vector) {
			return equals((Vector<?>) obj0, (Vector<?>) obj1);
		}

		return obj0.equals(obj1);
	}

	public static boolean equals(Enumeration<?> e, Object[] obj) {
		return equals(e, obj, true);
	}

	public static boolean equals(Enumeration<?> e, Object[] obj1, boolean isOrderImportant) {
		Vector<Object> v = new Vector<>();

		while (e.hasMoreElements()) {
			v.addElement(e.nextElement());
		}

		Object[] obj0 = new Object[v.size()];
		v.copyInto(obj0);

		return equals(obj0, obj1, isOrderImportant);
	}

	public static boolean equals(Enumeration<?> e0, Enumeration<?> e1) {
		if (e0 == e1) {
			return true;
		}

		if (e0 == null || e1 == null) {
			return false;
		}

		while (e0.hasMoreElements() && e1.hasMoreElements()) {
			if (!equals(e0.nextElement(), e1.nextElement())) {
				return false;
			}
		}

		if (e0.hasMoreElements() || e1.hasMoreElements()) {
			return false;
		}

		return true;
	}

	public static boolean equals(Hashtable<?, ?> ht0, Hashtable<?, ?> ht1) {
		if (ht0 == ht1) {
			return true;
		}

		if (ht0 == null || ht1 == null) {
			return false;
		}

		if (ht0.size() != ht1.size()) {
			return false;
		}

		Enumeration<?> keys0 = ht0.keys();
		while (keys0.hasMoreElements()) {
			Object key = keys0.nextElement();
			if (!equals(ht0.get(key), ht1.get(key))) {
				return false;
			}
		}

		return true;
	}

	public static boolean equals(Vector<?> c0, Vector<?> c1) {
		if (c0 == c1) {
			return true;
		}

		if (c0 == null || c1 == null) {
			return false;
		}

		if (!equals(c0.elements(), c1.elements())) {
			return false;
		}

		return true;
	}
}