plugins/org.eclipse.jst.j2ee.core/j2ee-validation/org/eclipse/jst/j2ee/model/internal/validation/AbstractEJBValidator.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 2006 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
  *******************************************************************************/
 /*
  * Created on Nov 24, 2003
  *
  * To change the template for this generated file go to
  * Window>Preferences>Java>Code Generation>Code and Comments
  */
 package org.eclipse.jst.j2ee.model.internal.validation;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
 import java.util.logging.Level;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jem.util.logger.proxy.Logger;
 import org.eclipse.wst.validation.ValidationState;
 import org.eclipse.wst.validation.internal.core.ValidationException;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;
 import org.eclipse.wst.validation.internal.provisional.core.IValidatorExtender;
 /**
  * @author vijayb
  *
  * To change the template for this generated type comment go to
  * Window>Preferences>Java>Code Generation>Code and Comments
  */
 public abstract class AbstractEJBValidator extends J2EEValidator implements IValidatorExtender {
 	protected Map _validated = null;
 	/**
 	 *
 	 */
 	public AbstractEJBValidator() {
 		super();
 		_validated = new HashMap();
 	}

 	private Map getValidatedMap(){
 		if( _validated == null ){
 			_validated = new HashMap();
 		}
 		return _validated;
 	}

 	protected void logMissingRule(IEJBValidationContext vc, Object ruleId) {
 		Logger logger = vc.getMsgLogger();
 		if (logger != null && logger.isLoggingLevel(Level.SEVERE)) {
 			logger.write(Level.SEVERE, ruleId + " = null"); //$NON-NLS-1$
 		}
 		addInternalErrorMessage(vc);
 	}
 	protected void addInternalErrorMessage(IEJBValidationContext vc) {
 			addInternalErrorMessage(vc, null);
 	}

 	protected void addInternalErrorMessage(IEJBValidationContext vc, Throwable exc) {
 		IMessage mssg = vc.getMessage();
 		mssg.setId(internalErrorMessage());
 		vc.addMessage(mssg);
 		if(exc != null) {
 			Logger logger = vc.getMsgLogger();
 			if (logger != null && logger.isLoggingLevel(Level.SEVERE)) {
 				logger.write(Level.SEVERE, exc);
 			}
 		}
 	}

 	protected Map removeOldMessages(IEJBValidationContext vc,Map targets) throws ValidationException {
 			if(vc.getURIs() == null) {
 				// Full validation
 				vc.removeAllMessages(); // Remove messages from the EJBJar.
 				vc.loadModel(removeOldMessagesString(), new Object[]{vc.getReporter(), null}); // Remove messages from any EJB client JAR files or Java Utility JAR files.
 				return null;
 			}
 			preRemoveOldMessages(vc,targets); // Get the list of targets to be validated, and remove messages from all of them.

 			// Remove the messages from all of the changed files and their dependents.
 			vc.loadModel(removeOldMessagesString(), new Object[]{vc.getReporter(), targets});
 			return targets;
 		}
 	/**
 	 * @param vc
 	 * @param delta
 	 * @param targets
 	 */
 	protected void preRemoveOldMessages(IEJBValidationContext vc,Map targets) throws ValidationException {
 		//Default
 	}
 	/**
 	 * @return
 	 */
 	protected String removeOldMessagesString() {
 		return null;
 	}
 	/**
 	* @return
 	*/
 	private String internalErrorMessage() {
 			return null;
 		}
 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.wst.validation.internal.core.core.IValidator#validate(org.eclipse.wst.validation.internal.core.core.IHelper,
 	 *      org.eclipse.wst.validation.internal.core.core.IReporter,
 	 *      org.eclipse.wst.validation.internal.core.core.IFileDelta[])
 	 */
 	@Override
 	public void validate(IValidationContext helper, IReporter reporter) throws ValidationException {
 		//Default
 		super.validate(helper, reporter);
 	}

     public void run(IValidationRule rule, Object targetParent, Object target) throws ValidationException {
     	if(isValidated(rule.getId(), targetParent, target)) {
     		// Whether or not this is a full or incremental run, don't revalidate this target
     		// if it has already been validated. (e.g. if a class is used by more than one bean,
     		// and say one bean is stateless and one is stateful, and everything else about the
     		// beans are identical, don't validate that class again.)
     		return;
     	}

     	try {
     		rule.preValidate(getValidationContext(), targetParent, target);
     		rule.validate(getValidationContext(), targetParent, target);
     		rule.postValidate(getValidationContext(), targetParent, target);
     	}
     	catch(ValidationCancelledException exc) {
     		// Clean up the messages which are on the task list? Or is it nicer to leave them behind?
     	}
     	catch(ValidationException e) {
     		throw e;
     	}
     	catch(Throwable exc) {
     		addInternalErrorMessage(getValidationContext(), exc);
     	}
     	finally {
     		setValidated(rule.getId(), targetParent, target);
     		releaseRules(rule);
     	}
     }

     /**
      * @param rule
      */
     protected abstract void releaseRules(IValidationRule rule);

     private IEJBValidationContext _vc = null;

     protected IEJBValidationContext getValidationContext() {
     	return _vc;
     }
     protected void setValidationContext(IEJBValidationContext vc) {
     	_vc = vc;
     }

 	/**
 	 *  This class is public only for the EJBHelper.
 	 */
 	public class TargetObject {
 		private Object _parent = null;
 		private Object _target = null;

 		public TargetObject() {
 			//Default
 		}

 		public Object getTargetParent() {
 			return _parent;
 		}

 		public Object getTarget() {
 			return _target;
 		}

 		public void setTargetParent(Object tp) {
 			_parent = tp;
 		}

 		public void setTarget(Object t) {
 			_target = t;
 		}

 		@Override
 		public int hashCode() {
 			int parent = (getTargetParent() == null) ? 0 : getTargetParent().hashCode();
 			int target = (getTarget() == null) ? 0 : getTarget().hashCode();
 			return parent + target;
 		}

 		@Override
 		public boolean equals(Object o) {
 			if(o == null) {
 				return false;
 			}

 			if(this == o) {
 				return true;
 			}

 			if(!(o instanceof TargetObject)) {
 				return false;
 			}

 			Object thisParent = this.getTargetParent();
 			Object oParent = ((TargetObject)o).getTargetParent();
 			Object thisTarget = this.getTarget();
 			Object oTarget = ((TargetObject)o).getTarget();

 			if((thisParent == null) && (oParent == null)) {
 				// check target
 			}
 			else if((thisParent != null) && (oParent != null)) {
 				if(thisParent.equals(oParent)) {
 					// check target
 				}
 				else {
 					return false;
 				}
 			}
 			else {
 				return false;
 			}

 			if((thisTarget == null) && (oTarget == null)) {
 				return true;
 			}
 			else if((thisTarget != null) && (oTarget != null)) {
 				return (thisTarget.equals(oTarget));
 			}
 			else {
 				return false;
 			}
 		}
 	}


     public void setValidated(Object key, Object targetParent, Object target) {
     	Set done = null;
     	if(getValidatedMap().containsKey(key)) {
     		done = (Set)getValidatedMap().get(key);
     	}
     	else {
     		done = new HashSet();
     	}

     	done.add(getTargetObjectPool().getTargetObject(targetParent, target));
     	getValidatedMap().put(key, done);
     }


 	protected class TargetObjectPool {
 		private int _growSize = 0;
 		private Vector _pool = null;

 		public TargetObjectPool(int initialSize) {
 			_growSize = initialSize;
 			_pool = new Vector(initialSize, _growSize);
 			grow();
 		}

 		private void grow() {
 			for(int i=0; i<_growSize; i++) {
 				_pool.add(new TargetObject());
 			}
 		}

 		public TargetObject getTargetObject(Object targetParent, Object target) {
 			if(_pool.size() <= 0) {
 				grow();
 			}
 			TargetObject obj = (TargetObject)_pool.remove(0);
 			obj.setTargetParent(targetParent);
 			obj.setTarget(target);
 			return obj;
 		}

 		public void release(TargetObject obj) {
 			obj.setTargetParent(null);
 			obj.setTarget(null);
 			_pool.add(obj);
 		}
 	}

 	protected abstract TargetObjectPool getTargetObjectPool();

     public boolean isValidated(Object key, Object targetParent, Object target) {
     	if(!getValidatedMap().containsKey(key)) {
     		return false;
     	}


     	Set done = (Set)getValidatedMap().get(key);
     	TargetObject temp = getTargetObjectPool().getTargetObject(targetParent, target);
     	try {
     		if(done.contains(temp)) {
     			return true;
     		}

     		return false;
     	}
     	finally {
     		getTargetObjectPool().release(temp);
     	}
     }
     @Override
     public void cleanup(IReporter reporter) {
     	//cleanup has been moved to the validationFinishing method below.  See bugzilla 290581 for details.
     }

 	public void validationFinishing(IProject project, ValidationState state, IProgressMonitor monitor) {
 		if( _validated != null ){
 	    	Iterator iterator = _validated.keySet().iterator();
 	    	while(iterator.hasNext()) {
 	    		Set done = (Set)_validated.get(iterator.next());
 	    		Iterator toIterator = done.iterator();
 	    		while(toIterator.hasNext()) {
 	    			TargetObject to = (TargetObject)toIterator.next();
 	    			getTargetObjectPool().release(to);
 	    		}
 	    		done.clear();
 	    	}
 	    	_validated.clear();
 	    	_validated = null;
 		}
 		setValidationContext(null);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2001, 2006 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
	*******************************************************************************/
	/*
	* Created on Nov 24, 2003
	*
	* To change the template for this generated file go to
	* Window>Preferences>Java>Code Generation>Code and Comments
	*/
	package org.eclipse.jst.j2ee.model.internal.validation;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.Set;
	import java.util.Vector;
	import java.util.logging.Level;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.jem.util.logger.proxy.Logger;
	import org.eclipse.wst.validation.ValidationState;
	import org.eclipse.wst.validation.internal.core.ValidationException;
	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
	import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;
	import org.eclipse.wst.validation.internal.provisional.core.IValidatorExtender;
	/**
	* @author vijayb
	*
	* To change the template for this generated type comment go to
	* Window>Preferences>Java>Code Generation>Code and Comments
	*/
	public abstract class AbstractEJBValidator extends J2EEValidator implements IValidatorExtender {
	protected Map _validated = null;
	/**
	*
	*/
	public AbstractEJBValidator() {
	super();
	_validated = new HashMap();
	}

	private Map getValidatedMap(){
	if( _validated == null ){
	_validated = new HashMap();
	}
	return _validated;
	}

	protected void logMissingRule(IEJBValidationContext vc, Object ruleId) {
	Logger logger = vc.getMsgLogger();
	if (logger != null && logger.isLoggingLevel(Level.SEVERE)) {
	logger.write(Level.SEVERE, ruleId + " = null"); //$NON-NLS-1$
	}
	addInternalErrorMessage(vc);
	}
	protected void addInternalErrorMessage(IEJBValidationContext vc) {
	addInternalErrorMessage(vc, null);
	}

	protected void addInternalErrorMessage(IEJBValidationContext vc, Throwable exc) {
	IMessage mssg = vc.getMessage();
	mssg.setId(internalErrorMessage());
	vc.addMessage(mssg);
	if(exc != null) {
	Logger logger = vc.getMsgLogger();
	if (logger != null && logger.isLoggingLevel(Level.SEVERE)) {
	logger.write(Level.SEVERE, exc);
	}
	}
	}

	protected Map removeOldMessages(IEJBValidationContext vc,Map targets) throws ValidationException {
	if(vc.getURIs() == null) {
	// Full validation
	vc.removeAllMessages(); // Remove messages from the EJBJar.
	vc.loadModel(removeOldMessagesString(), new Object[]{vc.getReporter(), null}); // Remove messages from any EJB client JAR files or Java Utility JAR files.
	return null;
	}
	preRemoveOldMessages(vc,targets); // Get the list of targets to be validated, and remove messages from all of them.

	// Remove the messages from all of the changed files and their dependents.
	vc.loadModel(removeOldMessagesString(), new Object[]{vc.getReporter(), targets});
	return targets;
	}
	/**
	* @param vc
	* @param delta
	* @param targets
	*/
	protected void preRemoveOldMessages(IEJBValidationContext vc,Map targets) throws ValidationException {
	//Default
	}
	/**
	* @return
	*/
	protected String removeOldMessagesString() {
	return null;
	}
	/**
	* @return
	*/
	private String internalErrorMessage() {
	return null;
	}
	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.wst.validation.internal.core.core.IValidator#validate(org.eclipse.wst.validation.internal.core.core.IHelper,
	* org.eclipse.wst.validation.internal.core.core.IReporter,
	* org.eclipse.wst.validation.internal.core.core.IFileDelta[])
	*/
	@Override
	public void validate(IValidationContext helper, IReporter reporter) throws ValidationException {
	//Default
	super.validate(helper, reporter);
	}

	public void run(IValidationRule rule, Object targetParent, Object target) throws ValidationException {
	if(isValidated(rule.getId(), targetParent, target)) {
	// Whether or not this is a full or incremental run, don't revalidate this target
	// if it has already been validated. (e.g. if a class is used by more than one bean,
	// and say one bean is stateless and one is stateful, and everything else about the
	// beans are identical, don't validate that class again.)
	return;
	}

	try {
	rule.preValidate(getValidationContext(), targetParent, target);
	rule.validate(getValidationContext(), targetParent, target);
	rule.postValidate(getValidationContext(), targetParent, target);
	}
	catch(ValidationCancelledException exc) {
	// Clean up the messages which are on the task list? Or is it nicer to leave them behind?
	}
	catch(ValidationException e) {
	throw e;
	}
	catch(Throwable exc) {
	addInternalErrorMessage(getValidationContext(), exc);
	}
	finally {
	setValidated(rule.getId(), targetParent, target);
	releaseRules(rule);
	}
	}

	/**
	* @param rule
	*/
	protected abstract void releaseRules(IValidationRule rule);

	private IEJBValidationContext _vc = null;

	protected IEJBValidationContext getValidationContext() {
	return _vc;
	}
	protected void setValidationContext(IEJBValidationContext vc) {
	_vc = vc;
	}

	/**
	* This class is public only for the EJBHelper.
	*/
	public class TargetObject {
	private Object _parent = null;
	private Object _target = null;

	public TargetObject() {
	//Default
	}

	public Object getTargetParent() {
	return _parent;
	}

	public Object getTarget() {
	return _target;
	}

	public void setTargetParent(Object tp) {
	_parent = tp;
	}

	public void setTarget(Object t) {
	_target = t;
	}

	@Override
	public int hashCode() {
	int parent = (getTargetParent() == null) ? 0 : getTargetParent().hashCode();
	int target = (getTarget() == null) ? 0 : getTarget().hashCode();
	return parent + target;
	}

	@Override
	public boolean equals(Object o) {
	if(o == null) {
	return false;
	}

	if(this == o) {
	return true;
	}

	if(!(o instanceof TargetObject)) {
	return false;
	}

	Object thisParent = this.getTargetParent();
	Object oParent = ((TargetObject)o).getTargetParent();
	Object thisTarget = this.getTarget();
	Object oTarget = ((TargetObject)o).getTarget();

	if((thisParent == null) && (oParent == null)) {
	// check target
	}
	else if((thisParent != null) && (oParent != null)) {
	if(thisParent.equals(oParent)) {
	// check target
	}
	else {
	return false;
	}
	}
	else {
	return false;
	}

	if((thisTarget == null) && (oTarget == null)) {
	return true;
	}
	else if((thisTarget != null) && (oTarget != null)) {
	return (thisTarget.equals(oTarget));
	}
	else {
	return false;
	}
	}
	}


	public void setValidated(Object key, Object targetParent, Object target) {
	Set done = null;
	if(getValidatedMap().containsKey(key)) {
	done = (Set)getValidatedMap().get(key);
	}
	else {
	done = new HashSet();
	}

	done.add(getTargetObjectPool().getTargetObject(targetParent, target));
	getValidatedMap().put(key, done);
	}


	protected class TargetObjectPool {
	private int _growSize = 0;
	private Vector _pool = null;

	public TargetObjectPool(int initialSize) {
	_growSize = initialSize;
	_pool = new Vector(initialSize, _growSize);
	grow();
	}

	private void grow() {
	for(int i=0; i<_growSize; i++) {
	_pool.add(new TargetObject());
	}
	}

	public TargetObject getTargetObject(Object targetParent, Object target) {
	if(_pool.size() <= 0) {
	grow();
	}
	TargetObject obj = (TargetObject)_pool.remove(0);
	obj.setTargetParent(targetParent);
	obj.setTarget(target);
	return obj;
	}

	public void release(TargetObject obj) {
	obj.setTargetParent(null);
	obj.setTarget(null);
	_pool.add(obj);
	}
	}

	protected abstract TargetObjectPool getTargetObjectPool();

	public boolean isValidated(Object key, Object targetParent, Object target) {
	if(!getValidatedMap().containsKey(key)) {
	return false;
	}


	Set done = (Set)getValidatedMap().get(key);
	TargetObject temp = getTargetObjectPool().getTargetObject(targetParent, target);
	try {
	if(done.contains(temp)) {
	return true;
	}

	return false;
	}
	finally {
	getTargetObjectPool().release(temp);
	}
	}
	@Override
	public void cleanup(IReporter reporter) {
	//cleanup has been moved to the validationFinishing method below. See bugzilla 290581 for details.
	}

	public void validationFinishing(IProject project, ValidationState state, IProgressMonitor monitor) {
	if( _validated != null ){
	Iterator iterator = _validated.keySet().iterator();
	while(iterator.hasNext()) {
	Set done = (Set)_validated.get(iterator.next());
	Iterator toIterator = done.iterator();
	while(toIterator.hasNext()) {
	TargetObject to = (TargetObject)toIterator.next();
	getTargetObjectPool().release(to);
	}
	done.clear();
	}
	_validated.clear();
	_validated = null;
	}
	setValidationContext(null);
	}

	}