1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
package jdiff;
import java.io.*;
import java.util.*;
/**
* Class to represent a constructor, analogous to ConstructorDoc in the
* Javadoc doclet API.
*
* The method used for Collection comparison (compareTo) must make its
* comparison based upon everything that is known about this constructor.
*
* See the file LICENSE.txt for copyright details.
* @author Matthew Doar, mdoar@pobox.com
*/
class ConstructorAPI implements Comparable {
/**
* Name of the constructor.
* Either this or type_ must be non-null
*/
public String name_ = null;
/**
* The type of the constructor, being all the parameter types
* separated by commas.
* Either this or name_ must be non-null.
*/
public String type_ = null;
/**
* The exceptions thrown by this constructor, being all the exception types
* separated by commas. "no exceptions" if no exceptions are thrown.
*/
public String exceptions_ = "no exceptions";
/** Modifiers for this class. */
public Modifiers modifiers_;
public List params_; // ParamAPI[]
/** The doc block, default is null. */
public String doc_ = null;
/** Constructor. */
public ConstructorAPI(String name, String type, Modifiers modifiers) {
if (name == null && type == null) {
throw new IllegalArgumentException("Cannot have constructor with both name and type"
+ "being null");
}
name_ = name;
type_ = type;
modifiers_ = modifiers;
params_ = new ArrayList();
}
private static <T extends Comparable<? super T>> int compareNullIsLeast(T c1, T c2) {
return c1 == null ? (c2 == null ? 0 : -1) : (c2 == null ? 1 : c1.compareTo(c2));
}
/** Compare two ConstructorAPI objects by type and modifiers. */
public int compareTo(Object o) {
ConstructorAPI constructorAPI = (ConstructorAPI)o;
int comp = compareNullIsLeast(name_, constructorAPI.name_);
if (comp != 0)
return comp;
comp = compareNullIsLeast(getSignature(), constructorAPI.getSignature());
if (comp != 0)
return comp;
comp = exceptions_.compareTo(constructorAPI.exceptions_);
if (comp != 0)
return comp;
comp = modifiers_.compareTo(constructorAPI.modifiers_);
if (comp != 0)
return comp;
if (APIComparator.docChanged(doc_, constructorAPI.doc_))
return -1;
return 0;
}
/**
* Tests two constructors, using just the name and type, used by indexOf().
*/
public boolean equals(Object o) {
ConstructorAPI constructorAPI = (ConstructorAPI)o;
if (compareNullIsLeast(name_, constructorAPI.name_) == 0 &&
compareNullIsLeast(getSignature(), constructorAPI.getSignature()) == 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_;
if (params_ == null)
return type_;
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;
}
}
|
