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

 /*******************************************************************************
  * Copyright (c) 2001, 2005 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.jst.j2ee.model.internal.validation;

 import java.util.List;

 import org.eclipse.jem.java.JavaClass;
 import org.eclipse.jem.java.JavaHelpers;
 import org.eclipse.jem.java.Method;
 import org.eclipse.jst.j2ee.ejb.EnterpriseBean;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;


 /**
  * This class checks remote interface classes for errors or potential errors.
  * If any problems are found, an error, warning, or info marker is added to the task list.
  * The checks for a session remote interface and an entity remote interface are the same
  * in EJB 1.1.
  *
  * The following paragraph is taken from
  * Enterprise JavaBeans Specification ("Specification")
  * Version: 1.1
  * Status: Final Release
  * Release: 12/17/99
  * Copyright 1999 Sun Microsystems, Inc.
  * 901 San Antonio Road, Palo Alto, CA 94303, U.S.A.
  * All rights reserved.
  *
  * 6.10.5 Session bean's remote interface
  * The following are the requirements for the session bean's remote interface:
  *		- The interface must extend the javax.ejb.EJBObject interface.
  *		- The methods defined in this interface must follow the rules for RMI/IIOP.
  *        This means that their argument and return values must be of valid types
  *        for RMI/IIOP, and their throws clause must include the java.rmi.RemoteException.
  *		- The remote interface is allowed to have superinterfaces. Use of interface
  *        inheritance is subject to the RMI/IIOP rules for the definition of remote interfaces.
  *		- For each method defined in the remote interface, there must be a matching
  *        method in the session bean's class.
  *			- The matching method must have:
  *				- The same name.
  *				- The same number and types of arguments, and the same return type.
  *				- All the exceptions defined in the throws clause of the matching
  *                method of the session bean class must be defined in the throws
  *                clause of the method of the remote interface.
  *
  * 9.2.7 Entity bean's remote interface
  * The following are the requirements for the entity bean's remote interface:
  * 		- The interface must extend the javax.ejb.EJBObject interface.
  * 		- The methods defined in the remote interface must follow the rules for RMI-IIOP.
  * 		  This means that their argument and return value types must be valid types for RMI-IIOP,
  * 		  and their throws clauses must include the java.rmi.RemoteException.
  * 		- The remote interface is allowed to have superinterfaces. Use of interface inheritance
  *		  is subject to the RMI-IIOP rules for the definition of remote interfaces.
  * 		- For each method defined in the remote interface, there must be a matching method
  *		  in the entity bean's class. The matching method must have:
  * 			- The same name.
  *			- The same number and types of its arguments, and the same return type.
  *			- All the exceptions defined in the throws clause of the matching method
  *			  of the enterprise Bean class must be defined in the throws clause of
  *			  the method of the remote interface.
  */
 public abstract class AValidateRemote extends AValidateEJB {
 	public final Object getTarget(Object parent, Object clazz) {
 		if(parent == null) {
 			return null;
 		}

 		return ((EnterpriseBean)parent).getRemoteInterface();
 	}

 	public final List[] getMethodsExtended(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz)  {
 		// A home or component class needs the following classes' extended methods:
 		//    1. bean class
 		List[] result = new List[1];
 		JavaClass beanClass = bean.getEjbClass();
 		if(beanClass == null) {
 			result[0] = null;
 		}
 		else {
 			result[0] = beanClass.getMethodsExtended();
 		}
 		return result;
 	}

 	public final List[] getFieldsExtended(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) {
 		// Never check that a home or component's field is defined on another class
 		// of the bean.
 		return null;
 	}

 	/**
 	 * Return true if the method can, and should, be validated.
 	 * Filter out faulty methods (i.e., null), and methods which
 	 * belong to the base type, whatever that is. (e.g. java.lang.Object)
 	 */
 	protected boolean isValid(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method, List[] methodsExtendedList) throws InvalidInputException {
 		if (super.isValid(vc, bean, clazz, method, methodsExtendedList)) {
 			// Exclude root remote interface methods
 			if (ValidationRuleUtility.isEJBObjectMethod(bean, method)) {
 				return false;
 			}
 			else if (isEjbRelationshipRoleMethod(vc, bean, clazz, method)) {
 				return false;
 			}
 			else if (ValidationRuleUtility.isClinitMethod(bean, method)) {
 				return false;
 			}
 			else {
 				return true;
 			}
 		}
 		return false;
 	}

 	/**
 	 * Check the remote interface's methods against the EJB 1.1 spec.
 	 *
 	 * 6.10.5 Session bean's remote interface
 	 * ...
 	 *		- The methods defined in this interface must follow the rules for RMI/IIOP.
 	 *        This means that their argument and return values must be of valid types
 	 *        for RMI/IIOP, and their throws clause must include the java.rmi.RemoteException.
 	 * ...
 	 *		- For each method defined in the remote interface, there must be a matching
 	 *        method in the session bean's class.
 	 *			- The matching method must have:
 	 *				- The same name.
 	 *				- The same number and types of arguments, and the same return type.
 	 *				- All the exceptions defined in the throws clause of the matching
 	 *                method of the session bean class must be defined in the throws
 	 *                clause of the method of the remote interface.
 	 * ...
 	 * 9.2.7 Entity bean's remote interface
 	 * ...
 	 * 		- The methods defined in the remote interface must follow the rules for RMI-IIOP.
 	 * 		  This means that their argument and return value types must be valid types for RMI-IIOP,
 	 * 		  and their throws clauses must include the java.rmi.RemoteException.
 	 * ...
 	 * 		- For each method defined in the remote interface, there must be a matching method
 	 *		  in the entity bean's class. The matching method must have:
 	 * 			- The same name.
 	 *			- The same number and types of its arguments, and the same return type.
 	 *			- All the exceptions defined in the throws clause of the matching method
 	 *			  of the enterprise Bean class must be defined in the throws clause of
 	 *			  the method of the remote interface.
 	 * ...
 	 */
 	public void primValidate(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method riMethod) throws InvalidInputException {
 		// Can't invoke an abstract method
 		// super.validateExistence(riMethod);

 		vc.terminateIfCancelled();

 		// The methods defined in this interface must follow the rules for RMI/IIOP.
 		validateLegalRMIMethod(vc, bean, clazz, riMethod);

 		// For each method defined in the remote interface, there must be a matching
 		// method in the session bean's class.
 		validateMethod_beanDep(vc, bean, clazz, riMethod);

 	}

 	/**
 	 * Checks to see if @ejbMethod is one of the required methods.
 	 */
 	protected void primValidateExistence(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method ejbMethod) throws InvalidInputException {
 		// Can't invoke an abstract method
 		//super.validateExistence(ejbMethod);

 		//There are no required methods.
 	}

 	/**
 	 * Check that the remote interface class definition follows the EJB 1.1 spec.
 	 *
 	 * The following paragraph is taken from
 	 * Enterprise JavaBeans Specification ("Specification")
 	 * Version: 1.1
 	 * Status: Final Release
 	 * Release: 12/17/99
 	 * Copyright 1999 Sun Microsystems, Inc.
 	 * 901 San Antonio Road, Palo Alto, CA 94303, U.S.A.
 	 * All rights reserved.
 	 *
 	 * 6.10.5 Session bean's remote interface
 	 * The following are the requirements for the session bean's remote interface:
 	 *		- The interface must extend the javax.ejb.EJBObject interface.
 	 * ...
 	 *		- The remote interface is allowed to have superinterfaces. Use of interface
 	 *        inheritance is subject to the RMI/IIOP rules for the definition of remote interfaces.
 	 * ...
 	 * 9.2.7 Entity bean's remote interface
 	 * The following are the requirements for the entity bean's remote interface:
 	 * 		- The interface must extend the javax.ejb.EJBObject interface.
 	 * ...
 	 * 		- The remote interface is allowed to have superinterfaces. Use of interface inheritance
 	 *		  is subject to the RMI-IIOP rules for the definition of remote interfaces.
 	 * ...
 	 */
 	public void validateClass(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) throws InvalidInputException {
 		vc.terminateIfCancelled();

 		// It must be an interface, not a class.
 		if (!clazz.isInterface()) {
 			IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2012, IEJBValidationContext.ERROR, bean, clazz, this);
 			vc.addMessage(message);
 		}

 		// The interface must extend the javax.ejb.EJBObject interface.
 		JavaHelpers javaxEjbObject = ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVAX_EJB_EJBOBJECT, bean);
 		if (!ValidationRuleUtility.isAssignableFrom(clazz, javaxEjbObject)) {
 			String[] msgParm = { ITypeConstants.CLASSNAME_JAVAX_EJB_EJBOBJECT };
 			IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2017, IEJBValidationContext.ERROR, bean, clazz, msgParm, this);
 			vc.addMessage(message);
 		}

 		if (ValidationRuleUtility.isUnnamedPackage(clazz.getJavaPackage())) {
 			IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2041, IEJBValidationContext.INFO, bean, clazz, this);
 			vc.addMessage(message);
 		}

 		validateAppendixB(vc, bean, clazz);
 	}

 	/**
 	 * 6.10.5
 	 * For each method defined in the remote interface, there must be a matching
 	 * method in the session bean's class. The matching method must have:
 	 *   - The same name.
 	 *   - The same number and types of arguments, and the same return type.
 	 *   - All the exceptions defined in the throws clause of the matching method
 	 *     of the session bean class must be defined in the throws clause of the
 	 *     method of the remote interface.
 	 *
 	 * 9.2.7
 	 * For each method defined in the remote interface, there must be a matching
 	 * method in the entity bean's class. The matching method must have:
 	 *   - The same name.
 	 *   - The same number and types of its arguments, and the same return type.
 	 *   - All the exceptions defined in the throws clause of the matching method
 	 *     of the enterprise Bean class must be defined in the throws clause of
 	 *     the method of the remote interface.
 	 */
 	public void validateMatchingBeanMethod(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method remoteMethod) throws InvalidInputException {
 		vc.terminateIfCancelled();
 		if (remoteMethod == null) {
 			return;
 		}

 		JavaClass beanClass = bean.getEjbClass();
 		ValidationRuleUtility.isValidTypeHierarchy(bean, beanClass);

 		Method beanMethod = ValidationRuleUtility.getMethodExtended(beanClass, remoteMethod, remoteMethod.getName());
 		if (beanMethod == null) {
 			String[] msgParm = { beanClass.getName()};
 			IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2023, IEJBValidationContext.ERROR, bean, clazz, remoteMethod, msgParm, this);
 			vc.addMessage(message);
 			return;
 		}

 		ValidationRuleUtility.isValidType(ValidationRuleUtility.getType(remoteMethod.getReturnType()));

 		try {
 			ValidationRuleUtility.isValidType(ValidationRuleUtility.getType(beanMethod.getReturnType()));
 		}
 		catch (InvalidInputException e) {
 			// Let the validation of the bean class report the reflection warning.
 			// Don't do any validation based on that method.
 			return;
 		}

 		// Check if return types match
 		vc.terminateIfCancelled();
 		if (!ValidationRuleUtility.isAssignableFrom(remoteMethod.getReturnType(), beanMethod.getReturnType())) {
 			IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2415, IEJBValidationContext.ERROR, bean, clazz, remoteMethod, new String[] { beanMethod.getReturnType().getJavaName(), beanClass.getName()}, this);
 			vc.addMessage(message);
 		}


 		// Section 6.10.5 (session), 9.2.7 (entity), declare that all exceptions declared
 		// on the ejbCreate, ejbPostCreate methods must be defined in the throws clause of
 		// the matching create of the remote interface.
 		/*
 		// Don't check for the exceptions here - let the bean class do it. When the remote
 		// changes, a "dependent" validation of the bean's checks should be done automatically.
 		// If it is checked in this method as well, there are duplicate messages on the task list.
 		HashSet exceptions = getNotSubsetExceptions(remoteMethod, beanMethod);
 		if(exceptions.size() > 0) {
 			Iterator iterator = exceptions.iterator();
 			while(iterator.hasNext()) {
 				JavaClass exc = (JavaClass)iterator.next();
 				String[] msgParm = {exc.getQualifiedName()};
 				addValidationMessage(IEJBValidationContext.ERROR, IMessagePrefixEjb11Constants.EJB_METHOD_THROW_NOTRI_EXCEP, msgParm, beanMethod, EJB_BEAN_GROUP);
 			}
 		}
 		*/
 	}

 	/**
 	 * Check the remote interface's methods against the EJB 1.1 spec.
 	 *
 	 * 6.10.5 Session bean's remote interface
 	 * ...
 	 *		- The methods defined in this interface must follow the rules for RMI/IIOP.
 	 *        This means that their argument and return values must be of valid types
 	 *        for RMI/IIOP, and their throws clause must include the java.rmi.RemoteException.
 	 * ...
 	 *		- For each method defined in the remote interface, there must be a matching
 	 *        method in the session bean's class.
 	 *			- The matching method must have:
 	 *				- The same name.
 	 *				- The same number and types of arguments, and the same return type.
 	 *				- All the exceptions defined in the throws clause of the matching
 	 *                method of the session bean class must be defined in the throws
 	 *                clause of the method of the remote interface.
 	 * ...
 	 * 9.2.7 Entity bean's remote interface
 	 * ...
 	 * 		- The methods defined in the remote interface must follow the rules for RMI-IIOP.
 	 * 		  This means that their argument and return value types must be valid types for RMI-IIOP,
 	 * 		  and their throws clauses must include the java.rmi.RemoteException.
 	 * ...
 	 * 		- For each method defined in the remote interface, there must be a matching method
 	 *		  in the entity bean's class. The matching method must have:
 	 * 			- The same name.
 	 *			- The same number and types of its arguments, and the same return type.
 	 *			- All the exceptions defined in the throws clause of the matching method
 	 *			  of the enterprise Bean class must be defined in the throws clause of
 	 *			  the method of the remote interface.
 	 * ...
 	 */
 	public void validateMethod_beanDep(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method riMethod) throws InvalidInputException {
 		vc.terminateIfCancelled();
 		// For each method defined in the remote interface, there must be a matching
 		// method in the session bean's class.
 		validateMatchingBeanMethod(vc, bean, clazz, riMethod);
 	}

 	/**
 	 * Final check to see if required methods were detected.
 	 */
 	protected void validateMethodExists(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) throws InvalidInputException {
 		//There are no required methods.
 	}

 	protected void validateAppendixB(IEJBValidationContext vc, EnterpriseBean bean, JavaClass thisRemote) {
 		// The Java inheritance structure must match the EJB inheritance structure.
 		// e.g. if EJB B is a child of EJB A, then class B must be a child of class A.
 		// B could be a grandchild (or great-grandchild or ...) of A.
 		if(bean == null) {
 			return;
 		}
 		EnterpriseBean supertype = getSuperType(bean);
 		JavaClass parentRemote = null;
 		if (supertype != null) {
 			parentRemote = supertype.getRemoteInterface();

 			// Remote a Xchild of parent Remote
 			try {
 				ValidationRuleUtility.isValidType(thisRemote);
 				ValidationRuleUtility.isValidType(parentRemote);
 				if (!ValidationRuleUtility.isAssignableFrom(thisRemote, parentRemote)) {
 					String[] msgParm = new String[] { thisRemote.getQualifiedName(), parentRemote.getQualifiedName()};
 					IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2105, IEJBValidationContext.ERROR, bean, thisRemote, msgParm, this);
 					vc.addMessage(message);
 				}
 			}
 			catch (InvalidInputException e) {
 				String[] msgParm = { e.getJavaClass().getQualifiedName(), bean.getName()};
 				IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2849, IEJBValidationContext.WARNING, bean, msgParm, this);
 				vc.addMessage(message);
 			}
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2001, 2005 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.jst.j2ee.model.internal.validation;

	import java.util.List;

	import org.eclipse.jem.java.JavaClass;
	import org.eclipse.jem.java.JavaHelpers;
	import org.eclipse.jem.java.Method;
	import org.eclipse.jst.j2ee.ejb.EnterpriseBean;
	import org.eclipse.wst.validation.internal.provisional.core.IMessage;


	/**
	* This class checks remote interface classes for errors or potential errors.
	* If any problems are found, an error, warning, or info marker is added to the task list.
	* The checks for a session remote interface and an entity remote interface are the same
	* in EJB 1.1.
	*
	* The following paragraph is taken from
	* Enterprise JavaBeans Specification ("Specification")
	* Version: 1.1
	* Status: Final Release
	* Release: 12/17/99
	* Copyright 1999 Sun Microsystems, Inc.
	* 901 San Antonio Road, Palo Alto, CA 94303, U.S.A.
	* All rights reserved.
	*
	* 6.10.5 Session bean's remote interface
	* The following are the requirements for the session bean's remote interface:
	* - The interface must extend the javax.ejb.EJBObject interface.
	* - The methods defined in this interface must follow the rules for RMI/IIOP.
	* This means that their argument and return values must be of valid types
	* for RMI/IIOP, and their throws clause must include the java.rmi.RemoteException.
	* - The remote interface is allowed to have superinterfaces. Use of interface
	* inheritance is subject to the RMI/IIOP rules for the definition of remote interfaces.
	* - For each method defined in the remote interface, there must be a matching
	* method in the session bean's class.
	* - The matching method must have:
	* - The same name.
	* - The same number and types of arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching
	* method of the session bean class must be defined in the throws
	* clause of the method of the remote interface.
	*
	* 9.2.7 Entity bean's remote interface
	* The following are the requirements for the entity bean's remote interface:
	* - The interface must extend the javax.ejb.EJBObject interface.
	* - The methods defined in the remote interface must follow the rules for RMI-IIOP.
	* This means that their argument and return value types must be valid types for RMI-IIOP,
	* and their throws clauses must include the java.rmi.RemoteException.
	* - The remote interface is allowed to have superinterfaces. Use of interface inheritance
	* is subject to the RMI-IIOP rules for the definition of remote interfaces.
	* - For each method defined in the remote interface, there must be a matching method
	* in the entity bean's class. The matching method must have:
	* - The same name.
	* - The same number and types of its arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching method
	* of the enterprise Bean class must be defined in the throws clause of
	* the method of the remote interface.
	*/
	public abstract class AValidateRemote extends AValidateEJB {
	public final Object getTarget(Object parent, Object clazz) {
	if(parent == null) {
	return null;
	}

	return ((EnterpriseBean)parent).getRemoteInterface();
	}

	public final List[] getMethodsExtended(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) {
	// A home or component class needs the following classes' extended methods:
	// 1. bean class
	List[] result = new List[1];
	JavaClass beanClass = bean.getEjbClass();
	if(beanClass == null) {
	result[0] = null;
	}
	else {
	result[0] = beanClass.getMethodsExtended();
	}
	return result;
	}

	public final List[] getFieldsExtended(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) {
	// Never check that a home or component's field is defined on another class
	// of the bean.
	return null;
	}

	/**
	* Return true if the method can, and should, be validated.
	* Filter out faulty methods (i.e., null), and methods which
	* belong to the base type, whatever that is. (e.g. java.lang.Object)
	*/
	protected boolean isValid(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method, List[] methodsExtendedList) throws InvalidInputException {
	if (super.isValid(vc, bean, clazz, method, methodsExtendedList)) {
	// Exclude root remote interface methods
	if (ValidationRuleUtility.isEJBObjectMethod(bean, method)) {
	return false;
	}
	else if (isEjbRelationshipRoleMethod(vc, bean, clazz, method)) {
	return false;
	}
	else if (ValidationRuleUtility.isClinitMethod(bean, method)) {
	return false;
	}
	else {
	return true;
	}
	}
	return false;
	}

	/**
	* Check the remote interface's methods against the EJB 1.1 spec.
	*
	* 6.10.5 Session bean's remote interface
	* ...
	* - The methods defined in this interface must follow the rules for RMI/IIOP.
	* This means that their argument and return values must be of valid types
	* for RMI/IIOP, and their throws clause must include the java.rmi.RemoteException.
	* ...
	* - For each method defined in the remote interface, there must be a matching
	* method in the session bean's class.
	* - The matching method must have:
	* - The same name.
	* - The same number and types of arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching
	* method of the session bean class must be defined in the throws
	* clause of the method of the remote interface.
	* ...
	* 9.2.7 Entity bean's remote interface
	* ...
	* - The methods defined in the remote interface must follow the rules for RMI-IIOP.
	* This means that their argument and return value types must be valid types for RMI-IIOP,
	* and their throws clauses must include the java.rmi.RemoteException.
	* ...
	* - For each method defined in the remote interface, there must be a matching method
	* in the entity bean's class. The matching method must have:
	* - The same name.
	* - The same number and types of its arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching method
	* of the enterprise Bean class must be defined in the throws clause of
	* the method of the remote interface.
	* ...
	*/
	public void primValidate(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method riMethod) throws InvalidInputException {
	// Can't invoke an abstract method
	// super.validateExistence(riMethod);

	vc.terminateIfCancelled();

	// The methods defined in this interface must follow the rules for RMI/IIOP.
	validateLegalRMIMethod(vc, bean, clazz, riMethod);

	// For each method defined in the remote interface, there must be a matching
	// method in the session bean's class.
	validateMethod_beanDep(vc, bean, clazz, riMethod);

	}

	/**
	* Checks to see if @ejbMethod is one of the required methods.
	*/
	protected void primValidateExistence(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method ejbMethod) throws InvalidInputException {
	// Can't invoke an abstract method
	//super.validateExistence(ejbMethod);

	//There are no required methods.
	}

	/**
	* Check that the remote interface class definition follows the EJB 1.1 spec.
	*
	* The following paragraph is taken from
	* Enterprise JavaBeans Specification ("Specification")
	* Version: 1.1
	* Status: Final Release
	* Release: 12/17/99
	* Copyright 1999 Sun Microsystems, Inc.
	* 901 San Antonio Road, Palo Alto, CA 94303, U.S.A.
	* All rights reserved.
	*
	* 6.10.5 Session bean's remote interface
	* The following are the requirements for the session bean's remote interface:
	* - The interface must extend the javax.ejb.EJBObject interface.
	* ...
	* - The remote interface is allowed to have superinterfaces. Use of interface
	* inheritance is subject to the RMI/IIOP rules for the definition of remote interfaces.
	* ...
	* 9.2.7 Entity bean's remote interface
	* The following are the requirements for the entity bean's remote interface:
	* - The interface must extend the javax.ejb.EJBObject interface.
	* ...
	* - The remote interface is allowed to have superinterfaces. Use of interface inheritance
	* is subject to the RMI-IIOP rules for the definition of remote interfaces.
	* ...
	*/
	public void validateClass(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) throws InvalidInputException {
	vc.terminateIfCancelled();

	// It must be an interface, not a class.
	if (!clazz.isInterface()) {
	IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2012, IEJBValidationContext.ERROR, bean, clazz, this);
	vc.addMessage(message);
	}

	// The interface must extend the javax.ejb.EJBObject interface.
	JavaHelpers javaxEjbObject = ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVAX_EJB_EJBOBJECT, bean);
	if (!ValidationRuleUtility.isAssignableFrom(clazz, javaxEjbObject)) {
	String[] msgParm = { ITypeConstants.CLASSNAME_JAVAX_EJB_EJBOBJECT };
	IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2017, IEJBValidationContext.ERROR, bean, clazz, msgParm, this);
	vc.addMessage(message);
	}

	if (ValidationRuleUtility.isUnnamedPackage(clazz.getJavaPackage())) {
	IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2041, IEJBValidationContext.INFO, bean, clazz, this);
	vc.addMessage(message);
	}

	validateAppendixB(vc, bean, clazz);
	}

	/**
	* 6.10.5
	* For each method defined in the remote interface, there must be a matching
	* method in the session bean's class. The matching method must have:
	* - The same name.
	* - The same number and types of arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching method
	* of the session bean class must be defined in the throws clause of the
	* method of the remote interface.
	*
	* 9.2.7
	* For each method defined in the remote interface, there must be a matching
	* method in the entity bean's class. The matching method must have:
	* - The same name.
	* - The same number and types of its arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching method
	* of the enterprise Bean class must be defined in the throws clause of
	* the method of the remote interface.
	*/
	public void validateMatchingBeanMethod(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method remoteMethod) throws InvalidInputException {
	vc.terminateIfCancelled();
	if (remoteMethod == null) {
	return;
	}

	JavaClass beanClass = bean.getEjbClass();
	ValidationRuleUtility.isValidTypeHierarchy(bean, beanClass);

	Method beanMethod = ValidationRuleUtility.getMethodExtended(beanClass, remoteMethod, remoteMethod.getName());
	if (beanMethod == null) {
	String[] msgParm = { beanClass.getName()};
	IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2023, IEJBValidationContext.ERROR, bean, clazz, remoteMethod, msgParm, this);
	vc.addMessage(message);
	return;
	}

	ValidationRuleUtility.isValidType(ValidationRuleUtility.getType(remoteMethod.getReturnType()));

	try {
	ValidationRuleUtility.isValidType(ValidationRuleUtility.getType(beanMethod.getReturnType()));
	}
	catch (InvalidInputException e) {
	// Let the validation of the bean class report the reflection warning.
	// Don't do any validation based on that method.
	return;
	}

	// Check if return types match
	vc.terminateIfCancelled();
	if (!ValidationRuleUtility.isAssignableFrom(remoteMethod.getReturnType(), beanMethod.getReturnType())) {
	IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2415, IEJBValidationContext.ERROR, bean, clazz, remoteMethod, new String[] { beanMethod.getReturnType().getJavaName(), beanClass.getName()}, this);
	vc.addMessage(message);
	}


	// Section 6.10.5 (session), 9.2.7 (entity), declare that all exceptions declared
	// on the ejbCreate, ejbPostCreate methods must be defined in the throws clause of
	// the matching create of the remote interface.
	/*
	// Don't check for the exceptions here - let the bean class do it. When the remote
	// changes, a "dependent" validation of the bean's checks should be done automatically.
	// If it is checked in this method as well, there are duplicate messages on the task list.
	HashSet exceptions = getNotSubsetExceptions(remoteMethod, beanMethod);
	if(exceptions.size() > 0) {
	Iterator iterator = exceptions.iterator();
	while(iterator.hasNext()) {
	JavaClass exc = (JavaClass)iterator.next();
	String[] msgParm = {exc.getQualifiedName()};
	addValidationMessage(IEJBValidationContext.ERROR, IMessagePrefixEjb11Constants.EJB_METHOD_THROW_NOTRI_EXCEP, msgParm, beanMethod, EJB_BEAN_GROUP);
	}
	}
	*/
	}

	/**
	* Check the remote interface's methods against the EJB 1.1 spec.
	*
	* 6.10.5 Session bean's remote interface
	* ...
	* - The methods defined in this interface must follow the rules for RMI/IIOP.
	* This means that their argument and return values must be of valid types
	* for RMI/IIOP, and their throws clause must include the java.rmi.RemoteException.
	* ...
	* - For each method defined in the remote interface, there must be a matching
	* method in the session bean's class.
	* - The matching method must have:
	* - The same name.
	* - The same number and types of arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching
	* method of the session bean class must be defined in the throws
	* clause of the method of the remote interface.
	* ...
	* 9.2.7 Entity bean's remote interface
	* ...
	* - The methods defined in the remote interface must follow the rules for RMI-IIOP.
	* This means that their argument and return value types must be valid types for RMI-IIOP,
	* and their throws clauses must include the java.rmi.RemoteException.
	* ...
	* - For each method defined in the remote interface, there must be a matching method
	* in the entity bean's class. The matching method must have:
	* - The same name.
	* - The same number and types of its arguments, and the same return type.
	* - All the exceptions defined in the throws clause of the matching method
	* of the enterprise Bean class must be defined in the throws clause of
	* the method of the remote interface.
	* ...
	*/
	public void validateMethod_beanDep(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method riMethod) throws InvalidInputException {
	vc.terminateIfCancelled();
	// For each method defined in the remote interface, there must be a matching
	// method in the session bean's class.
	validateMatchingBeanMethod(vc, bean, clazz, riMethod);
	}

	/**
	* Final check to see if required methods were detected.
	*/
	protected void validateMethodExists(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) throws InvalidInputException {
	//There are no required methods.
	}

	protected void validateAppendixB(IEJBValidationContext vc, EnterpriseBean bean, JavaClass thisRemote) {
	// The Java inheritance structure must match the EJB inheritance structure.
	// e.g. if EJB B is a child of EJB A, then class B must be a child of class A.
	// B could be a grandchild (or great-grandchild or ...) of A.
	if(bean == null) {
	return;
	}
	EnterpriseBean supertype = getSuperType(bean);
	JavaClass parentRemote = null;
	if (supertype != null) {
	parentRemote = supertype.getRemoteInterface();

	// Remote a Xchild of parent Remote
	try {
	ValidationRuleUtility.isValidType(thisRemote);
	ValidationRuleUtility.isValidType(parentRemote);
	if (!ValidationRuleUtility.isAssignableFrom(thisRemote, parentRemote)) {
	String[] msgParm = new String[] { thisRemote.getQualifiedName(), parentRemote.getQualifiedName()};
	IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2105, IEJBValidationContext.ERROR, bean, thisRemote, msgParm, this);
	vc.addMessage(message);
	}
	}
	catch (InvalidInputException e) {
	String[] msgParm = { e.getJavaClass().getQualifiedName(), bean.getName()};
	IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2849, IEJBValidationContext.WARNING, bean, msgParm, this);
	vc.addMessage(message);
	}
	}
	}
	}