gdaniels 2003/01/01 09:45:52
Modified: java/src/org/apache/axis/description ServiceDesc.java
Log:
Fix bugs:
http://nagoya.apache.org/bugzilla/show_bug.cgi?id=13146
http://nagoya.apache.org/bugzilla/show_bug.cgi?id=11766
Be more careful about matching overloaded methods with operations.
Now if we find a method which works, but only by using conversion,
we continue scanning to try and find a better match. This seems to
clear up the overloaded WSDL generation problems that James Black
was seeing, and since we only need to do it once, the performance hit
won't be very noticeable.
Revision Changes Path
1.70 +40 -17 xml-axis/java/src/org/apache/axis/description/ServiceDesc.java
Index: ServiceDesc.java
===================================================================
RCS file: /home/cvs/xml-axis/java/src/org/apache/axis/description/ServiceDesc.java,v
retrieving revision 1.69
retrieving revision 1.70
diff -u -r1.69 -r1.70
--- ServiceDesc.java 11 Dec 2002 22:38:13 -0000 1.69
+++ ServiceDesc.java 1 Jan 2003 17:45:52 -0000 1.70
@@ -597,11 +597,16 @@
return;
// Find the method. We do this once for each Operation.
+
Method [] methods = implClass.getDeclaredMethods();
+ // A place to keep track of possible matches
+ Method possibleMatch = null;
+
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (Modifier.isPublic(method.getModifiers()) &&
- method.getName().equals(oper.getName())) {
+ method.getName().equals(oper.getName()) &&
+ method2OperationMap.get(method) == null) {
if (style == Style.MESSAGE) {
int messageOperType = checkMessageMethod(method);
@@ -618,23 +623,24 @@
continue;
int j;
+ boolean conversionNecessary = false;
for (j = 0; j < paramTypes.length; j++) {
Class type = paramTypes[j];
- Class heldType = type;
+ Class actualType = type;
if (Holder.class.isAssignableFrom(type)) {
- heldType = JavaUtils.getHolderValueType(type);
+ actualType = JavaUtils.getHolderValueType(type);
}
ParameterDesc param = oper.getParameter(j);
QName typeQName = param.getTypeQName();
if (typeQName == null) {
// No typeQName is available. Set it using
- // information from the held type.
+ // information from the actual type.
// (Scenarios B and D)
// There is no need to try and match with
// the Method parameter javaType because
// the ParameterDesc is being constructed
// by introspecting the Method.
- typeQName = tm.getTypeQName(heldType);
+ typeQName = tm.getTypeQName(actualType);
param.setTypeQName(typeQName);
} else {
// A type qname is available.
@@ -655,9 +661,14 @@
// This is a match if the paramClass is somehow
// convertable to the "real" parameter type. If not,
// break out of this loop.
- if (!JavaUtils.isConvertable(paramClass, heldType)) {
+ if (!JavaUtils.isConvertable(paramClass, actualType)) {
break;
}
+
+ if (!actualType.isAssignableFrom(paramClass)) {
+ // This doesn't fit without conversion
+ conversionNecessary = true;
+ }
}
// In all scenarios the ParameterDesc javaType is set to
// match the javaType in the corresponding parameter.
@@ -669,20 +680,32 @@
// failed.
continue;
}
+
+ // This is our latest possibility
+ possibleMatch = method;
- oper.setReturnClass(method.getReturnType());
+ // If this is exactly it, stop now. Otherwise keep looking
+ // just in case we find a better match.
+ if (!conversionNecessary) {
+ break;
+ }
- // Do the faults
- createFaultMetadata(method, oper);
-
- // At some point we might want to check here to see if this
- // Method is already associated with another Operation, but
- // this doesn't seem critital.
-
- oper.setMethod(method);
- method2OperationMap.put(method, oper);
- return;
}
+ }
+
+ // At this point, we may or may not have a possible match.
+ // FIXME : Should we prefer an exact match from a base class over
+ // a with-conversion match from the target class? If so,
+ // we'll need to change the logic below.
+ if (possibleMatch != null) {
+ oper.setReturnClass(possibleMatch.getReturnType());
+
+ // Do the faults
+ createFaultMetadata(possibleMatch, oper);
+
+ oper.setMethod(possibleMatch);
+ method2OperationMap.put(possibleMatch, oper);
+ return;
}
// Didn't find a match. Try the superclass, if appropriate
