bundles/org.eclipse.equinox.p2.metadata.repository/src/org/eclipse/equinox/internal/p2/metadata/repository/io/MetadataWriter.java - equinox/rt.equinox.p2 - Git at Google

 /*******************************************************************************
  *  Copyright (c) 2007, 2017 IBM Corporation and others.
  *
  *  This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License 2.0
  *  which accompanies this distribution, and is available at
  *  https://www.eclipse.org/legal/epl-2.0/
  *
  *  SPDX-License-Identifier: EPL-2.0
  *
  *  Contributors:
  *     IBM Corporation - initial API and implementation
  *     Genuitec, LLC - added license support
  *******************************************************************************/
 package org.eclipse.equinox.internal.p2.metadata.repository.io;

 import java.io.OutputStream;
 import java.net.MalformedURLException;
 import java.util.*;
 import org.eclipse.core.runtime.*;
 import org.eclipse.equinox.internal.p2.core.helpers.LogHelper;
 import org.eclipse.equinox.internal.p2.metadata.RequiredCapability;
 import org.eclipse.equinox.internal.p2.metadata.RequiredPropertiesMatch;
 import org.eclipse.equinox.internal.p2.metadata.repository.Constants;
 import org.eclipse.equinox.internal.p2.persistence.XMLWriter;
 import org.eclipse.equinox.p2.metadata.*;
 import org.eclipse.equinox.p2.metadata.expression.*;

 public class MetadataWriter extends XMLWriter implements XMLConstants {

 	public MetadataWriter(OutputStream output, ProcessingInstruction[] piElements) {
 		super(output, piElements);
 		// TODO: add a processing instruction for the metadata version
 	}

 	/**
 	 * Writes a list of {@link IInstallableUnit}.
 	 * @param units An Iterator of {@link IInstallableUnit}.
 	 * @param size The number of units to write
 	 */
 	public void writeInstallableUnits(Iterator<IInstallableUnit> units, int size) {
 		if (!units.hasNext())
 			return;
 		start(INSTALLABLE_UNITS_ELEMENT);

 		// The size is a bummer. Is it really needed? It forces the use of a collect
 		attribute(COLLECTION_SIZE_ATTRIBUTE, size);
 		while (units.hasNext())
 			writeInstallableUnit(units.next());
 		end(INSTALLABLE_UNITS_ELEMENT);
 	}

 	protected void writeInstallableUnit(IInstallableUnit resolvedIU) {
 		IInstallableUnit iu = resolvedIU.unresolved();
 		start(INSTALLABLE_UNIT_ELEMENT);
 		attribute(ID_ATTRIBUTE, iu.getId());
 		attribute(VERSION_ATTRIBUTE, iu.getVersion());
 		attribute(SINGLETON_ATTRIBUTE, iu.isSingleton(), true);
 		//		attribute(FRAGMENT_ATTRIBUTE, iu.isFragment(), false);

 		boolean simpleRequirements = hasOnlySimpleRequirements(iu);
 		if (!simpleRequirements)
 			attribute(GENERATION_ATTRIBUTE, 2);

 		if (iu instanceof IInstallableUnitFragment) {
 			IInstallableUnitFragment fragment = (IInstallableUnitFragment) iu;
 			writeHostRequirements(fragment.getHost());
 		}

 		if (iu instanceof IInstallableUnitPatch) {
 			IInstallableUnitPatch patch = (IInstallableUnitPatch) iu;
 			writeApplicabilityScope(patch.getApplicabilityScope());
 			writeRequirementsChange(patch.getRequirementsChange());
 			writeLifeCycle(patch.getLifeCycle());
 		}

 		writeUpdateDescriptor(resolvedIU, resolvedIU.getUpdateDescriptor());
 		writeProperties(iu.getProperties());
 		writeMetaRequirements(iu.getMetaRequirements());
 		writeProvidedCapabilities(iu.getProvidedCapabilities());
 		if (simpleRequirements && iu instanceof IInstallableUnitFragment) {
 			Collection<IRequirement> mergedRequirementsAndFragmentHostForPre36Compatibility = new LinkedHashSet<>(iu.getRequirements());
 			mergedRequirementsAndFragmentHostForPre36Compatibility.addAll(((IInstallableUnitFragment) iu).getHost());
 			writeRequirements(mergedRequirementsAndFragmentHostForPre36Compatibility);
 		} else {
 			writeRequirements(iu.getRequirements());
 		}
 		writeTrimmedCdata(IU_FILTER_ELEMENT, iu.getFilter() == null ? null : iu.getFilter().getParameters()[0].toString());

 		writeArtifactKeys(iu.getArtifacts());
 		writeTouchpointType(iu.getTouchpointType());
 		writeTouchpointData(iu.getTouchpointData());
 		writeLicenses(iu.getLicenses());
 		writeCopyright(iu.getCopyright());

 		end(INSTALLABLE_UNIT_ELEMENT);
 	}

 	private boolean hasOnlySimpleRequirements(IInstallableUnit iu) {
 		for (IRequirement r : iu.getRequirements())
 			if (r.getMax() == 0 || !RequiredCapability.isVersionRangeRequirement(r.getMatches()))
 				return false;

 		if (iu.getUpdateDescriptor() != null) {
 			for (IMatchExpression<IInstallableUnit> m : iu.getUpdateDescriptor().getIUsBeingUpdated()) {
 				if (!RequiredCapability.isVersionRangeRequirement(m))
 					return false;
 			}
 		}

 		for (IRequirement r : iu.getMetaRequirements())
 			if (r.getMax() == 0 || !RequiredCapability.isVersionRangeRequirement(r.getMatches()))
 				return false;

 		if (iu instanceof IInstallableUnitFragment) {
 			for (IRequirement r : ((IInstallableUnitFragment) iu).getHost())
 				if (!RequiredCapability.isVersionRangeRequirement(r.getMatches()))
 					return false;
 		}

 		if (iu instanceof IInstallableUnitPatch) {
 			IInstallableUnitPatch iuPatch = (IInstallableUnitPatch) iu;
 			for (IRequirement[] rArr : iuPatch.getApplicabilityScope())
 				for (IRequirement r : rArr)
 					if (!RequiredCapability.isVersionRangeRequirement(r.getMatches()))
 						return false;

 			IRequirement lifeCycle = iuPatch.getLifeCycle();
 			if (lifeCycle != null && !RequiredCapability.isVersionRangeRequirement(lifeCycle.getMatches()))
 				return false;
 		}
 		return true;
 	}

 	protected void writeLifeCycle(IRequirement capability) {
 		if (capability == null)
 			return;
 		start(LIFECYCLE);
 		writeRequirement(capability);
 		end(LIFECYCLE);
 	}

 	protected void writeHostRequirements(Collection<IRequirement> hostRequirements) {
 		if (hostRequirements != null && hostRequirements.size() > 0) {
 			start(HOST_REQUIREMENTS_ELEMENT);
 			attribute(COLLECTION_SIZE_ATTRIBUTE, hostRequirements.size());
 			for (IRequirement req : hostRequirements) {
 				writeRequirement(req);
 			}
 			end(HOST_REQUIREMENTS_ELEMENT);
 		}
 	}

 	protected void writeProvidedCapabilities(Collection<IProvidedCapability> capabilities) {
 		if (capabilities != null && capabilities.size() > 0) {
 			start(PROVIDED_CAPABILITIES_ELEMENT);
 			attribute(COLLECTION_SIZE_ATTRIBUTE, capabilities.size());
 			for (IProvidedCapability capability : capabilities) {
 				writeProvidedCapability(capability);
 			}
 			end(PROVIDED_CAPABILITIES_ELEMENT);
 		}
 	}

 	protected void writeProvidedCapability(IProvidedCapability capability) {
 		start(PROVIDED_CAPABILITY_ELEMENT);

 		attribute(NAMESPACE_ATTRIBUTE, capability.getNamespace());
 		attribute(NAME_ATTRIBUTE, capability.getName());
 		attribute(VERSION_ATTRIBUTE, capability.getVersion());

 		Map<String, Object> props = new HashMap<>(capability.getProperties());
 		props.remove(capability.getNamespace());
 		props.remove(IProvidedCapability.PROPERTY_VERSION);

 		if (!props.isEmpty()) {
 			writeProperties(props);
 		}

 		end(PROVIDED_CAPABILITY_ELEMENT);
 	}

 	protected void writeMetaRequirements(Collection<IRequirement> metaRequirements) {
 		if (metaRequirements != null && metaRequirements.size() > 0) {
 			start(META_REQUIREMENTS_ELEMENT);
 			attribute(COLLECTION_SIZE_ATTRIBUTE, metaRequirements.size());
 			for (IRequirement req : metaRequirements) {
 				writeRequirement(req);
 			}
 			end(META_REQUIREMENTS_ELEMENT);
 		}
 	}

 	protected void writeRequirements(Collection<IRequirement> requirements) {
 		if (requirements != null && requirements.size() > 0) {
 			start(REQUIREMENTS_ELEMENT);
 			attribute(COLLECTION_SIZE_ATTRIBUTE, requirements.size());
 			for (IRequirement req : requirements) {
 				writeRequirement(req);
 			}
 			end(REQUIREMENTS_ELEMENT);
 		}
 	}

 	protected void writeUpdateDescriptor(IInstallableUnit iu, IUpdateDescriptor descriptor) {
 		if (descriptor == null)
 			return;

 		if (descriptor.getIUsBeingUpdated().size() > 1)
 			throw new IllegalStateException();
 		IMatchExpression<IInstallableUnit> singleUD = descriptor.getIUsBeingUpdated().iterator().next();
 		start(UPDATE_DESCRIPTOR_ELEMENT);
 		if (RequiredCapability.isVersionRangeRequirement(singleUD)) {
 			attribute(ID_ATTRIBUTE, RequiredCapability.extractName(singleUD));
 			attribute(VERSION_RANGE_ATTRIBUTE, RequiredCapability.extractRange(singleUD));
 		} else {
 			writeMatchExpression(singleUD);
 		}
 		attribute(UPDATE_DESCRIPTOR_SEVERITY, descriptor.getSeverity());
 		attribute(DESCRIPTION_ATTRIBUTE, descriptor.getDescription());
 		end(UPDATE_DESCRIPTOR_ELEMENT);
 	}

 	protected void writeApplicabilityScope(IRequirement[][] capabilities) {
 		start(APPLICABILITY_SCOPE);
 		for (IRequirement[] capability : capabilities) {
 			start(APPLY_ON);
 			writeRequirements(Arrays.asList(capability));
 			end(APPLY_ON);
 		}
 		end(APPLICABILITY_SCOPE);
 	}

 	protected void writeRequirementsChange(List<IRequirementChange> changes) {
 		start(REQUIREMENT_CHANGES);
 		for (int i = 0; i < changes.size(); i++) {
 			writeRequirementChange(changes.get(i));
 		}
 		end(REQUIREMENT_CHANGES);
 	}

 	protected void writeRequirementChange(IRequirementChange change) {
 		start(REQUIREMENT_CHANGE);
 		if (change.applyOn() != null) {
 			start(REQUIREMENT_FROM);
 			writeRequirement(change.applyOn());
 			end(REQUIREMENT_FROM);
 		}
 		if (change.newValue() != null) {
 			start(REQUIREMENT_TO);
 			writeRequirement(change.newValue());
 			end(REQUIREMENT_TO);
 		}
 		end(REQUIREMENT_CHANGE);
 	}

 	protected void writeRequirement(IRequirement requirement) {
 		IMatchExpression<IInstallableUnit> match = requirement.getMatches();

 		// A (namespace, name, version-range) type of requirement
 		if (requirement.getMax() > 0 && RequiredCapability.isVersionRangeRequirement(match)) {
 			start(REQUIREMENT_ELEMENT);

 			attribute(NAMESPACE_ATTRIBUTE, RequiredCapability.extractNamespace(match));
 			attribute(NAME_ATTRIBUTE, RequiredCapability.extractName(match));
 			attribute(VERSION_RANGE_ATTRIBUTE, RequiredCapability.extractRange(match));
 			attribute(REQUIRED_CAPABILITY_OPTIONAL_ATTRIBUTE, requirement.getMin() == 0, false);
 			attribute(REQUIRED_CAPABILITY_MULTIPLE_ATTRIBUTE, requirement.getMax() > 1, false);
 		}
 		// A (namespace, attributes-match) type of requirement
 		else if (RequiredPropertiesMatch.isPropertiesMatchRequirement(match)) {
 			start(REQUIREMENT_PROPERTIES_ELEMENT);

 			attribute(NAMESPACE_ATTRIBUTE, RequiredPropertiesMatch.extractNamespace(match));
 			attribute(MATCH_ATTRIBUTE, RequiredPropertiesMatch.extractPropertiesMatch(match));

 			if (requirement.getMin() != 1) {
 				attribute(MIN_ATTRIBUTE, requirement.getMin());
 			}

 			if (requirement.getMax() != 1) {
 				attribute(MAX_ATTRIBUTE, requirement.getMax());
 			}
 		}
 		// A general match expression type of requirement
 		else {
 			start(REQUIREMENT_ELEMENT);

 			writeMatchExpression(match);

 			if (requirement.getMin() != 1) {
 				attribute(MIN_ATTRIBUTE, requirement.getMin());
 			}

 			if (requirement.getMax() != 1) {
 				attribute(MAX_ATTRIBUTE, requirement.getMax());
 			}
 		}

 		attribute(REQUIREMENT_GREED_ATTRIBUTE, requirement.isGreedy(), true);

 		if (requirement.getFilter() != null) {
 			writeTrimmedCdata(REQUIREMENT_FILTER_ELEMENT, requirement.getFilter().getParameters()[0].toString());
 		}

 		if (requirement.getDescription() != null) {
 			writeTrimmedCdata(REQUIREMENT_DESCRIPTION_ELEMENT, requirement.getDescription());
 		}

 		end();
 	}

 	private void writeMatchExpression(IMatchExpression<IInstallableUnit> match) {
 		attribute(MATCH_ATTRIBUTE, ExpressionUtil.getOperand(match));
 		Object[] params = match.getParameters();
 		if (params.length > 0) {
 			IExpressionFactory factory = ExpressionUtil.getFactory();
 			IExpression[] constantArray = new IExpression[params.length];
 			for (int idx = 0; idx < params.length; ++idx)
 				constantArray[idx] = factory.constant(params[idx]);
 			attribute(MATCH_PARAMETERS_ATTRIBUTE, factory.array(constantArray));
 		}
 	}

 	protected void writeArtifactKeys(Collection<IArtifactKey> artifactKeys) {
 		if (artifactKeys != null && artifactKeys.size() > 0) {
 			start(ARTIFACT_KEYS_ELEMENT);
 			attribute(COLLECTION_SIZE_ATTRIBUTE, artifactKeys.size());
 			for (IArtifactKey artifactKey : artifactKeys) {
 				start(ARTIFACT_KEY_ELEMENT);
 				attribute(ARTIFACT_KEY_CLASSIFIER_ATTRIBUTE, artifactKey.getClassifier());
 				attribute(ID_ATTRIBUTE, artifactKey.getId());
 				attribute(VERSION_ATTRIBUTE, artifactKey.getVersion());
 				end(ARTIFACT_KEY_ELEMENT);
 			}
 			end(ARTIFACT_KEYS_ELEMENT);
 		}
 	}

 	protected void writeTouchpointType(ITouchpointType touchpointType) {
 		start(TOUCHPOINT_TYPE_ELEMENT);
 		attribute(ID_ATTRIBUTE, touchpointType.getId());
 		attribute(VERSION_ATTRIBUTE, touchpointType.getVersion());
 		end(TOUCHPOINT_TYPE_ELEMENT);
 	}

 	protected void writeTouchpointData(Collection<ITouchpointData> touchpointData) {
 		if (touchpointData != null && touchpointData.size() > 0) {
 			start(TOUCHPOINT_DATA_ELEMENT);
 			attribute(COLLECTION_SIZE_ATTRIBUTE, touchpointData.size());
 			for (ITouchpointData nextData : touchpointData) {
 				Map<String, ITouchpointInstruction> instructions = nextData.getInstructions();
 				if (instructions.size() > 0) {
 					start(TOUCHPOINT_DATA_INSTRUCTIONS_ELEMENT);
 					attribute(COLLECTION_SIZE_ATTRIBUTE, instructions.size());
 					for (Map.Entry<String, ITouchpointInstruction> entry : instructions.entrySet()) {
 						start(TOUCHPOINT_DATA_INSTRUCTION_ELEMENT);
 						attribute(TOUCHPOINT_DATA_INSTRUCTION_KEY_ATTRIBUTE, entry.getKey());
 						ITouchpointInstruction instruction = entry.getValue();
 						if (instruction.getImportAttribute() != null)
 							attribute(TOUCHPOINT_DATA_INSTRUCTION_IMPORT_ATTRIBUTE, instruction.getImportAttribute());
 						cdata(instruction.getBody(), true);
 						end(TOUCHPOINT_DATA_INSTRUCTION_ELEMENT);
 					}
 					end(TOUCHPOINT_DATA_INSTRUCTIONS_ELEMENT);
 				}
 			}
 			end(TOUCHPOINT_DATA_ELEMENT);
 		}
 	}

 	private void writeTrimmedCdata(String element, String filter) {
 		String trimmed;
 		if (filter != null && (trimmed = filter.trim()).length() > 0) {
 			start(element);
 			cdata(trimmed);
 			end(element);
 		}
 	}

 	private void writeLicenses(Collection<ILicense> licenses) {
 		if (licenses != null && licenses.size() > 0) {
 			// In the future there may be more than one license, so we write this
 			// as a collection of one.
 			// See bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=216911
 			start(LICENSES_ELEMENT);
 			attribute(COLLECTION_SIZE_ATTRIBUTE, licenses.size());
 			for (ILicense license : licenses) {
 				if (license == null)
 					continue;
 				start(LICENSE_ELEMENT);
 				if (license.getLocation() != null) {
 					attribute(URI_ATTRIBUTE, license.getLocation().toString());

 					try {
 						// we write the URL attribute for backwards compatibility with 3.4.x
 						// this attribute should be removed if we make a breaking format change.
 						attribute(URL_ATTRIBUTE, URIUtil.toURL(license.getLocation()).toExternalForm());
 					} catch (MalformedURLException e) {
 						attribute(URL_ATTRIBUTE, license.getLocation().toString());
 					}
 				}
 				cdata(license.getBody(), true);
 				end(LICENSE_ELEMENT);
 			}
 			end(LICENSES_ELEMENT);
 		}
 	}

 	private void writeCopyright(ICopyright copyright) {
 		if (copyright != null) {
 			start(COPYRIGHT_ELEMENT);
 			try {
 				if (copyright.getLocation() != null) {
 					attribute(URI_ATTRIBUTE, copyright.getLocation().toString());
 					try {
 						// we write the URL attribute for backwards compatibility with 3.4.x
 						// this attribute should be removed if we make a breaking format change.
 						attribute(URL_ATTRIBUTE, URIUtil.toURL(copyright.getLocation()).toExternalForm());
 					} catch (MalformedURLException e) {
 						attribute(URL_ATTRIBUTE, copyright.getLocation().toString());
 					}
 				}
 			} catch (IllegalStateException ise) {
 				LogHelper.log(new Status(IStatus.INFO, Constants.ID, "Error writing the copyright URL: " + copyright.getLocation())); //$NON-NLS-1$
 			}
 			cdata(copyright.getBody(), true);
 			end(COPYRIGHT_ELEMENT);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2007, 2017 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Genuitec, LLC - added license support
	*******************************************************************************/
	package org.eclipse.equinox.internal.p2.metadata.repository.io;

	import java.io.OutputStream;
	import java.net.MalformedURLException;
	import java.util.*;
	import org.eclipse.core.runtime.*;
	import org.eclipse.equinox.internal.p2.core.helpers.LogHelper;
	import org.eclipse.equinox.internal.p2.metadata.RequiredCapability;
	import org.eclipse.equinox.internal.p2.metadata.RequiredPropertiesMatch;
	import org.eclipse.equinox.internal.p2.metadata.repository.Constants;
	import org.eclipse.equinox.internal.p2.persistence.XMLWriter;
	import org.eclipse.equinox.p2.metadata.*;
	import org.eclipse.equinox.p2.metadata.expression.*;

	public class MetadataWriter extends XMLWriter implements XMLConstants {

	public MetadataWriter(OutputStream output, ProcessingInstruction[] piElements) {
	super(output, piElements);
	// TODO: add a processing instruction for the metadata version
	}

	/**
	* Writes a list of {@link IInstallableUnit}.
	* @param units An Iterator of {@link IInstallableUnit}.
	* @param size The number of units to write
	*/
	public void writeInstallableUnits(Iterator<IInstallableUnit> units, int size) {
	if (!units.hasNext())
	return;
	start(INSTALLABLE_UNITS_ELEMENT);

	// The size is a bummer. Is it really needed? It forces the use of a collect
	attribute(COLLECTION_SIZE_ATTRIBUTE, size);
	while (units.hasNext())
	writeInstallableUnit(units.next());
	end(INSTALLABLE_UNITS_ELEMENT);
	}

	protected void writeInstallableUnit(IInstallableUnit resolvedIU) {
	IInstallableUnit iu = resolvedIU.unresolved();
	start(INSTALLABLE_UNIT_ELEMENT);
	attribute(ID_ATTRIBUTE, iu.getId());
	attribute(VERSION_ATTRIBUTE, iu.getVersion());
	attribute(SINGLETON_ATTRIBUTE, iu.isSingleton(), true);
	// attribute(FRAGMENT_ATTRIBUTE, iu.isFragment(), false);

	boolean simpleRequirements = hasOnlySimpleRequirements(iu);
	if (!simpleRequirements)
	attribute(GENERATION_ATTRIBUTE, 2);

	if (iu instanceof IInstallableUnitFragment) {
	IInstallableUnitFragment fragment = (IInstallableUnitFragment) iu;
	writeHostRequirements(fragment.getHost());
	}

	if (iu instanceof IInstallableUnitPatch) {
	IInstallableUnitPatch patch = (IInstallableUnitPatch) iu;
	writeApplicabilityScope(patch.getApplicabilityScope());
	writeRequirementsChange(patch.getRequirementsChange());
	writeLifeCycle(patch.getLifeCycle());
	}

	writeUpdateDescriptor(resolvedIU, resolvedIU.getUpdateDescriptor());
	writeProperties(iu.getProperties());
	writeMetaRequirements(iu.getMetaRequirements());
	writeProvidedCapabilities(iu.getProvidedCapabilities());
	if (simpleRequirements && iu instanceof IInstallableUnitFragment) {
	Collection<IRequirement> mergedRequirementsAndFragmentHostForPre36Compatibility = new LinkedHashSet<>(iu.getRequirements());
	mergedRequirementsAndFragmentHostForPre36Compatibility.addAll(((IInstallableUnitFragment) iu).getHost());
	writeRequirements(mergedRequirementsAndFragmentHostForPre36Compatibility);
	} else {
	writeRequirements(iu.getRequirements());
	}
	writeTrimmedCdata(IU_FILTER_ELEMENT, iu.getFilter() == null ? null : iu.getFilter().getParameters()[0].toString());

	writeArtifactKeys(iu.getArtifacts());
	writeTouchpointType(iu.getTouchpointType());
	writeTouchpointData(iu.getTouchpointData());
	writeLicenses(iu.getLicenses());
	writeCopyright(iu.getCopyright());

	end(INSTALLABLE_UNIT_ELEMENT);
	}

	private boolean hasOnlySimpleRequirements(IInstallableUnit iu) {
	for (IRequirement r : iu.getRequirements())
	if (r.getMax() == 0 \|\| !RequiredCapability.isVersionRangeRequirement(r.getMatches()))
	return false;

	if (iu.getUpdateDescriptor() != null) {
	for (IMatchExpression<IInstallableUnit> m : iu.getUpdateDescriptor().getIUsBeingUpdated()) {
	if (!RequiredCapability.isVersionRangeRequirement(m))
	return false;
	}
	}

	for (IRequirement r : iu.getMetaRequirements())
	if (r.getMax() == 0 \|\| !RequiredCapability.isVersionRangeRequirement(r.getMatches()))
	return false;

	if (iu instanceof IInstallableUnitFragment) {
	for (IRequirement r : ((IInstallableUnitFragment) iu).getHost())
	if (!RequiredCapability.isVersionRangeRequirement(r.getMatches()))
	return false;
	}

	if (iu instanceof IInstallableUnitPatch) {
	IInstallableUnitPatch iuPatch = (IInstallableUnitPatch) iu;
	for (IRequirement[] rArr : iuPatch.getApplicabilityScope())
	for (IRequirement r : rArr)
	if (!RequiredCapability.isVersionRangeRequirement(r.getMatches()))
	return false;

	IRequirement lifeCycle = iuPatch.getLifeCycle();
	if (lifeCycle != null && !RequiredCapability.isVersionRangeRequirement(lifeCycle.getMatches()))
	return false;
	}
	return true;
	}

	protected void writeLifeCycle(IRequirement capability) {
	if (capability == null)
	return;
	start(LIFECYCLE);
	writeRequirement(capability);
	end(LIFECYCLE);
	}

	protected void writeHostRequirements(Collection<IRequirement> hostRequirements) {
	if (hostRequirements != null && hostRequirements.size() > 0) {
	start(HOST_REQUIREMENTS_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, hostRequirements.size());
	for (IRequirement req : hostRequirements) {
	writeRequirement(req);
	}
	end(HOST_REQUIREMENTS_ELEMENT);
	}
	}

	protected void writeProvidedCapabilities(Collection<IProvidedCapability> capabilities) {
	if (capabilities != null && capabilities.size() > 0) {
	start(PROVIDED_CAPABILITIES_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, capabilities.size());
	for (IProvidedCapability capability : capabilities) {
	writeProvidedCapability(capability);
	}
	end(PROVIDED_CAPABILITIES_ELEMENT);
	}
	}

	protected void writeProvidedCapability(IProvidedCapability capability) {
	start(PROVIDED_CAPABILITY_ELEMENT);

	attribute(NAMESPACE_ATTRIBUTE, capability.getNamespace());
	attribute(NAME_ATTRIBUTE, capability.getName());
	attribute(VERSION_ATTRIBUTE, capability.getVersion());

	Map<String, Object> props = new HashMap<>(capability.getProperties());
	props.remove(capability.getNamespace());
	props.remove(IProvidedCapability.PROPERTY_VERSION);

	if (!props.isEmpty()) {
	writeProperties(props);
	}

	end(PROVIDED_CAPABILITY_ELEMENT);
	}

	protected void writeMetaRequirements(Collection<IRequirement> metaRequirements) {
	if (metaRequirements != null && metaRequirements.size() > 0) {
	start(META_REQUIREMENTS_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, metaRequirements.size());
	for (IRequirement req : metaRequirements) {
	writeRequirement(req);
	}
	end(META_REQUIREMENTS_ELEMENT);
	}
	}

	protected void writeRequirements(Collection<IRequirement> requirements) {
	if (requirements != null && requirements.size() > 0) {
	start(REQUIREMENTS_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, requirements.size());
	for (IRequirement req : requirements) {
	writeRequirement(req);
	}
	end(REQUIREMENTS_ELEMENT);
	}
	}

	protected void writeUpdateDescriptor(IInstallableUnit iu, IUpdateDescriptor descriptor) {
	if (descriptor == null)
	return;

	if (descriptor.getIUsBeingUpdated().size() > 1)
	throw new IllegalStateException();
	IMatchExpression<IInstallableUnit> singleUD = descriptor.getIUsBeingUpdated().iterator().next();
	start(UPDATE_DESCRIPTOR_ELEMENT);
	if (RequiredCapability.isVersionRangeRequirement(singleUD)) {
	attribute(ID_ATTRIBUTE, RequiredCapability.extractName(singleUD));
	attribute(VERSION_RANGE_ATTRIBUTE, RequiredCapability.extractRange(singleUD));
	} else {
	writeMatchExpression(singleUD);
	}
	attribute(UPDATE_DESCRIPTOR_SEVERITY, descriptor.getSeverity());
	attribute(DESCRIPTION_ATTRIBUTE, descriptor.getDescription());
	end(UPDATE_DESCRIPTOR_ELEMENT);
	}

	protected void writeApplicabilityScope(IRequirement[][] capabilities) {
	start(APPLICABILITY_SCOPE);
	for (IRequirement[] capability : capabilities) {
	start(APPLY_ON);
	writeRequirements(Arrays.asList(capability));
	end(APPLY_ON);
	}
	end(APPLICABILITY_SCOPE);
	}

	protected void writeRequirementsChange(List<IRequirementChange> changes) {
	start(REQUIREMENT_CHANGES);
	for (int i = 0; i < changes.size(); i++) {
	writeRequirementChange(changes.get(i));
	}
	end(REQUIREMENT_CHANGES);
	}

	protected void writeRequirementChange(IRequirementChange change) {
	start(REQUIREMENT_CHANGE);
	if (change.applyOn() != null) {
	start(REQUIREMENT_FROM);
	writeRequirement(change.applyOn());
	end(REQUIREMENT_FROM);
	}
	if (change.newValue() != null) {
	start(REQUIREMENT_TO);
	writeRequirement(change.newValue());
	end(REQUIREMENT_TO);
	}
	end(REQUIREMENT_CHANGE);
	}

	protected void writeRequirement(IRequirement requirement) {
	IMatchExpression<IInstallableUnit> match = requirement.getMatches();

	// A (namespace, name, version-range) type of requirement
	if (requirement.getMax() > 0 && RequiredCapability.isVersionRangeRequirement(match)) {
	start(REQUIREMENT_ELEMENT);

	attribute(NAMESPACE_ATTRIBUTE, RequiredCapability.extractNamespace(match));
	attribute(NAME_ATTRIBUTE, RequiredCapability.extractName(match));
	attribute(VERSION_RANGE_ATTRIBUTE, RequiredCapability.extractRange(match));
	attribute(REQUIRED_CAPABILITY_OPTIONAL_ATTRIBUTE, requirement.getMin() == 0, false);
	attribute(REQUIRED_CAPABILITY_MULTIPLE_ATTRIBUTE, requirement.getMax() > 1, false);
	}
	// A (namespace, attributes-match) type of requirement
	else if (RequiredPropertiesMatch.isPropertiesMatchRequirement(match)) {
	start(REQUIREMENT_PROPERTIES_ELEMENT);

	attribute(NAMESPACE_ATTRIBUTE, RequiredPropertiesMatch.extractNamespace(match));
	attribute(MATCH_ATTRIBUTE, RequiredPropertiesMatch.extractPropertiesMatch(match));

	if (requirement.getMin() != 1) {
	attribute(MIN_ATTRIBUTE, requirement.getMin());
	}

	if (requirement.getMax() != 1) {
	attribute(MAX_ATTRIBUTE, requirement.getMax());
	}
	}
	// A general match expression type of requirement
	else {
	start(REQUIREMENT_ELEMENT);

	writeMatchExpression(match);

	if (requirement.getMin() != 1) {
	attribute(MIN_ATTRIBUTE, requirement.getMin());
	}

	if (requirement.getMax() != 1) {
	attribute(MAX_ATTRIBUTE, requirement.getMax());
	}
	}

	attribute(REQUIREMENT_GREED_ATTRIBUTE, requirement.isGreedy(), true);

	if (requirement.getFilter() != null) {
	writeTrimmedCdata(REQUIREMENT_FILTER_ELEMENT, requirement.getFilter().getParameters()[0].toString());
	}

	if (requirement.getDescription() != null) {
	writeTrimmedCdata(REQUIREMENT_DESCRIPTION_ELEMENT, requirement.getDescription());
	}

	end();
	}

	private void writeMatchExpression(IMatchExpression<IInstallableUnit> match) {
	attribute(MATCH_ATTRIBUTE, ExpressionUtil.getOperand(match));
	Object[] params = match.getParameters();
	if (params.length > 0) {
	IExpressionFactory factory = ExpressionUtil.getFactory();
	IExpression[] constantArray = new IExpression[params.length];
	for (int idx = 0; idx < params.length; ++idx)
	constantArray[idx] = factory.constant(params[idx]);
	attribute(MATCH_PARAMETERS_ATTRIBUTE, factory.array(constantArray));
	}
	}

	protected void writeArtifactKeys(Collection<IArtifactKey> artifactKeys) {
	if (artifactKeys != null && artifactKeys.size() > 0) {
	start(ARTIFACT_KEYS_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, artifactKeys.size());
	for (IArtifactKey artifactKey : artifactKeys) {
	start(ARTIFACT_KEY_ELEMENT);
	attribute(ARTIFACT_KEY_CLASSIFIER_ATTRIBUTE, artifactKey.getClassifier());
	attribute(ID_ATTRIBUTE, artifactKey.getId());
	attribute(VERSION_ATTRIBUTE, artifactKey.getVersion());
	end(ARTIFACT_KEY_ELEMENT);
	}
	end(ARTIFACT_KEYS_ELEMENT);
	}
	}

	protected void writeTouchpointType(ITouchpointType touchpointType) {
	start(TOUCHPOINT_TYPE_ELEMENT);
	attribute(ID_ATTRIBUTE, touchpointType.getId());
	attribute(VERSION_ATTRIBUTE, touchpointType.getVersion());
	end(TOUCHPOINT_TYPE_ELEMENT);
	}

	protected void writeTouchpointData(Collection<ITouchpointData> touchpointData) {
	if (touchpointData != null && touchpointData.size() > 0) {
	start(TOUCHPOINT_DATA_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, touchpointData.size());
	for (ITouchpointData nextData : touchpointData) {
	Map<String, ITouchpointInstruction> instructions = nextData.getInstructions();
	if (instructions.size() > 0) {
	start(TOUCHPOINT_DATA_INSTRUCTIONS_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, instructions.size());
	for (Map.Entry<String, ITouchpointInstruction> entry : instructions.entrySet()) {
	start(TOUCHPOINT_DATA_INSTRUCTION_ELEMENT);
	attribute(TOUCHPOINT_DATA_INSTRUCTION_KEY_ATTRIBUTE, entry.getKey());
	ITouchpointInstruction instruction = entry.getValue();
	if (instruction.getImportAttribute() != null)
	attribute(TOUCHPOINT_DATA_INSTRUCTION_IMPORT_ATTRIBUTE, instruction.getImportAttribute());
	cdata(instruction.getBody(), true);
	end(TOUCHPOINT_DATA_INSTRUCTION_ELEMENT);
	}
	end(TOUCHPOINT_DATA_INSTRUCTIONS_ELEMENT);
	}
	}
	end(TOUCHPOINT_DATA_ELEMENT);
	}
	}

	private void writeTrimmedCdata(String element, String filter) {
	String trimmed;
	if (filter != null && (trimmed = filter.trim()).length() > 0) {
	start(element);
	cdata(trimmed);
	end(element);
	}
	}

	private void writeLicenses(Collection<ILicense> licenses) {
	if (licenses != null && licenses.size() > 0) {
	// In the future there may be more than one license, so we write this
	// as a collection of one.
	// See bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=216911
	start(LICENSES_ELEMENT);
	attribute(COLLECTION_SIZE_ATTRIBUTE, licenses.size());
	for (ILicense license : licenses) {
	if (license == null)
	continue;
	start(LICENSE_ELEMENT);
	if (license.getLocation() != null) {
	attribute(URI_ATTRIBUTE, license.getLocation().toString());

	try {
	// we write the URL attribute for backwards compatibility with 3.4.x
	// this attribute should be removed if we make a breaking format change.
	attribute(URL_ATTRIBUTE, URIUtil.toURL(license.getLocation()).toExternalForm());
	} catch (MalformedURLException e) {
	attribute(URL_ATTRIBUTE, license.getLocation().toString());
	}
	}
	cdata(license.getBody(), true);
	end(LICENSE_ELEMENT);
	}
	end(LICENSES_ELEMENT);
	}
	}

	private void writeCopyright(ICopyright copyright) {
	if (copyright != null) {
	start(COPYRIGHT_ELEMENT);
	try {
	if (copyright.getLocation() != null) {
	attribute(URI_ATTRIBUTE, copyright.getLocation().toString());
	try {
	// we write the URL attribute for backwards compatibility with 3.4.x
	// this attribute should be removed if we make a breaking format change.
	attribute(URL_ATTRIBUTE, URIUtil.toURL(copyright.getLocation()).toExternalForm());
	} catch (MalformedURLException e) {
	attribute(URL_ATTRIBUTE, copyright.getLocation().toString());
	}
	}
	} catch (IllegalStateException ise) {
	LogHelper.log(new Status(IStatus.INFO, Constants.ID, "Error writing the copyright URL: " + copyright.getLocation())); //$NON-NLS-1$
	}
	cdata(copyright.getBody(), true);
	end(COPYRIGHT_ELEMENT);
	}
	}
	}