bundles/org.eclipse.equinox.p2.tools/src/org/eclipse/equinox/internal/p2/tools/MetadataCompareApplication.java

/*******************************************************************************
 * Copyright (c) 2007, 2008 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.equinox.internal.p2.tools;

//import java.net.MalformedURLException;
//import java.net.URL;
//import java.util.*;
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;

public class MetadataCompareApplication implements IApplication {

	//	private String source;
	//	private String target;
	//	private boolean compare = false;
	//	private boolean list = false;
	//	private String type = "meta";

	public Object start(IApplicationContext context) throws Exception {
		//		initializeFromArguments((String[]) context.getArguments().get("application.args"));
		//
		//		if (compare)
		//			compareMetadataRepositories(new URL(source), new URL(target));
		//		if (list) {
		//			list(source);
		//			list(target);
		//		}
		return IApplication.EXIT_OK;
	}

	//	private void list(String sourceLocation) throws ProvisionException {
	//		if (sourceLocation == null)
	//			return;
	//		IQueryable source = null;
	//		if (type.equals("meta")) {
	//			URL location;
	//			try {
	//				location = new URL(sourceLocation);
	//			} catch (MalformedURLException e) {
	//				return;
	//			}
	//			ProvisioningHelper.addMetadataRepository(location);
	//			source = ProvisioningHelper.getMetadataRepository(location);
	//			if (source == null)
	//				return;
	//		} else if (type.equals("profile")) {
	//			source = ProvisioningHelper.getProfile(sourceLocation);
	//			if (source == null)
	//				return;
	//		}
	//		IInstallableUnit[] sourceIUs = source.query(null, null, null, false, null);
	//		sourceIUs = sort(sourceIUs, true);
	//		for (int i = 0; i < sourceIUs.length; i++) {
	//			System.out.print(sourceIUs[i]);
	//			System.out.println(sourceIUs[i].isFragment() ? " (fragment)" : "");
	//		}
	//		System.out.println("Total: " + sourceIUs.length);
	//	}
	//
	//	private void compareMetadataRepositories(URL source, URL target) throws ProvisionException {
	//		ProvisioningHelper.addMetadataRepository(source);
	//		IMetadataRepository sourceRepo = ProvisioningHelper.getMetadataRepository(source);
	//		if (sourceRepo == null)
	//			return;
	//		ProvisioningHelper.addMetadataRepository(target);
	//		IMetadataRepository targetRepo = ProvisioningHelper.getMetadataRepository(target);
	//		if (targetRepo == null)
	//			return;
	//
	//		System.out.println("\n" + source.toExternalForm() + " -> " + target.toExternalForm());
	//		compare(sourceRepo, targetRepo);
	//
	//		System.out.println("\n" + target.toExternalForm() + " -> " + source.toExternalForm());
	//		compare(targetRepo, sourceRepo);
	//	}
	//
	//	private void compare(IQueryable sourceRepo, IQueryable targetRepo) {
	//		IQueryable[] target = new IQueryable[] {targetRepo};
	//		IInstallableUnit[] ius = sourceRepo.query(null, null, null, false, null);
	//		ius = sort(ius, true);
	//		for (int i = 0; i < ius.length; i++) {
	//			IInstallableUnit iu = ius[i];
	//			Iterator result = Query.getIterator(target, iu.getId(), new VersionRange(iu.getVersion(), true, iu.getVersion(), true), null, false);
	//			if (!result.hasNext())
	//				System.out.println(iu);
	//			else {
	//				String comparison = compare(iu, (IInstallableUnit) result.next());
	//				if (comparison.length() > 0)
	//					System.out.println(iu + comparison);
	//			}
	//		}
	//	}
	//
	//	private boolean compare(Object a, Object b) {
	//		if (a == null)
	//			return b == null;
	//		return a.equals(b);
	//	}
	//
	//	private boolean compare(Object[] a, Object b[]) {
	//		if (a == null)
	//			return b == null;
	//		return Arrays.equals(a, b);
	//	}
	//
	//	private String compare(IInstallableUnit iu, IInstallableUnit next) {
	//		String result = "";
	//		if (!iu.equals(next))
	//			result += " iu";
	//		if (!compare(iu.getApplicabilityFilter(), next.getApplicabilityFilter()))
	//			result += " applicabilityFilter";
	//		if (!compare(iu.getArtifacts(), next.getArtifacts()))
	//			result += " artifactLocators";
	//		if (!compare(iu.getProvidedCapabilities(), next.getProvidedCapabilities()))
	//			result += " providedCapabilities";
	//		if (!compareRequires(iu.getRequiredCapabilities(), next.getRequiredCapabilities()))
	//			result += " requiredCapabilities";
	//		if (!compare(iu.getTouchpointType(), next.getTouchpointType()))
	//			result += " touchpointType";
	//
	//		if (iu.isFragment()) {
	//			if (((InstallableUnitFragment) iu).getHostId() == null || ((InstallableUnitFragment) iu).getHostVersionRange() == null)
	//				return result;
	//			if (!((InstallableUnitFragment) iu).getHostId().equals(((InstallableUnitFragment) next).getHostId()))
	//				result += " hostid";
	//			if (!((InstallableUnitFragment) iu).getHostVersionRange().equals(((InstallableUnitFragment) next).getHostVersionRange()))
	//				result += " hostversionRange";
	//		}
	//		return result;
	//	}
	//
	//	private boolean compareRequires(RequiredCapability[] a, RequiredCapability[] b) {
	//		if (a == null)
	//			return b == null;
	//		if (a.length != b.length)
	//			return false;
	//		if (a == b)
	//			return true;
	//		for (int i = 0; i < a.length; i++)
	//			if (findCapability(a[i], b) == null)
	//				return false;
	//		return true;
	//	}
	//
	//	private RequiredCapability findCapability(RequiredCapability target, RequiredCapability[] b) {
	//		for (int i = 0; i < b.length; i++) {
	//			RequiredCapability capability = b[i];
	//			if (target.equals(capability))
	//				return capability;
	//		}
	//		return null;
	//	}
	//
	//	private IInstallableUnit[] sort(IInstallableUnit[] ius, boolean clone) {
	//		Comparator comparator = new Comparator() {
	//			public int compare(Object source, Object target) {
	//				IInstallableUnit sourceIU = (IInstallableUnit) source;
	//				IInstallableUnit targetIU = (IInstallableUnit) target;
	//				int id = sourceIU.getId().compareTo(targetIU.getId());
	//				if (id != 0)
	//					return id;
	//				int version = sourceIU.getVersion().compareTo(targetIU.getVersion());
	//				if (version != 0)
	//					return version;
	//				return 0;
	//			}
	//		};
	//		IInstallableUnit[] result = ius;
	//		if (clone) {
	//			result = new InstallableUnit[ius.length];
	//			System.arraycopy(ius, 0, result, 0, ius.length);
	//		}
	//		Arrays.sort(result, comparator);
	//		return result;
	//	}
	//
	//	public void initializeFromArguments(String[] args) throws Exception {
	//		if (args == null)
	//			return;
	//		for (int i = 0; i < args.length; i++) {
	//			// check for args without parameters (i.e., a flag arg)
	//
	//			//			if (args[i].equalsIgnoreCase("-sort"))
	//			//				sort = true;
	//
	//			if (args[i].equalsIgnoreCase("-meta"))
	//				type = "meta";
	//
	//			if (args[i].equalsIgnoreCase("-compare"))
	//				compare = true;
	//
	//			if (args[i].equalsIgnoreCase("-profile"))
	//				type = "profile";
	//
	//			if (args[i].equalsIgnoreCase("-list"))
	//				list = true;
	//
	//			// check for args with parameters. If we are at the last argument or
	//			// if the next one
	//			// has a '-' as the first character, then we can't have an arg with
	//			// a parm so continue.
	//			if (i == args.length - 1 || args[i + 1].startsWith("-")) //$NON-NLS-1$
	//				continue;
	//
	//			String arg = args[++i];
	//
	//			if (args[i - 1].equalsIgnoreCase("-source"))
	//				source = arg;
	//			if (args[i - 1].equalsIgnoreCase("-target"))
	//				target = arg;
	//		}
	//	}
	//
	public void stop() {
	}

}