plugins/org.eclipse.wst.validation/vf2/org/eclipse/wst/validation/ValidationResult.java - webtools-common/webtools.common - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2009 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.wst.validation;

 import java.util.LinkedList;
 import java.util.List;

 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.wst.validation.internal.core.ValidationException;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;

 /**
  * The result of running a validate operation. Validators create and return this objects as part of
  * performing their validation.
  * <p>
  * <b>Provisional API:</b> This class/interface is part of an interim API that is still under development and expected to
  * change significantly before reaching stability. It is being made available at this early stage to solicit feedback
  * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
  * (repeatedly) as the API evolves.
  * </p>
  * @author karasiuk
  *
  */
 public final class ValidationResult {

 	private final List<ValidatorMessage> _messages = new LinkedList<ValidatorMessage>();

 	private final static ValidatorMessage[] _noMessages = new ValidatorMessage[0];

 	private boolean		_canceled;

 	/**
 	 * The resources that the validated resource depends on. This can be left null.
 	 * For example, an XML file may depend on a XSD in order to know if it is valid or not.
 	 * It would pass back the XSD file.
 	 */
 	private IResource[]	_dependsOn;

 	/**
 	 * The objects that you validated as a side effect of validating this object. The framework will not
 	 * call you with any of these objects (in this validation run). This can be left null.
 	 */
 	private IResource[] _validated;

 	private int			_severityError;
 	private int			_severityWarning;
 	private int			_severityInfo;

 	private IProject	_suspendValidation;

 	/** A count of the number of resources that were validated. */
 	private int			_numberOfValidatedResources = 1;

 	private ReporterHelper	_reporter;
 	private ValidationException	_validationException;

 	/**
 	 * This is an optional method, that a validator can use to return error
 	 * messages. The validation framework converts these into IMarkers.
 	 * <p>
 	 * The scenario that motivated this method, is when a validator is used both
 	 * for <b>as you type</b> validation and <b>build</b> validation. When
 	 * called in as you type mode, the validator doesn't want to directly create IMarkers,
 	 * because the resource hasn't been saved yet. It needs to return something
 	 * other than an IMarker. But when called in build mode, it does ultimately
 	 * want IMarkers. By returning ValidatorMessages, it only needs to return
 	 * one type of message, and those messages can be either be directly used by
 	 * the caller, or automatically converted into IMarkers by the validation
 	 * framework.
 	 * </p>
 	 * <p>
 	 * To make matters even more complicated there is a third way to return
 	 * messages. To make it easier for old validators to port to the new
 	 * framework, they can continue to use an IReporter. If a validator calls
 	 * the getReporter() method then it is assumed by the framework that that is
 	 * the approach that they have chosen.
 	 * </p>
 	 *
 	 * @see #getReporter(IProgressMonitor)
 	 *
 	 * @param message
 	 * 		A validation message.
 	 */
 	public void add(ValidatorMessage message){
 		_messages.add(message);
 	}

 	/**
 	 * Answer an IReporter for handing error messages.
 	 * <p>
 	 * This is a transition method, to help old validators port to the new validation framework. If this method
 	 * is called it is assumed by the framework, that this IReporter will be used as the only way of passing messages
 	 * back to the framework.
 	 *
 	 * @see #add(ValidatorMessage)
 	 * @param monitor
 	 */
 	public IReporter getReporter(IProgressMonitor monitor){
 		if (_reporter == null)_reporter = new ReporterHelper(monitor);
 		return _reporter;
 	}

 	ReporterHelper getReporterHelper(){
 		return _reporter;
 	}

 	/**
 	 * Merge the message counts and messages from an individual validator into this result.
 	 * @param result it can be null, in which case it is ignored.
 	 */
 	public void mergeResults(ValidationResult result){
 		if (result == null)return;

 		ValidatorMessage[] msgs = result.getMessages();
 		for (ValidatorMessage m : msgs){
 			add(m);
 			int severity = m.getAttribute(IMarker.SEVERITY, 0);
 			switch (severity){
 			case IMarker.SEVERITY_ERROR:
 				incrementError(1);
 				break;
 			case IMarker.SEVERITY_WARNING:
 				incrementWarning(1);
 				break;
 			case IMarker.SEVERITY_INFO:
 				incrementInfo(1);
 				break;

 			}
 		}

 		incrementError(result.getSeverityError());
 		incrementWarning(result.getSeverityWarning());
 		incrementInfo(result.getSeverityInfo());

 		_numberOfValidatedResources += result.getNumberOfValidatedResources();

 	}

 	/**
 	 * Answer the resources that the validated resource depends on.
 	 */
 	public IResource[] getDependsOn() {
 		return _dependsOn;
 	}

 	/**
 	 * Answer any validation messages that were added by the validator.
 	 * @return an array is returned even if there are no messages.
 	 */
 	public ValidatorMessage[] getMessages(){
 		if (_messages == null)return _noMessages;
 		ValidatorMessage[] msgs = new ValidatorMessage[_messages.size()];
 		_messages.toArray(msgs);
 		return msgs;
 	}

 	/**
 	 * Answer a copy of any validation messages that were added by the validator. The array is a new
 	 * array, and each message is a copy.
 	 * @return an array is returned even if there are no messages.
 	 */
 	public synchronized ValidatorMessage[] getMessagesAsCopy(){
 		if (_messages == null)return _noMessages;
 		ValidatorMessage[] msgs = new ValidatorMessage[_messages.size()];
 		int i = 0;
 		for (ValidatorMessage msg : _messages)msgs[i++] = msg.asCopy();
 		return msgs;
 	}

 	/**
 	 * Update the resources that the validated resource depends on. This can be
 	 * left null. For example, a XML file may depend on a XSD file in order to
 	 * know if it is valid or not. It would pass back that XSD file.
 	 *
 	 * @param dependsOn
 	 * 		If this is null then the dependency information is not updated. To
 	 * 		remove the dependency information, an empty array needs to be
 	 * 		supplied. A non null parameter, <b>replaces</b> all the dependency
 	 * 		information for this resource, for this validator.
 	 */
 	public void setDependsOn(IResource[] dependsOn) {
 		_dependsOn = dependsOn;
 	}

 	/**
 	 * @return All the resources that were validated as a side-effect of
 	 * 	validating the main resource, or null if none were.
 	 */
 	public IResource[] getValidated() {
 		return _validated;
 	}

 	/**
 	 * Indicate that additional resources have been validated as part of this
 	 * validate operation. Sometimes in the course of performing a validation on
 	 * one resource it is necessary to validate other resources as well. This
 	 * method is used to let the framework know about these additional validated
 	 * resources, to possibly save them being validated redundantly.
 	 *
 	 * @param validated
 	 * 		Any additional resources that were validated.
 	 */
 	public void setValidated(IResource[] validated) {
 		_validated = validated;
 	}

 	/**
 	 * Answer the number of error messages that were generated as part of this validation operation.
 	 */
 	public int getSeverityError() {
 		return _severityError;
 	}

 	/**
 	 * Set the number of error messages that were generated as part of this validation operation.
 	 * <p>
 	 * Messages added through the add(ValidationMessage) method should not be included here, as this
 	 * information will be determined from the ValidationMessage.
 	 * </p>
 	 */
 	public void setSeverityError(int severityError) {
 		_severityError = severityError;
 	}


 	/**
 	 * Increment the number of error messages that were generated as part of this validation operation.
 	 * <p>
 	 * Messages added through the add(ValidationMessage) method should not be included here, as this
 	 * information will be determined from the ValidationMessage.
 	 * </p>
 	 *
 	 * @return the current number of errors.
 	 */
 	public int incrementError(int errors){
 		_severityError += errors;
 		return _severityError;
 	}

 	/**
 	 * Answer the number of warning messages that were generated as part of this validation operation.
 	 */
 	public int getSeverityWarning() {
 		return _severityWarning;
 	}

 	/**
 	 * Set the number of warning messages that were generated as part of this validation operation.
 	 * <p>
 	 * Messages added through the add(ValidationMessage) method should not be included here, as this
 	 * information will be determined from the ValidationMessage.
 	 * </p>
 	 */
 	public void setSeverityWarning(int severityWarning) {
 		_severityWarning = severityWarning;
 	}

 	/**
 	 * Increment the number of warning messages that were generated as part of this validation operation.
 	 * <p>
 	 * Messages added through the add(ValidationMessage) method should not be included here, as this
 	 * information will be determined from the ValidationMessage.
 	 * </p>
 	 *
 	 * @return the current number of warnings.
 	 */
 	public int incrementWarning(int warnings){
 		_severityWarning += warnings;
 		return _severityWarning;
 	}

 	/**
 	 * Answer the number of informational messages that were generated as part of this validation operation.
 	 */
 	public int getSeverityInfo() {
 		return _severityInfo;
 	}

 	/**
 	 * Set the number of informational messages that were generated as part of this validation operation.
 	 * <p>
 	 * Messages added through the add(ValidationMessage) method should not be included here, as this
 	 * information will be determined from the ValidationMessage.
 	 * </p>
 	 */
 	public void setSeverityInfo(int severityInfo) {
 		_severityInfo = severityInfo;
 	}

 	/**
 	 * Increment the number of informational messages that were generated as part of this validation operation.
 	 * <p>
 	 * Messages added through the add(ValidationMessage) method should not be included here, as this
 	 * information will be determined from the ValidationMessage.
 	 * </p>
 	 *
 	 * @return the current number of informational message.
 	 */
 	public int incrementInfo(int info){
 		_severityInfo += info;
 		return _severityInfo;
 	}

 	/**
 	 * Was the operation canceled before it completed? For example if the validation is being run through the
 	 * user interface, the end user can cancel the operation through the progress monitor.
 	 *
 	 * @return true if the operation was canceled
 	 */
 	public boolean isCanceled() {
 		return _canceled;
 	}

 	/**
 	 * Indicate if the operation was canceled.
 	 *
 	 * @param canceled
 	 * 		Set to true if it was canceled and false if it was not canceled.
 	 */
 	public void setCanceled(boolean canceled) {
 		_canceled = canceled;
 	}

 	/**
 	 * Answer the number of resources that have been validated.
 	 */
 	public int getNumberOfValidatedResources() {
 		if (_validated == null)return _numberOfValidatedResources;
 		return _numberOfValidatedResources + _validated.length;
 	}

 	/**
 	 * If the validation ended with an exception, answer it.
 	 * @return null if the validator did not finish with an exception.
 	 */
 	public ValidationException getValidationException() {
 		return _validationException;
 	}

 	/**
 	 * If the validation failed with an exception, it can be recorded here.
 	 * <p>
 	 * This method is provided for old validators to ease their transition to the new framework.
 	 * </p>
 	 * @param validationException
 	 */
 	public void setValidationException(ValidationException validationException) {
 		_validationException = validationException;
 	}

 	/**
 	 * Answer the project that the validator would like to have suspended.
 	 *
 	 * @return the project to suspend or null. The normal result is null, which means that
 	 * the validator wishes to receive normal validation requests.
 	 */
 	public IProject getSuspendValidation(){
 		return _suspendValidation;
 	}

 	/**
 	 * Calling this method will inform the framework, that this validator does not wish to be
 	 * called again for any resources in this project, for the duration of this validation operation.
 	 * <p>
 	 * Some validators may have a rich set of triggers, but once they have been invoked once,
 	 * do not need to be invoked again during the course of the current validation.
 	 * </p>
 	 * @param project The project that this validator no longer wants to be notified on.
 	 */
 	public void setSuspendValidation(IProject project) {
 		_suspendValidation = project;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2007, 2009 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.wst.validation;

	import java.util.LinkedList;
	import java.util.List;

	import org.eclipse.core.resources.IMarker;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.wst.validation.internal.core.ValidationException;
	import org.eclipse.wst.validation.internal.provisional.core.IReporter;

	/**
	* The result of running a validate operation. Validators create and return this objects as part of
	* performing their validation.
	* <p>
	* <b>Provisional API:</b> This class/interface is part of an interim API that is still under development and expected to
	* change significantly before reaching stability. It is being made available at this early stage to solicit feedback
	* from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
	* (repeatedly) as the API evolves.
	* </p>
	* @author karasiuk
	*
	*/
	public final class ValidationResult {

	private final List<ValidatorMessage> _messages = new LinkedList<ValidatorMessage>();

	private final static ValidatorMessage[] _noMessages = new ValidatorMessage[0];

	private boolean _canceled;

	/**
	* The resources that the validated resource depends on. This can be left null.
	* For example, an XML file may depend on a XSD in order to know if it is valid or not.
	* It would pass back the XSD file.
	*/
	private IResource[] _dependsOn;

	/**
	* The objects that you validated as a side effect of validating this object. The framework will not
	* call you with any of these objects (in this validation run). This can be left null.
	*/
	private IResource[] _validated;

	private int _severityError;
	private int _severityWarning;
	private int _severityInfo;

	private IProject _suspendValidation;

	/** A count of the number of resources that were validated. */
	private int _numberOfValidatedResources = 1;

	private ReporterHelper _reporter;
	private ValidationException _validationException;

	/**
	* This is an optional method, that a validator can use to return error
	* messages. The validation framework converts these into IMarkers.
	* <p>
	* The scenario that motivated this method, is when a validator is used both
	* for <b>as you type</b> validation and <b>build</b> validation. When
	* called in as you type mode, the validator doesn't want to directly create IMarkers,
	* because the resource hasn't been saved yet. It needs to return something
	* other than an IMarker. But when called in build mode, it does ultimately
	* want IMarkers. By returning ValidatorMessages, it only needs to return
	* one type of message, and those messages can be either be directly used by
	* the caller, or automatically converted into IMarkers by the validation
	* framework.
	* </p>
	* <p>
	* To make matters even more complicated there is a third way to return
	* messages. To make it easier for old validators to port to the new
	* framework, they can continue to use an IReporter. If a validator calls
	* the getReporter() method then it is assumed by the framework that that is
	* the approach that they have chosen.
	* </p>
	*
	* @see #getReporter(IProgressMonitor)
	*
	* @param message
	* A validation message.
	*/
	public void add(ValidatorMessage message){
	_messages.add(message);
	}

	/**
	* Answer an IReporter for handing error messages.
	* <p>
	* This is a transition method, to help old validators port to the new validation framework. If this method
	* is called it is assumed by the framework, that this IReporter will be used as the only way of passing messages
	* back to the framework.
	*
	* @see #add(ValidatorMessage)
	* @param monitor
	*/
	public IReporter getReporter(IProgressMonitor monitor){
	if (_reporter == null)_reporter = new ReporterHelper(monitor);
	return _reporter;
	}

	ReporterHelper getReporterHelper(){
	return _reporter;
	}

	/**
	* Merge the message counts and messages from an individual validator into this result.
	* @param result it can be null, in which case it is ignored.
	*/
	public void mergeResults(ValidationResult result){
	if (result == null)return;

	ValidatorMessage[] msgs = result.getMessages();
	for (ValidatorMessage m : msgs){
	add(m);
	int severity = m.getAttribute(IMarker.SEVERITY, 0);
	switch (severity){
	case IMarker.SEVERITY_ERROR:
	incrementError(1);
	break;
	case IMarker.SEVERITY_WARNING:
	incrementWarning(1);
	break;
	case IMarker.SEVERITY_INFO:
	incrementInfo(1);
	break;

	}
	}

	incrementError(result.getSeverityError());
	incrementWarning(result.getSeverityWarning());
	incrementInfo(result.getSeverityInfo());

	_numberOfValidatedResources += result.getNumberOfValidatedResources();

	}

	/**
	* Answer the resources that the validated resource depends on.
	*/
	public IResource[] getDependsOn() {
	return _dependsOn;
	}

	/**
	* Answer any validation messages that were added by the validator.
	* @return an array is returned even if there are no messages.
	*/
	public ValidatorMessage[] getMessages(){
	if (_messages == null)return _noMessages;
	ValidatorMessage[] msgs = new ValidatorMessage[_messages.size()];
	_messages.toArray(msgs);
	return msgs;
	}

	/**
	* Answer a copy of any validation messages that were added by the validator. The array is a new
	* array, and each message is a copy.
	* @return an array is returned even if there are no messages.
	*/
	public synchronized ValidatorMessage[] getMessagesAsCopy(){
	if (_messages == null)return _noMessages;
	ValidatorMessage[] msgs = new ValidatorMessage[_messages.size()];
	int i = 0;
	for (ValidatorMessage msg : _messages)msgs[i++] = msg.asCopy();
	return msgs;
	}

	/**
	* Update the resources that the validated resource depends on. This can be
	* left null. For example, a XML file may depend on a XSD file in order to
	* know if it is valid or not. It would pass back that XSD file.
	*
	* @param dependsOn
	* If this is null then the dependency information is not updated. To
	* remove the dependency information, an empty array needs to be
	* supplied. A non null parameter, <b>replaces</b> all the dependency
	* information for this resource, for this validator.
	*/
	public void setDependsOn(IResource[] dependsOn) {
	_dependsOn = dependsOn;
	}

	/**
	* @return All the resources that were validated as a side-effect of
	* validating the main resource, or null if none were.
	*/
	public IResource[] getValidated() {
	return _validated;
	}

	/**
	* Indicate that additional resources have been validated as part of this
	* validate operation. Sometimes in the course of performing a validation on
	* one resource it is necessary to validate other resources as well. This
	* method is used to let the framework know about these additional validated
	* resources, to possibly save them being validated redundantly.
	*
	* @param validated
	* Any additional resources that were validated.
	*/
	public void setValidated(IResource[] validated) {
	_validated = validated;
	}

	/**
	* Answer the number of error messages that were generated as part of this validation operation.
	*/
	public int getSeverityError() {
	return _severityError;
	}

	/**
	* Set the number of error messages that were generated as part of this validation operation.
	* <p>
	* Messages added through the add(ValidationMessage) method should not be included here, as this
	* information will be determined from the ValidationMessage.
	* </p>
	*/
	public void setSeverityError(int severityError) {
	_severityError = severityError;
	}


	/**
	* Increment the number of error messages that were generated as part of this validation operation.
	* <p>
	* Messages added through the add(ValidationMessage) method should not be included here, as this
	* information will be determined from the ValidationMessage.
	* </p>
	*
	* @return the current number of errors.
	*/
	public int incrementError(int errors){
	_severityError += errors;
	return _severityError;
	}

	/**
	* Answer the number of warning messages that were generated as part of this validation operation.
	*/
	public int getSeverityWarning() {
	return _severityWarning;
	}

	/**
	* Set the number of warning messages that were generated as part of this validation operation.
	* <p>
	* Messages added through the add(ValidationMessage) method should not be included here, as this
	* information will be determined from the ValidationMessage.
	* </p>
	*/
	public void setSeverityWarning(int severityWarning) {
	_severityWarning = severityWarning;
	}

	/**
	* Increment the number of warning messages that were generated as part of this validation operation.
	* <p>
	* Messages added through the add(ValidationMessage) method should not be included here, as this
	* information will be determined from the ValidationMessage.
	* </p>
	*
	* @return the current number of warnings.
	*/
	public int incrementWarning(int warnings){
	_severityWarning += warnings;
	return _severityWarning;
	}

	/**
	* Answer the number of informational messages that were generated as part of this validation operation.
	*/
	public int getSeverityInfo() {
	return _severityInfo;
	}

	/**
	* Set the number of informational messages that were generated as part of this validation operation.
	* <p>
	* Messages added through the add(ValidationMessage) method should not be included here, as this
	* information will be determined from the ValidationMessage.
	* </p>
	*/
	public void setSeverityInfo(int severityInfo) {
	_severityInfo = severityInfo;
	}

	/**
	* Increment the number of informational messages that were generated as part of this validation operation.
	* <p>
	* Messages added through the add(ValidationMessage) method should not be included here, as this
	* information will be determined from the ValidationMessage.
	* </p>
	*
	* @return the current number of informational message.
	*/
	public int incrementInfo(int info){
	_severityInfo += info;
	return _severityInfo;
	}

	/**
	* Was the operation canceled before it completed? For example if the validation is being run through the
	* user interface, the end user can cancel the operation through the progress monitor.
	*
	* @return true if the operation was canceled
	*/
	public boolean isCanceled() {
	return _canceled;
	}

	/**
	* Indicate if the operation was canceled.
	*
	* @param canceled
	* Set to true if it was canceled and false if it was not canceled.
	*/
	public void setCanceled(boolean canceled) {
	_canceled = canceled;
	}

	/**
	* Answer the number of resources that have been validated.
	*/
	public int getNumberOfValidatedResources() {
	if (_validated == null)return _numberOfValidatedResources;
	return _numberOfValidatedResources + _validated.length;
	}

	/**
	* If the validation ended with an exception, answer it.
	* @return null if the validator did not finish with an exception.
	*/
	public ValidationException getValidationException() {
	return _validationException;
	}

	/**
	* If the validation failed with an exception, it can be recorded here.
	* <p>
	* This method is provided for old validators to ease their transition to the new framework.
	* </p>
	* @param validationException
	*/
	public void setValidationException(ValidationException validationException) {
	_validationException = validationException;
	}

	/**
	* Answer the project that the validator would like to have suspended.
	*
	* @return the project to suspend or null. The normal result is null, which means that
	* the validator wishes to receive normal validation requests.
	*/
	public IProject getSuspendValidation(){
	return _suspendValidation;
	}

	/**
	* Calling this method will inform the framework, that this validator does not wish to be
	* called again for any resources in this project, for the duration of this validation operation.
	* <p>
	* Some validators may have a rich set of triggers, but once they have been invoked once,
	* do not need to be invoked again during the course of the current validation.
	* </p>
	* @param project The project that this validator no longer wants to be notified on.
	*/
	public void setSuspendValidation(IProject project) {
	_suspendValidation = project;
	}
	}