blob: 09a9dff336edd96835626c78397cbf1f81dbd270 (
plain)
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
124
125
126
127
128
129
130
131
132
133
|
/*
* Copyright (C) 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.doclava;
import java.util.ArrayList;
public class AnnotationValueInfo implements Resolvable {
private Object mValue;
private MethodInfo mElement;
private String mInstanceName; // exists solely for resolving elements
private ArrayList<Resolution> mResolutions;
public AnnotationValueInfo() {
mElement = null;
mValue = null;
mInstanceName = null;
}
public AnnotationValueInfo(MethodInfo element) {
mElement = element;
}
public void init(Object value) {
mValue = value;
}
public MethodInfo element() {
return mElement;
}
public void setElement(MethodInfo element) {
mElement = element;
}
public Object value() {
return mValue;
}
public void setAnnotationInstanceName(String instance) {
mInstanceName = instance;
}
public String valueString() {
Object v = mValue;
if (v instanceof TypeInfo) {
return ((TypeInfo) v).fullName();
} else if (v instanceof FieldInfo) {
StringBuilder str = new StringBuilder();
FieldInfo f = (FieldInfo) v;
str.append(f.containingClass().qualifiedName());
str.append('.');
str.append(f.name());
return str.toString();
} else if (v instanceof AnnotationInstanceInfo) {
return v.toString();
} else if (v instanceof ArrayList<?>) {
StringBuilder str = new StringBuilder();
@SuppressWarnings("unchecked")
ArrayList<AnnotationValueInfo> values = (ArrayList<AnnotationValueInfo>) v;
str.append("{");
for (AnnotationValueInfo info : values) {
str.append(info.valueString());
if (info != values.get(values.size()-1)) {
str.append(",");
}
}
str.append("}");
return str.toString();
} else {
return FieldInfo.constantLiteralValue(v);
}
}
public void addResolution(Resolution resolution) {
if (mResolutions == null) {
mResolutions = new ArrayList<Resolution>();
}
mResolutions.add(resolution);
}
public void printResolutions() {
System.out.println("Resolutions for Annotation Value:");
for (Resolution r : mResolutions) {
System.out.println(r);
}
}
public boolean resolveResolutions() {
ArrayList<Resolution> resolutions = mResolutions;
mResolutions = new ArrayList<Resolution>();
boolean allResolved = true;
for (Resolution resolution : resolutions) {
StringBuilder qualifiedClassName = new StringBuilder();
InfoBuilder.resolveQualifiedName(mInstanceName, qualifiedClassName,
resolution.getInfoBuilder());
// if we still couldn't resolve it, save it for the next pass
if ("".equals(qualifiedClassName.toString())) {
mResolutions.add(resolution);
allResolved = false;
} else if ("element".equals(resolution.getVariable())) {
ClassInfo annotation = InfoBuilder.Caches.obtainClass(qualifiedClassName.toString());
for (MethodInfo m : annotation.annotationElements()) {
if (resolution.getValue().equals(m.name()) ||
annotation.annotationElements().size() == 1) {
mElement = m;
break;
}
}
}
}
return allResolved;
}
}
|
