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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
package org.jetbrains.protocolReader;
import org.jetbrains.jsonProtocol.JsonField;
import org.jetbrains.jsonProtocol.JsonNullable;
import org.jetbrains.jsonProtocol.JsonOptionalField;
import org.jetbrains.jsonProtocol.JsonSubtypeCasting;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.*;
class FieldProcessor<T> {
private final Class<T> typeClass;
private final List<FieldLoader> fieldLoaders = new ArrayList<>(2);
private final LinkedHashMap<Method, MethodHandler> methodHandlerMap = new LinkedHashMap<>();
private final List<VolatileFieldBinding> volatileFields = new ArrayList<>(2);
boolean lazyRead;
private final InterfaceReader reader;
FieldProcessor(InterfaceReader reader, Class<T> typeClass) {
this.typeClass = typeClass;
this.reader = reader;
}
void go() {
Method[] methods = typeClass.getDeclaredMethods();
// todo sort by source location
Arrays.sort(methods, new Comparator<Method>() {
@Override
public int compare(Method o1, Method o2) {
return o1.getName().compareTo(o2.getName());
}
});
for (Method m : methods) {
try {
processMethod(m);
}
catch (JsonProtocolModelParseException e) {
throw new JsonProtocolModelParseException("Problem with method " + m, e);
}
}
}
private void processMethod(Method m) {
if (m.getParameterTypes().length != 0) {
throw new JsonProtocolModelParseException("No parameters expected in " + m);
}
String fieldName = checkAndGetJsonFieldName(m);
MethodHandler methodHandler;
JsonSubtypeCasting jsonSubtypeCaseAnnotation = m.getAnnotation(JsonSubtypeCasting.class);
if (jsonSubtypeCaseAnnotation != null) {
methodHandler = processManualSubtypeMethod(m, jsonSubtypeCaseAnnotation);
lazyRead = true;
}
else {
methodHandler = processFieldGetterMethod(m, fieldName);
}
methodHandlerMap.put(m, methodHandler);
}
private MethodHandler processFieldGetterMethod(Method m, String fieldName) {
Type genericReturnType = m.getGenericReturnType();
boolean nullable;
if (m.getAnnotation(JsonNullable.class) != null) {
nullable = true;
}
else if (genericReturnType == String.class || genericReturnType == Enum.class) {
JsonField jsonField = m.getAnnotation(JsonField.class);
if (jsonField != null) {
nullable = jsonField.optional() && !jsonField.allowAnyPrimitiveValue() && !jsonField.allowAnyPrimitiveValueAndMap();
}
else {
nullable = m.getAnnotation(JsonOptionalField.class) != null;
}
}
else {
nullable = false;
}
ValueReader fieldTypeParser = reader.getFieldTypeParser(genericReturnType, nullable, false, m);
if (fieldTypeParser != InterfaceReader.VOID_PARSER) {
fieldLoaders.add(new FieldLoader(fieldName, fieldTypeParser));
}
return new PreparsedFieldMethodHandler(fieldTypeParser == InterfaceReader.VOID_PARSER ? null : fieldName);
}
private MethodHandler processManualSubtypeMethod(final Method m, JsonSubtypeCasting jsonSubtypeCaseAnn) {
ValueReader fieldTypeParser = reader.getFieldTypeParser(m.getGenericReturnType(), false, !jsonSubtypeCaseAnn.reinterpret(), null);
VolatileFieldBinding fieldInfo = allocateVolatileField(fieldTypeParser, true);
LazyCachedMethodHandler handler = new LazyCachedMethodHandler(fieldTypeParser, fieldInfo);
ObjectValueReader<?> parserAsObjectValueParser = fieldTypeParser.asJsonTypeParser();
if (parserAsObjectValueParser != null && parserAsObjectValueParser.isSubtyping()) {
SubtypeCaster subtypeCaster = new SubtypeCaster(parserAsObjectValueParser.getType()) {
@Override
void writeJava(TextOutput out) {
out.append(m.getName()).append("()");
}
};
reader.subtypeCasters.add(subtypeCaster);
}
return handler;
}
List<VolatileFieldBinding> getVolatileFields() {
return volatileFields;
}
List<FieldLoader> getFieldLoaders() {
return fieldLoaders;
}
LinkedHashMap<Method, MethodHandler> getMethodHandlerMap() {
return methodHandlerMap;
}
private VolatileFieldBinding allocateVolatileField(final ValueReader fieldTypeParser, boolean internalType) {
int position = volatileFields.size();
FieldTypeInfo fieldTypeInfo;
if (internalType) {
fieldTypeInfo = new FieldTypeInfo() {
@Override
public void appendValueTypeNameJava(FileScope scope, TextOutput out) {
fieldTypeParser.appendInternalValueTypeName(scope, out);
}
};
}
else {
fieldTypeInfo = new FieldTypeInfo() {
@Override
public void appendValueTypeNameJava(FileScope scope, TextOutput out) {
fieldTypeParser.appendFinishedValueTypeName(out);
}
};
}
VolatileFieldBinding binding = new VolatileFieldBinding(position, fieldTypeInfo);
volatileFields.add(binding);
return binding;
}
private static String checkAndGetJsonFieldName(Method m) {
if (m.getParameterTypes().length != 0) {
throw new JsonProtocolModelParseException("Must have 0 parameters");
}
JsonField fieldAnn = m.getAnnotation(JsonField.class);
if (fieldAnn != null) {
String jsonLiteralName = fieldAnn.jsonLiteralName();
if (!jsonLiteralName.isEmpty()) {
return jsonLiteralName;
}
}
return m.getName();
}
}
|
