/*******************************************************************************
* 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
*******************************************************************************/
package org.eclipse.jst.j2ee.ejb;
import org.eclipse.emf.common.util.EList;
import org.eclipse.jem.java.JavaClass;
import org.eclipse.jem.java.Method;
import org.eclipse.jst.j2ee.common.J2EEEObject;
/**
* The method element is used to denote a method of an enterprise bean's
* home or remote interface, or a set of methods. The ejb-name element
* must be the name of one of the enterprise beans in declared in the
* deployment descriptor; the optional method-intf element allows to
* distinguish between a method with the same signature that is defined in
* both the home and remote interface; the method-name element specifies
* the method name; and the optional method-params elements identify a
* single method among multiple methods with an overloaded method name.
*
* There are three possible styles of the method element syntax:
*
* 1. <method>
* <ejb-name>EJBNAME<//ejb-name>
* <method-name>*<//method-name>
* <//method>
*
* This style is used to refer to all the methods of the specified
* enterprise bean's home and remote interfaces.
*
* 2. <method>
* <ejb-name>EJBNAME<//ejb-name>
* <method-name>METHOD<//method-name>
* <//method>>
*
* This style is used to refer to the specified method of the
* specified enterprise bean. If there are multiple methods with
* the same overloaded name, the element of this style refers to
* all the methods with the overloaded name.
*
*
*
*
*
* 3. <method>
* <ejb-name>EJBNAME<//ejb-name>
* <method-name>METHOD<//method-name>
* <method-params>
* <method-param>PARAM-1<//method-param>
* <method-param>PARAM-2<//method-param>
* ...
* <method-param>PARAM-n<//method-param>
* <//method-params>
* <method>
*
* This style is used to refer to a single method within a set of
* methods with an overloaded name. PARAM-1 through PARAM-n are the
* fully-qualified Java types of the method's input parameters (if
* the method has no input arguments, the method-params element
* contains no method-param elements). Arrays are specified by the
* array element's type, followed by one or more pair of square
* brackets (e.g. int[][]).
*
*
* Used in: method-permission and container-transaction
*
* Examples:
*
* Style 1: The following method element refers to all the methods of
* the EmployeeService bean's home and remote interfaces:
*
* <method>
* <ejb-name>EmployeeService<//ejb-name>
* <method-name>*<//method-name>
* <//method>
*
* Style 2: The following method element refers to all the create
* methods of the EmployeeService bean's home interface:
*
* <method>
* <ejb-name>EmployeeService<//ejb-name>
* <method-name>create<//method-name>
* <//method>
*
* Style 3: The following method element refers to the
* create(String firstName, String LastName) method of the
* EmployeeService bean's home interface.
*
* <method>
* <ejb-name>EmployeeService<//ejb-name>
* <method-name>create<//method-name>
* <method-params>
* <method-param>java.lang.String<//method-param>
* <method-param>java.lang.String<//method-param>
* <//method-params>
* <//method>
*
*
* The following example illustrates a Style 3 element with
* more complex parameter types. The method
* foobar(char s, int i, int[] iar, mypackage.MyClass mycl,
* mypackage.MyClass[][] myclaar)
* would be specified as:
*
* <method>
* <ejb-name>EmployeeService<//ejb-name>
* <method-name>foobar<//method-name>
* <method-params>
* <method-param>char<//method-param>
* <method-param>int<//method-param>
* <method-param>int[]<//method-param>
* <method-param>mypackage.MyClass<//method-param>
* <method-param>mypackage.MyClass[][]<//method-param>
* <//method-params>
* <//method>
*
* The optional method-intf element can be used when it becomes
* necessary to differentiate between a method defined in the home
* interface and a method with the same name and signature that is
* defined in the remote interface.
*
* For example, the method element
*
* <method>
* <ejb-name>EmployeeService<//ejb-name>
* <method-intf>Remote<//method-intf>
* <method-name>create<//method-name>
* <method-params>
* <method-param>java.lang.String<//method-param>
* <method-param>java.lang.String<//method-param>
* <//method-params>
* <//method>
*
* can be used to differentiate the create(String, String) method
* defined in the remote interface from the create(String, String)
* method defined in the home interface, which would be defined as
*
* <method>
* <ejb-name>EmployeeService<//ejb-name>
* <method-intf>Home<//method-intf>
* <method-name>create<//method-name>
* <method-params>
* <method-param>java.lang.String<//method-param>
* <method-param>java.lang.String<//method-param>
* <//method-params>
* <//method>
* @generated
* @since 1.0 */
public interface MethodElement extends J2EEEObject {
public static final String RIGHT_PAREN = "("; //$NON-NLS-1$
public static final String LEFT_PAREN = ")"; //$NON-NLS-1$
public static final String COMMA = ","; //$NON-NLS-1$
public void addMethodParams(String param);
/**
* Set the params for this method element to an empty array, as opposed
* to null.
*/
public void applyZeroParams();
/**
* Return true if this MethodElement and @anotherMethodElement
* have the same name, parameters, and type.
*/
boolean equalSignature(MethodElement anotherMethodElement) ;
java.util.List getMethodParams() ;/**
* Answer whether method params apply to this method, e.g., it is specific to one
* overloaded method, even if the method is a zero parameter method. Answer false if no
* parameters apply, that is, the method element applies to all overloaded methods with this name
*/
/**
* Answer a list of all the methods for which this method element applies. The following rules are used:
*
* 1) If the method element type is unspecified, the methods are obtained from the remote interface of the ejb;
* If it is specified, then the appropriate interface is used
*
* 2) If the method name = "*", then all the PUBLIC methods for that interface are returned
*
* 3) If the method name is specified, and no method params are specified, then all public methods for the interface
* having the same name are returned.
*
* 4) If the method name and params are specified, then a zero or one element array is returned, containing the one and only method
* on the interface with the appropriate signature, if it exists
*/
public Method[] getMethods();
/**
* Return the MethodElement that is most specific.
*/
MethodElement getMostSpecific(MethodElement aMethodElement, JavaClass aJavaClass);
/**
* Return the signature.
* For example: setTwoParamMethod(java.lang.String, java.lang.String)
*/
String getSignature() ;
/**
* Return the type cast to a JavaClass.
*/
JavaClass getTypeJavaClass() ;
public boolean hasMethodParams();
/**
* Parse @aSignature setting the name and the params.
* A signature example: setTwoParamMethod(java.lang.String, java.lang.String)
*/
void initializeFromSignature(String aSignature) ;
boolean isDefault();
/**
* Return true if this MethodElement and @anotherMethodElement
* represent the same exact methods.
*/
boolean isEquivalent(MethodElement anotherMethodElement) ;
boolean isHome() ;
boolean isRemote() ;
boolean isUnspecified() ;
boolean isLocalHome() ;
boolean isLocal() ;
boolean isService();
/**
* Return true if this MethodElement represents one or more
* methods.
*/
public boolean isValid() ;
/**
* Return true if this MethodElement has the same basic signature as
* @aMethod, ignoring the return type, thrown exceptions, and declaring class of
* this instance or @aMethod. Return false, if params is null
*/
public boolean nameAndParamsEquals(Method aMethod);
public void removeMethodParams(String param);
boolean represents(Method aMethod);
public void setIdToReadableString();
/**
* Return true if this MethodElement uniquely identifies
* @aMethod. Return false, even if the MethodElement represents
* @aMethod (i.e., @aMethod is contained in its list of methods).
*/
boolean uniquelyIdentifies(Method aMethod);
/**
* @generated This field/method will be replaced during code generation
* @return The value of the Name attribute
* The method-name element contains a name of an enterprise bean method,
* or the asterisk (*) character. The asterisk is used when the element
* denotes all the methods of an enterprise bean's remote and home
* interfaces.
*/
String getName();
/**
* @generated This field/method will be replaced during code generation
* @param value The new value of the Name attribute
*/
void setName(String value);
/**
* @generated This field/method will be replaced during code generation
* @return The value of the Parms attribute
* The method-params element contains a list of the fully-qualified Java type
* names of the method parameters. In the current implementation this is a space
* delimitted String. A null string indicates a generic method element that can
* apply to multiple methods with the same name. An empty string indicates a
* method with zero parameters.
*/
String getParms();
/**
* @generated This field/method will be replaced during code generation
* @param value The new value of the Parms attribute
*/
void setParms(String value);
/**
* @generated This field/method will be replaced during code generation
* @return The value of the Type attribute
*/
MethodElementKind getType();
/**
* Sets the value of the '{@link org.eclipse.jst.j2ee.ejb.MethodElement#getType <em>Type</em>}' attribute.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @param value the new value of the '<em>Type</em>' attribute.
* @see org.eclipse.jst.j2ee.ejb.MethodElementKind
* @see #isSetType()
* @see #unsetType()
* @see #getType()
* @generated
*/
void setType(MethodElementKind value);
/**
* Unsets the value of the '{@link org.eclipse.jst.j2ee.ejb.MethodElement#getType <em>Type</em>}' attribute.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #isSetType()
* @see #getType()
* @see #setType(MethodElementKind)
* @generated
*/
void unsetType();
/**
* Returns whether the value of the '{@link org.eclipse.jst.j2ee.ejb.MethodElement#getType <em>Type</em>}' attribute is set.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @return whether the value of the '<em>Type</em>' attribute is set.
* @see #unsetType()
* @see #getType()
* @see #setType(MethodElementKind)
* @generated
*/
boolean isSetType();
/**
* @generated This field/method will be replaced during code generation
* @return The value of the Description attribute
* The description element is used by the ejb-jar file producer to provide text
* describing the parent element. The description element should include any
* information that the ejb-jar file producer wants to provide to the consumer of
* the ejb-jar file (i.e. to the Deployer). Typically, the tools used by the
* ejb-jar file consumer will display the description when processing the parent
* element.
*/
String getDescription();
/**
* @generated This field/method will be replaced during code generation
* @param value The new value of the Description attribute
*/
void setDescription(String value);
/**
* @generated This field/method will be replaced during code generation
* @return The EnterpriseBean reference
*/
EnterpriseBean getEnterpriseBean();
/**
* @generated This field/method will be replaced during code generation
* @param l The new value of the EnterpriseBean reference
*/
void setEnterpriseBean(EnterpriseBean value);
/**
* Returns the value of the '<em><b>Descriptions</b></em>' containment reference list.
* The list contents are of type {@link org.eclipse.jst.j2ee.common.Description}.
* <!-- begin-user-doc -->
* <p>
* If the meaning of the '<em>Descriptions</em>' containment reference list isn't clear,
* there really should be more of a description here...
* </p>
* <!-- end-user-doc -->
* @return the value of the '<em>Descriptions</em>' containment reference list.
* @see org.eclipse.jst.j2ee.ejb.EjbPackage#getMethodElement_Descriptions()
* @model type="org.eclipse.jst.j2ee.common.Description" containment="true"
* @generated
*/
EList getDescriptions();
}