private void processFromProperties(TypeElement type, Set<TypeElement> types) {
List<? extends Element> children = type.getEnclosedElements();
VisitorConfig config = conf.getConfig(type, children);
// fields
if (config.visitFieldProperties()) {
for (VariableElement field : ElementFilter.fieldsIn(children)) {
TypeElement typeElement = typeExtractor.visit(field.asType());
if (typeElement != null) {
types.add(typeElement);
}
}
}
// getters
if (config.visitMethodProperties()) {
for (ExecutableElement method : ElementFilter.methodsIn(children)) {
String name = method.getSimpleName().toString();
if ((name.startsWith("get") || name.startsWith("is")) && method.getParameters().isEmpty()) {
TypeElement typeElement = typeExtractor.visit(method.getReturnType());
if (typeElement != null) {
types.add(typeElement);
}
}
}
}
}
private void scanForMultipart(
ExecutableElement executableElement, RestDocumentation.Resource.Method doc) {
for (VariableElement var : executableElement.getParameters()) {
TypeMirror varType = var.asType();
if (varType.toString().startsWith(MultipartHttpServletRequest.class.getName())) {
doc.setMultipartRequest(true);
return;
}
}
}
private void buildUrlParameters(
ExecutableElement executableElement, RestDocumentation.Resource.Method doc) {
RestDocumentation.Resource.Method.UrlFields subs = doc.getUrlParameters();
for (VariableElement var : executableElement.getParameters()) {
RequestParam reqParam = var.getAnnotation(RequestParam.class);
if (reqParam != null) {
addUrlField(subs, var, reqParam.value());
}
}
}
private void buildPathVariables(
ExecutableElement executableElement, RestDocumentation.Resource.Method doc) {
RestDocumentation.Resource.Method.UrlFields subs = doc.getUrlSubstitutions();
for (VariableElement var : executableElement.getParameters()) {
PathVariable pathVar = var.getAnnotation(PathVariable.class);
if (pathVar != null) {
addUrlField(subs, var, pathVar.value());
}
}
}
private void printMethod(ExecutableElement executableElement) {
StringBuilder s = new StringBuilder(256);
s.append("method: " + executableElement).append("\n\t");
s.append("annotations: " + executableElement.getAnnotationMirrors()).append("\n\t");
s.append("return: " + executableElement.getReturnType()).append("\n\t");
for (VariableElement var : executableElement.getParameters()) {
s.append("parameter: " + var + ", " + var.getAnnotation(ApiParameterDoc.class))
.append("\n\t");
}
generator.log(s.toString());
}
private boolean validateParametersTypes(ExecutableElement constructor) {
boolean res = true;
List<? extends VariableElement> parameters = constructor.getParameters();
Iterator<TypeElement> sources = context.sources().iterator();
for (VariableElement parameter : parameters) {
TypeElement sourceType = sources.next();
if (!parameter.asType().equals(sourceType.asType())) {
res = false;
break;
}
}
return res;
}
private void parseIdentifier(VariableElement fieldElement) {
final String name = fieldElement.getSimpleName().toString();
assert name.endsWith("_IDENTIFIER");
final String propertyName =
NameUtils.constantToIdentifier(name.substring(0, name.length() - "_IDENTIFIER".length()));
getProperty(propertyName).setHasIdentifier(true);
}
// processes the element
private void process(final boolean isDouble) throws ProcessorException, IOException {
log.fine("Processing floating-point element,");
final int count =
extractIntegerAttribute(element, "repeat", 0, null, 1, processor.getScriptProcessor());
for (int iter = 0; iter < count; iter++) {
for (Node content : children(element)) {
if (content instanceof Text) {
final String trimmedText = ((Text) content).getTextContent().trim();
if (trimmedText.isEmpty()) {
continue;
}
for (String split : new ScriptLine(trimmedText)) {
log.finer("Processing segment: " + split);
final BigInteger value;
if (ScriptProcessor.isScript(split)) {
if (isDouble) {
value =
BigInteger.valueOf(
Double.doubleToLongBits(
processor.getScriptProcessor().evalAsDouble(split)));
} else {
value =
BigInteger.valueOf(
Float.floatToIntBits(processor.getScriptProcessor().evalAsFloat(split)));
}
} else {
try {
if (isDouble) {
value = BigInteger.valueOf(Double.doubleToLongBits(Util.stringToDouble(split)));
} else {
value = BigInteger.valueOf(Float.floatToIntBits(Util.stringToFloat(split)));
}
} catch (final NumberFormatException | NullPointerException exception) {
throw new ProcessorException("Illegal number format (2): " + split);
}
}
write(value);
}
} else if (content instanceof Element) {
final Element innerElement = (Element) content;
switch (innerElement.getTagName()) {
case "flush":
new FlushElement(processor, innerElement);
break;
case "script":
new ScriptElement(processor, innerElement);
break;
default:
VariableElement.create(processor, innerElement, false);
break;
}
}
}
}
log.fine("Floating-point element processed");
}
private void parseShapeConstructor(ExecutableElement methodElement) {
List<? extends VariableElement> parameters = methodElement.getParameters();
if (superLayout != null) {
assert parameters.size() >= superLayout.getAllShapeProperties().size();
parameters =
parameters.subList(superLayout.getAllShapeProperties().size(), parameters.size());
}
for (VariableElement element : parameters) {
final String name = element.getSimpleName().toString();
constructorProperties.add(name);
final PropertyBuilder property = getProperty(name);
setPropertyType(property, element.asType());
parseConstructorParameterAnnotations(property, element);
property.setIsShapeProperty(true);
hasShapeProperties = true;
}
}
private void buildRequestBodies(
ExecutableElement executableElement, RestDocumentation.Resource.Method doc) {
List<VariableElement> requestBodies = new ArrayList<VariableElement>();
for (VariableElement var : executableElement.getParameters()) {
if (var.getAnnotation(org.springframework.web.bind.annotation.RequestBody.class) != null) {
requestBodies.add(var);
}
}
if (requestBodies.size() > 1) {
throw new IllegalStateException(
String.format(
"Method %s in class %s has multiple @RequestBody params",
executableElement.getSimpleName(), executableElement.getEnclosingElement()));
}
if (requestBodies.size() == 1) {
buildRequestBody(requestBodies.get(0), doc);
}
}
private void parseConstructor(ExecutableElement methodElement) {
List<? extends VariableElement> parameters = methodElement.getParameters();
if (hasShapeProperties || (superLayout != null && superLayout.hasShapeProperties())) {
assert parameters.get(0).asType().toString().equals(DynamicObjectFactory.class.getName())
: parameters.get(0).asType();
parameters = parameters.subList(1, parameters.size());
}
if (superLayout != null) {
assert parameters.size() >= superLayout.getAllNonShapeProperties().size();
parameters =
parameters.subList(superLayout.getAllNonShapeProperties().size(), parameters.size());
}
for (VariableElement element : parameters) {
final String name = element.getSimpleName().toString();
constructorProperties.add(name);
final PropertyBuilder property = getProperty(name);
setPropertyType(property, element.asType());
parseConstructorParameterAnnotations(property, element);
}
}
@Override
public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
System.out.println("processing: " + env.toString());
List<MethodToLog> methodToLogs = new ArrayList<>();
List<String> classNames = new ArrayList<>();
for (Element element : env.getElementsAnnotatedWith(XLog.class)) {
if (element.getKind() != ElementKind.METHOD
&& element.getKind() != ElementKind.CONSTRUCTOR
&& element.getKind() != ElementKind.CLASS) {
throw new IllegalStateException(
String.format(
"@%s annotation must be on as method, constructor or class.",
element.getSimpleName()));
}
if (element instanceof TypeElement) {
// class
String pkgName = ((TypeElement) element).getQualifiedName().toString();
if (!classNames.contains(pkgName)) {
classNames.add(pkgName);
}
} else if (element instanceof ExecutableElement) {
// method or constructor
ExecutableElement e = (ExecutableElement) element;
int type = XLogUtils.TYPE_METHOD;
if (e.getKind() == ElementKind.METHOD) {
type = XLogUtils.TYPE_METHOD;
} else if (e.getKind() == ElementKind.CONSTRUCTOR) {
type = XLogUtils.TYPE_CONSTRUCTOR;
}
TypeElement te = findEnclosingTypeElement(e);
System.out.println(te.getQualifiedName().toString() + "." + e.getSimpleName());
System.out.println(e.getReturnType());
List<String> parameters = new ArrayList<>();
List<String> parameterNames = new ArrayList<>();
for (VariableElement ve : e.getParameters()) {
System.out.println(ve.asType());
System.out.println(ve.getSimpleName());
parameters.add(ve.asType().toString());
parameterNames.add(ve.getSimpleName().toString());
}
MethodToLog methodToLog =
new MethodToLog(
type,
te.getQualifiedName().toString(),
e.getSimpleName().toString(),
parameters,
parameterNames);
methodToLogs.add(methodToLog);
if (!classNames.contains(methodToLog.getClassName())) {
classNames.add(methodToLog.getClassName());
}
}
}
if (methodToLogs.size() > 0) {
generateXLogProcessor("_" + MD5(env.toString()), methodToLogs, classNames);
}
return true;
}
private void addUrlField(
RestDocumentation.Resource.Method.UrlFields subs, VariableElement var, String annoValue) {
String name =
(annoValue == null || annoValue.isEmpty()) ? var.getSimpleName().toString() : annoValue;
subs.addField(name, newJsonType(var.asType()));
}
private void buildRequestBody(VariableElement var, RestDocumentation.Resource.Method doc) {
doc.setRequestBody(newJsonType(var.asType()));
}
/**
* {@inheritDoc}
*
* <p>This implementation scans the enclosed elements, unless the element is a {@code
* RESOURCE_VARIABLE} in which case {@code visitUnknown} is called.
*
* @param e {@inheritDoc}
* @param p {@inheritDoc}
* @return the result of scanning
*/
public R visitVariable(VariableElement e, P p) {
if (e.getKind() != ElementKind.RESOURCE_VARIABLE) return scan(e.getEnclosedElements(), p);
else return visitUnknown(e, p);
}
