| package jdiff; |
| |
| import java.io.*; |
| import java.util.*; |
| |
| /** |
| * Class to represent a method, analogous to MethodDoc in the |
| * Javadoc doclet API. |
| * |
| * The method used for Collection comparison (compareTo) must make its |
| * comparison based upon everything that is known about this method. |
| * |
| * See the file LICENSE.txt for copyright details. |
| * @author Matthew Doar, mdoar@pobox.com |
| */ |
| class MethodAPI implements Comparable { |
| |
| /** Name of the method. */ |
| public String name_ = null; |
| |
| /** Return type of the method. */ |
| public String returnType_ = null; |
| |
| /** |
| * The fully qualified name of the class or interface this method is |
| * inherited from. If this is null, then the method is defined locally |
| * in this class or interface. |
| */ |
| public String inheritedFrom_ = null; |
| |
| /** |
| * The exceptions thrown by this method, being all the exception types |
| * separated by commas. "no exceptions" if no exceptions are thrown. |
| */ |
| public String exceptions_ = "no exceptions"; |
| |
| /** Set if this method is abstract. */ |
| public boolean isAbstract_ = false; |
| |
| /** Set if this method is native. */ |
| public boolean isNative_ = false; |
| |
| /** Set if this method is synchronized. */ |
| public boolean isSynchronized_ = false; |
| |
| /** Modifiers for this class. */ |
| public Modifiers modifiers_; |
| |
| public List params_; // ParamAPI[] |
| |
| /** The doc block, default is null. */ |
| public String doc_ = null; |
| |
| /** Constructor. */ |
| public MethodAPI(String name, String returnType, boolean isAbstract, |
| boolean isNative, boolean isSynchronized, |
| Modifiers modifiers) { |
| name_ = name; |
| returnType_ = returnType; |
| isAbstract_ = isAbstract; |
| isNative_ = isNative; |
| isSynchronized_ = isSynchronized; |
| modifiers_ = modifiers; |
| params_ = new ArrayList(); // ParamAPI[] |
| } |
| |
| /** Copy constructor. */ |
| public MethodAPI(MethodAPI m) { |
| name_ = m.name_; |
| returnType_ = m.returnType_; |
| inheritedFrom_ = m.inheritedFrom_; |
| exceptions_ = m.exceptions_; |
| isAbstract_ = m.isAbstract_; |
| isNative_ = m.isNative_; |
| isSynchronized_ = m.isSynchronized_; |
| modifiers_ = m.modifiers_; // Note: shallow copy |
| params_ = m.params_; // Note: shallow copy |
| doc_ = m.doc_; |
| signature_ = m.signature_; // Cached |
| } |
| |
| /** |
| * Compare two methods, including the return type, and parameter |
| * names and types, and modifiers. |
| */ |
| public int compareTo(Object o) { |
| MethodAPI oMethod = (MethodAPI)o; |
| int comp = name_.compareTo(oMethod.name_); |
| if (comp != 0) |
| return comp; |
| comp = returnType_.compareTo(oMethod.returnType_); |
| if (comp != 0) |
| return comp; |
| if (APIComparator.changedInheritance(inheritedFrom_, oMethod.inheritedFrom_) != 0) |
| return -1; |
| if (isAbstract_ != oMethod.isAbstract_) { |
| return -1; |
| } |
| if (Diff.showAllChanges && |
| isNative_ != oMethod.isNative_) { |
| return -1; |
| } |
| if (Diff.showAllChanges && |
| isSynchronized_ != oMethod.isSynchronized_) { |
| return -1; |
| } |
| comp = exceptions_.compareTo(oMethod.exceptions_); |
| if (comp != 0) |
| return comp; |
| comp = modifiers_.compareTo(oMethod.modifiers_); |
| if (comp != 0) |
| return comp; |
| comp = getSignature().compareTo(oMethod.getSignature()); |
| if (comp != 0) |
| return comp; |
| if (APIComparator.docChanged(doc_, oMethod.doc_)) |
| return -1; |
| return 0; |
| } |
| |
| /** |
| * Tests two methods, using just the method name, used by indexOf(). |
| */ |
| public boolean equals(Object o) { |
| if (name_.compareTo(((MethodAPI)o).name_) == 0) |
| return true; |
| return false; |
| } |
| |
| /** |
| * Tests two methods for equality, using just the signature. |
| */ |
| public boolean equalSignatures(Object o) { |
| if (getSignature().compareTo(((MethodAPI)o).getSignature()) == 0) |
| return true; |
| return false; |
| } |
| |
| /** Cached result of getSignature(). */ |
| private String signature_ = null; |
| |
| /** Return the signature of the method. */ |
| public String getSignature() { |
| if (signature_ != null) |
| return signature_; |
| String res = ""; |
| boolean first = true; |
| Iterator iter = params_.iterator(); |
| while (iter.hasNext()) { |
| if (!first) |
| res += ", "; |
| ParamAPI param = (ParamAPI)(iter.next()); |
| res += param.toString(); |
| first = false; |
| } |
| signature_ = res; |
| return res; |
| } |
| } |