1 package jdiff; 2 3 import java.io.*; 4 import java.util.*; 5 6 /** 7 * Class to represent a method, analogous to MethodDoc in the 8 * Javadoc doclet API. 9 * 10 * The method used for Collection comparison (compareTo) must make its 11 * comparison based upon everything that is known about this method. 12 * 13 * See the file LICENSE.txt for copyright details. 14 * @author Matthew Doar, mdoar@pobox.com 15 */ 16 class MethodAPI implements Comparable { 17 18 /** Name of the method. */ 19 public String name_ = null; 20 21 /** Return type of the method. */ 22 public String returnType_ = null; 23 24 /** 25 * The fully qualified name of the class or interface this method is 26 * inherited from. If this is null, then the method is defined locally 27 * in this class or interface. 28 */ 29 public String inheritedFrom_ = null; 30 31 /** 32 * The exceptions thrown by this method, being all the exception types 33 * separated by commas. "no exceptions" if no exceptions are thrown. 34 */ 35 public String exceptions_ = "no exceptions"; 36 37 /** Set if this method is abstract. */ 38 public boolean isAbstract_ = false; 39 40 /** Set if this method is native. */ 41 public boolean isNative_ = false; 42 43 /** Set if this method is synchronized. */ 44 public boolean isSynchronized_ = false; 45 46 /** Modifiers for this class. */ 47 public Modifiers modifiers_; 48 49 public List params_; // ParamAPI[] 50 51 /** The doc block, default is null. */ 52 public String doc_ = null; 53 54 /** Constructor. */ MethodAPI(String name, String returnType, boolean isAbstract, boolean isNative, boolean isSynchronized, Modifiers modifiers)55 public MethodAPI(String name, String returnType, boolean isAbstract, 56 boolean isNative, boolean isSynchronized, 57 Modifiers modifiers) { 58 name_ = name; 59 returnType_ = returnType; 60 isAbstract_ = isAbstract; 61 isNative_ = isNative; 62 isSynchronized_ = isSynchronized; 63 modifiers_ = modifiers; 64 params_ = new ArrayList(); // ParamAPI[] 65 } 66 67 /** Copy constructor. */ MethodAPI(MethodAPI m)68 public MethodAPI(MethodAPI m) { 69 name_ = m.name_; 70 returnType_ = m.returnType_; 71 inheritedFrom_ = m.inheritedFrom_; 72 exceptions_ = m.exceptions_; 73 isAbstract_ = m.isAbstract_; 74 isNative_ = m.isNative_; 75 isSynchronized_ = m.isSynchronized_; 76 modifiers_ = m.modifiers_; // Note: shallow copy 77 params_ = m.params_; // Note: shallow copy 78 doc_ = m.doc_; 79 signature_ = m.signature_; // Cached 80 } 81 82 /** 83 * Compare two methods, including the return type, and parameter 84 * names and types, and modifiers. 85 */ compareTo(Object o)86 public int compareTo(Object o) { 87 MethodAPI oMethod = (MethodAPI)o; 88 int comp = name_.compareTo(oMethod.name_); 89 if (comp != 0) 90 return comp; 91 comp = returnType_.compareTo(oMethod.returnType_); 92 if (comp != 0) 93 return comp; 94 if (APIComparator.changedInheritance(inheritedFrom_, oMethod.inheritedFrom_) != 0) 95 return -1; 96 if (isAbstract_ != oMethod.isAbstract_) { 97 return -1; 98 } 99 if (Diff.showAllChanges && 100 isNative_ != oMethod.isNative_) { 101 return -1; 102 } 103 if (Diff.showAllChanges && 104 isSynchronized_ != oMethod.isSynchronized_) { 105 return -1; 106 } 107 comp = exceptions_.compareTo(oMethod.exceptions_); 108 if (comp != 0) 109 return comp; 110 comp = modifiers_.compareTo(oMethod.modifiers_); 111 if (comp != 0) 112 return comp; 113 comp = getSignature().compareTo(oMethod.getSignature()); 114 if (comp != 0) 115 return comp; 116 if (APIComparator.docChanged(doc_, oMethod.doc_)) 117 return -1; 118 return 0; 119 } 120 121 /** 122 * Tests two methods, using just the method name, used by indexOf(). 123 */ equals(Object o)124 public boolean equals(Object o) { 125 if (name_.compareTo(((MethodAPI)o).name_) == 0) 126 return true; 127 return false; 128 } 129 130 /** 131 * Tests two methods for equality, using just the signature. 132 */ equalSignatures(Object o)133 public boolean equalSignatures(Object o) { 134 if (getSignature().compareTo(((MethodAPI)o).getSignature()) == 0) 135 return true; 136 return false; 137 } 138 139 /** Cached result of getSignature(). */ 140 private String signature_ = null; 141 142 /** Return the signature of the method. */ getSignature()143 public String getSignature() { 144 if (signature_ != null) 145 return signature_; 146 String res = ""; 147 boolean first = true; 148 Iterator iter = params_.iterator(); 149 while (iter.hasNext()) { 150 if (!first) 151 res += ", "; 152 ParamAPI param = (ParamAPI)(iter.next()); 153 res += param.toString(); 154 first = false; 155 } 156 signature_ = res; 157 return res; 158 } 159 } 160