KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > hivemind > service > MethodSignature


1 // Copyright 2004, 2005 The Apache Software Foundation
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 package org.apache.hivemind.service;
16
17 import java.lang.reflect.Method JavaDoc;
18
19 /**
20  * A representation of a {@link java.lang.reflect.Method}, identifying the name, return type,
21  * parameter types and exception types. Actual Method objects are tied to a particular class, and
22  * don't compare well with other otherwise identical Methods from other classes or interface;
23  * MethodSignatures are distinct from classes and compare well.
24  * <p>
25  * Because the intended purpose is to compare methods from interfaces (which are always public and
26  * abstract) we don't bother to actually track the modifiers. In addition, at this time,
27  * MethodSignature <em>does not distinguish between instance and static
28  * methods</em>.
29  *
30  * @author Howard Lewis Ship
31  */
32 public class MethodSignature
33 {
34     private int _hashCode = -1;
35
36     private Class JavaDoc _returnType;
37
38     private String JavaDoc _name;
39
40     private Class JavaDoc[] _parameterTypes;
41
42     private Class JavaDoc[] _exceptionTypes;
43
44     public MethodSignature(Class JavaDoc returnType, String JavaDoc name, Class JavaDoc[] parameterTypes,
45             Class JavaDoc[] exceptionTypes)
46     {
47         _returnType = returnType;
48         _name = name;
49         _parameterTypes = parameterTypes;
50         _exceptionTypes = exceptionTypes;
51     }
52
53     public MethodSignature(Method JavaDoc m)
54     {
55         this(m.getReturnType(), m.getName(), m.getParameterTypes(), m.getExceptionTypes());
56     }
57
58     /**
59      * Returns the exceptions for this method. Caution: do not modify the returned array. May return
60      * null.
61      */
62     public Class JavaDoc[] getExceptionTypes()
63     {
64         return _exceptionTypes;
65     }
66
67     public String JavaDoc getName()
68     {
69         return _name;
70     }
71
72     /**
73      * Returns the parameter types for this method. May return null. Caution: do not modify the
74      * returned array.
75      */
76     public Class JavaDoc[] getParameterTypes()
77     {
78         return _parameterTypes;
79     }
80
81     public Class JavaDoc getReturnType()
82     {
83         return _returnType;
84     }
85
86     public int hashCode()
87     {
88         if (_hashCode == -1)
89         {
90
91             _hashCode = _returnType.hashCode();
92
93             _hashCode = 31 * _hashCode + _name.hashCode();
94
95             int count = count(_parameterTypes);
96
97             for (int i = 0; i < count; i++)
98                 _hashCode = 31 * _hashCode + _parameterTypes[i].hashCode();
99
100             count = count(_exceptionTypes);
101
102             for (int i = 0; i < count; i++)
103                 _hashCode = 31 * _hashCode + _exceptionTypes[i].hashCode();
104         }
105
106         return _hashCode;
107     }
108
109     private static int count(Object JavaDoc[] array)
110     {
111         return array == null ? 0 : array.length;
112     }
113
114     /**
115      * Returns true if the other object is an instance of MethodSignature with identical values for
116      * return type, name, parameter types and exception types.
117      */
118     public boolean equals(Object JavaDoc o)
119     {
120         if (o == null || !(o instanceof MethodSignature))
121             return false;
122
123         MethodSignature ms = (MethodSignature) o;
124
125         if (_returnType != ms._returnType)
126             return false;
127
128         if (!_name.equals(ms._name))
129             return false;
130
131         if (mismatch(_parameterTypes, ms._parameterTypes))
132             return false;
133
134         return !mismatch(_exceptionTypes, ms._exceptionTypes);
135     }
136
137     private boolean mismatch(Class JavaDoc[] a1, Class JavaDoc[] a2)
138     {
139         int a1Count = count(a1);
140         int a2Count = count(a2);
141
142         if (a1Count != a2Count)
143             return true;
144
145         // Hm. What if order is important (for exceptions)? We're really saying here that they
146 // were derived from the name Method.
147
148         for (int i = 0; i < a1Count; i++)
149         {
150             if (a1[i] != a2[i])
151                 return true;
152         }
153
154         return false;
155     }
156
157     public String JavaDoc toString()
158     {
159         StringBuffer JavaDoc buffer = new StringBuffer JavaDoc();
160
161         buffer.append(ClassFabUtils.getJavaClassName(_returnType));
162         buffer.append(" ");
163         buffer.append(_name);
164         buffer.append("(");
165
166         for (int i = 0; i < count(_parameterTypes); i++)
167         {
168             if (i > 0)
169                 buffer.append(", ");
170
171             buffer.append(ClassFabUtils.getJavaClassName(_parameterTypes[i]));
172         }
173
174         buffer.append(")");
175
176         for (int i = 0; i < count(_exceptionTypes); i++)
177         {
178             if (i == 0)
179                 buffer.append(" throws ");
180             else
181                 buffer.append(", ");
182
183             buffer.append(_exceptionTypes[i].getName());
184         }
185
186         return buffer.toString();
187     }
188
189     /**
190      * Returns a string consisting of the name of the method and its parameter values. This is
191      * similar to {@link #toString()}, but omits the return type and information about thrown
192      * exceptions. A unique id is used by {@link MethodIterator} to identify overlapping methods
193      * (methods with the same name but different thrown exceptions).
194      *
195      * @since 1.1
196      */
197     public String JavaDoc getUniqueId()
198     {
199         StringBuffer JavaDoc buffer = new StringBuffer JavaDoc(_name);
200         buffer.append("(");
201
202         for (int i = 0; i < count(_parameterTypes); i++)
203         {
204             if (i > 0)
205                 buffer.append(",");
206
207             buffer.append(ClassFabUtils.getJavaClassName(_parameterTypes[i]));
208         }
209
210         buffer.append(")");
211
212         return buffer.toString();
213     }
214
215     /**
216      * Returns true if this signature has the same return type, name and parameters types as the
217      * method signature passed in, and this signatures exceptions "trump" (are the same as, or
218      * super-implementations of, all exceptions thrown by the other method signature).
219      *
220      * @since 1.1
221      */
222
223     public boolean isOverridingSignatureOf(MethodSignature ms)
224     {
225         if (_returnType != ms._returnType)
226             return false;
227
228         if (!_name.equals(ms._name))
229             return false;
230
231         if (mismatch(_parameterTypes, ms._parameterTypes))
232             return false;
233
234         return exceptionsEncompass(ms._exceptionTypes);
235     }
236
237     /**
238      * The nuts and bolts of checking that another method signature's exceptions are a subset of
239      * this signature's.
240      *
241      * @since 1.1
242      */
243
244     private boolean exceptionsEncompass(Class JavaDoc[] otherExceptions)
245     {
246         int ourCount = count(_exceptionTypes);
247         int otherCount = count(otherExceptions);
248
249         // If we have no exceptions, then ours encompass theirs only if they
250 // have no exceptions, either.
251
252         if (ourCount == 0)
253             return otherCount == 0;
254
255         boolean[] matched = new boolean[otherCount];
256         int unmatched = otherCount;
257
258         for (int i = 0; i < ourCount && unmatched > 0; i++)
259         {
260             for (int j = 0; j < otherCount; j++)
261             {
262                 // Ignore exceptions that have already been matched
263
264                 if (matched[j])
265                     continue;
266
267                 // When one of our exceptions is a super-class of one of their exceptions,
268 // then their exceptions is matched.
269
270                 if (_exceptionTypes[i].isAssignableFrom(otherExceptions[j]))
271                 {
272                     matched[j] = true;
273                     unmatched--;
274                 }
275             }
276         }
277
278         return unmatched == 0;
279     }
280 }
Popular Tags