List of usage examples for javax.lang.model.type TypeKind VOID
TypeKind VOID
To view the source code for javax.lang.model.type TypeKind VOID.
Click Source Link
From source file:com.github.jdot.type.Property.java
/** * Returns new BeanProperty instance if the specified element is a JavaBean accessor method, otherwise null. * //from ww w .ja v a 2s . co m * @param element * @return */ public static Property build(Type owner, ExecutableElement element) { Property beanProperty = null; String name = null; boolean propertyFound = true; boolean writeable = false; String type = null; // Check modifiers boolean publicFound = false; boolean staticFound = false; for (Modifier modifier : element.getModifiers()) { if (Modifier.PUBLIC.equals(modifier)) { publicFound = true; } if (Modifier.STATIC.equals(modifier)) { staticFound = true; } } if (!publicFound || staticFound) { propertyFound = false; } // Check method name if (propertyFound) { String methodName = element.getSimpleName().toString(); if (methodName.startsWith("set") && Character.isUpperCase(methodName.charAt(3))) { name = StringUtils.uncapitalize(methodName.substring(3)); writeable = true; } else if (methodName.startsWith("get") && Character.isUpperCase(methodName.charAt(3))) { name = StringUtils.uncapitalize(methodName.substring(3)); } else if (methodName.startsWith("is") && Character.isUpperCase(methodName.charAt(2))) { name = StringUtils.uncapitalize(methodName.substring(2)); } else { propertyFound = false; } } // Check arguments / return type if (propertyFound) { if (writeable) { if (element.getParameters().size() == 1 && TypeKind.VOID.equals(element.getReturnType().getKind())) { type = element.getParameters().get(0).asType().toString(); } else { propertyFound = false; } } else { if (TypeKind.VOID.equals(element.getReturnType().getKind())) { propertyFound = false; } else { type = element.getReturnType().toString(); } } } if (propertyFound) { beanProperty = new Property(owner, element, name, type, writeable); } return beanProperty; }
From source file:info.archinnov.achilles.internals.parser.UDFParser.java
public static List<UDFSignature> parseFunctionRegistryAndValidateTypes(AptUtils aptUtils, TypeElement elm) { final List<ExecutableElement> methods = ElementFilter.methodsIn(elm.getEnclosedElements()); final Optional<String> keyspace = AnnotationTree.findKeyspaceForFunctionRegistry(aptUtils, elm); final TypeName sourceClass = TypeName.get(aptUtils.erasure(elm)); //Not allow to declare function in system keyspaces if (keyspace.isPresent()) { final String keyspaceName = keyspace.get(); aptUtils.validateFalse(//from w w w. j a v a 2 s . com FORBIDDEN_KEYSPACES.contains(keyspaceName) || FORBIDDEN_KEYSPACES.contains(keyspaceName.toLowerCase()), "The provided keyspace '%s' on function registry class '%s' is forbidden because it is a system keyspace", keyspaceName, sourceClass); } aptUtils.validateFalse(keyspace.isPresent() && isBlank(keyspace.get()), "The declared keyspace for function registry '%s' should not be blank", elm.getSimpleName().toString()); return methods.stream().map(method -> { final List<TypeName> parametersType = method.getParameters().stream().map(VariableElement::asType) .map(TypeName::get).collect(toList()); final String methodName = method.getSimpleName().toString(); final List<UDFParamSignature> parameterSignatures = method.getParameters().stream() .map(x -> new UDFParamSignature(TypeName.get(x.asType()).box(), x.getSimpleName().toString())) .collect(toList()); //Validate parameter types for (TypeName param : parametersType) { TypeValidator.validateNativeTypesForFunction(aptUtils, method, param, "argument"); } //Validate return type final TypeMirror returnTypeMirror = method.getReturnType(); aptUtils.validateFalse(returnTypeMirror.getKind() == TypeKind.VOID, "The return type for the method '%s' on class '%s' should not be VOID", method.toString(), elm.getSimpleName().toString()); final TypeName returnType = TypeName.get(returnTypeMirror).box(); TypeValidator.validateNativeTypesForFunction(aptUtils, method, returnType, "return type"); // Validate NOT system function comparing only name lowercase aptUtils.validateFalse(SYSTEM_FUNCTIONS_NAME.contains(methodName.toLowerCase()), "The name of the function '%s' in class '%s' is reserved for system functions", method, sourceClass); return new UDFSignature(keyspace, sourceClass, methodName, returnType, parametersType, parameterSignatures); }).collect(toList()); }
From source file:info.archinnov.achilles.internals.parser.FunctionParser.java
public static List<FunctionSignature> parseFunctionRegistryAndValidateTypes(AptUtils aptUtils, TypeElement elm, GlobalParsingContext context) {//from w w w . j a v a 2s. c o m final List<ExecutableElement> methods = ElementFilter.methodsIn(elm.getEnclosedElements()); final Optional<String> keyspace = AnnotationTree.findKeyspaceForFunctionRegistry(aptUtils, elm); final FunctionParamParser paramParser = new FunctionParamParser(aptUtils); final TypeName parentType = TypeName.get(aptUtils.erasure(elm)); //Not allow to declare function in system keyspaces if (keyspace.isPresent()) { final String keyspaceName = keyspace.get(); aptUtils.validateFalse( FORBIDDEN_KEYSPACES.contains(keyspaceName) || FORBIDDEN_KEYSPACES.contains(keyspaceName.toLowerCase()), "The provided keyspace '%s' on function registry class '%s' is forbidden because it is a system keyspace", keyspaceName, parentType); } aptUtils.validateFalse(keyspace.isPresent() && isBlank(keyspace.get()), "The declared keyspace for function registry '%s' should not be blank", elm.getSimpleName().toString()); return methods.stream().map(method -> { final String methodName = method.getSimpleName().toString(); final List<AnnotationTree> annotationTrees = AnnotationTree.buildFromMethodForParam(aptUtils, method); final List<? extends VariableElement> parameters = method.getParameters(); final List<FunctionParamSignature> parameterSignatures = new ArrayList<>(parameters.size()); for (int i = 0; i < parameters.size(); i++) { final VariableElement parameter = parameters.get(i); context.nestedTypesStrategy.validate(aptUtils, annotationTrees.get(i), method.toString(), parentType); final FunctionParamSignature functionParamSignature = paramParser.parseParam(context, annotationTrees.get(i), parentType, methodName, parameter.getSimpleName().toString()); parameterSignatures.add(functionParamSignature); } //Validate return type final TypeMirror returnType = method.getReturnType(); aptUtils.validateFalse(returnType.getKind() == TypeKind.VOID, "The return type for the method '%s' on class '%s' should not be VOID", method.toString(), elm.getSimpleName().toString()); aptUtils.validateFalse(returnType.getKind().isPrimitive(), "Due to internal JDK API limitations, UDF/UDA return types cannot be primitive. " + "Use their Object counterpart instead for method '%s' " + "in function registry '%s'", method.toString(), elm.getQualifiedName()); final FunctionParamSignature returnTypeSignature = paramParser.parseParam(context, AnnotationTree.buildFromMethodForReturnType(aptUtils, method), parentType, methodName, "returnType"); // Validate NOT system function comparing only name lowercase aptUtils.validateFalse(SYSTEM_FUNCTIONS_NAME.contains(methodName.toLowerCase()), "The name of the function '%s' in class '%s' is reserved for system functions", method, parentType); return new FunctionSignature(keyspace, parentType, methodName, returnTypeSignature, parameterSignatures); }).collect(toList()); }
From source file:com.googlecode.androidannotations.processing.rest.RestProcessor.java
@Override public void process(Element element, JCodeModel codeModel, EBeansHolder activitiesHolder) throws Exception { RestImplementationHolder holder = restImplementationHolder.create(element); TypeElement typeElement = (TypeElement) element; holder.urlPrefix = typeElement.getAnnotation(Rest.class).value(); String interfaceName = typeElement.getQualifiedName().toString(); String implementationName = interfaceName + ModelConstants.GENERATION_SUFFIX; // holder.restImplementationClass = codeModel._class(JMod.PUBLIC | // JMod.ABSTRACT, implementationName, ClassType.CLASS); holder.restImplementationClass = codeModel._class(JMod.PUBLIC, implementationName, ClassType.CLASS); JClass interfaceClass = holder.refClass(interfaceName); holder.restImplementationClass._implements(interfaceClass); // RestTemplate field JClass restTemplateClass = holder.refClass(SPRING_REST_TEMPLATE_QUALIFIED_NAME); holder.restTemplateField = holder.restImplementationClass.field(JMod.PRIVATE, restTemplateClass, "restTemplate"); // Default constructor JMethod defaultConstructor = holder.restImplementationClass.constructor(JMod.PUBLIC); defaultConstructor.body().assign(holder.restTemplateField, JExpr._new(restTemplateClass)); // RestTemplate constructor JMethod restTemplateConstructor = holder.restImplementationClass.constructor(JMod.PUBLIC); JVar restTemplateParam = restTemplateConstructor.param(restTemplateClass, "restTemplate"); restTemplateConstructor.body().assign(JExpr._this().ref(holder.restTemplateField), restTemplateParam); // RequestFactory constructor JMethod requestFactoryConstructor = holder.restImplementationClass.constructor(JMod.PUBLIC); JClass requestFactoryClass = holder.refClass("org.springframework.http.client.ClientHttpRequestFactory"); JVar requestFactoryParam = requestFactoryConstructor.param(requestFactoryClass, "requestFactory"); requestFactoryConstructor.body().assign(holder.restTemplateField, JExpr._new(restTemplateClass).arg(requestFactoryParam)); // Implement getRestTemplate method List<? extends Element> enclosedElements = typeElement.getEnclosedElements(); List<ExecutableElement> methods = ElementFilter.methodsIn(enclosedElements); for (ExecutableElement method : methods) { if (method.getParameters().size() == 0 && method.getReturnType().toString().equals(SPRING_REST_TEMPLATE_QUALIFIED_NAME)) { String methodName = method.getSimpleName().toString(); JMethod getRestTemplateMethod = holder.restImplementationClass.method(JMod.PUBLIC, restTemplateClass, methodName); getRestTemplateMethod.annotate(Override.class); getRestTemplateMethod.body()._return(holder.restTemplateField); break; // Only one implementation }//from w w w. j a v a2s.c o m } for (ExecutableElement method : methods) { List<? extends VariableElement> parameters = method.getParameters(); if (parameters.size() == 1 && method.getReturnType().getKind() == TypeKind.VOID) { VariableElement firstParameter = parameters.get(0); if (firstParameter.asType().toString().equals(SPRING_REST_TEMPLATE_QUALIFIED_NAME)) { String methodName = method.getSimpleName().toString(); JMethod setRestTemplateMethod = holder.restImplementationClass.method(JMod.PUBLIC, codeModel.VOID, methodName); setRestTemplateMethod.annotate(Override.class); JVar restTemplateSetterParam = setRestTemplateMethod.param(restTemplateClass, firstParameter.getSimpleName().toString()); setRestTemplateMethod.body().assign(_this().ref(holder.restTemplateField), restTemplateSetterParam); break; // Only one implementation } } } }
From source file:io.wcm.tooling.netbeans.sightly.completion.classLookup.MemberLookupResolver.java
private Set<MemberLookupResult> getMethodsFromJavaSource(String clazzname, String variable) { Set<MemberLookupResult> ret = new LinkedHashSet<>(); ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() { @Override/*from w w w. j a v a2 s. c o m*/ public boolean accept(Element e, TypeMirror type) { // we accept only public stuff if (!e.getModifiers().contains(Modifier.PUBLIC)) { return false; } if (e.getKind() == ElementKind.METHOD) { ExecutableElement method = (ExecutableElement) e; if (method.getReturnType().getKind() != TypeKind.VOID) { return GETTER_PATTERN.matcher(e.getSimpleName().toString()).matches(); } } return e.getKind() == ElementKind.FIELD; } }; Set<Element> elems = getMembersFromJavaSource(clazzname, acceptor); for (Element e : elems) { if (e.getKind() == ElementKind.METHOD) { ExecutableElement method = (ExecutableElement) e; MemberLookupResult result = new MemberLookupResult(variable, e.getSimpleName().toString(), method.getReturnType().toString()); ret.add(result); } else if (e.getKind() == ElementKind.FIELD) { MemberLookupResult result = new MemberLookupResult(variable, e.getSimpleName().toString(), e.asType().toString()); ret.add(result); } } return ret; }
From source file:com.github.pellaton.springconfigvalidation.SpringConfigurationValidationProcessor.java
private void processForReturnType(ExecutableElement methodElement) { if (methodElement.getReturnType().getKind() == TypeKind.VOID) { printMessage(SpringConfigurationMessage.BEAN_METHOD_RETURNS_VOID, methodElement); }//from w w w . j a v a2 s .c o m }
From source file:org.mule.devkit.module.generation.AbstractMessageGenerator.java
protected Map<String, FieldVariableElement> generateFieldForEachSetter(DefinedClass transferObjectClass, TypeElement transferObject) { Map<String, AbstractMessageGenerator.FieldVariableElement> fields = new HashMap<String, FieldVariableElement>(); java.util.List<ExecutableElement> methods = ElementFilter.methodsIn(transferObject.getEnclosedElements()); for (ExecutableElement method : methods) { String methodName = method.getSimpleName().toString(); if (!methodName.startsWith("set") || method.getReturnType().getKind() != TypeKind.VOID || method.getParameters().size() != 1) { continue; }/*from ww w. ja va 2 s.c om*/ String fieldName = StringUtils.uncapitalize(methodName.substring(methodName.indexOf("set") + 3)); TypeMirror fieldTypeMirror = method.getParameters().get(0).asType(); FieldVariable field = null; if (fieldTypeMirror.toString().contains(ProcessorCallback.class.getName())) { field = transferObjectClass.field(Modifier.PRIVATE, ref(MessageProcessor.class), fieldName); } else { field = transferObjectClass.field(Modifier.PRIVATE, ref(Object.class), fieldName); } FieldVariable fieldType = transferObjectClass.field(Modifier.PRIVATE, ref(fieldTypeMirror), fieldName + "Type"); fields.put(fieldName, new AbstractMessageGenerator.FieldVariableElement(field, fieldType, null)); } return fields; }
From source file:org.netbeans.jcode.mvc.controller.MVCControllerGenerator.java
public Set<FileObject> generate(Entity entity, final boolean hasRemote, final boolean hasLocal, boolean overrideExisting) throws IOException { final String entityFQN = entity.getFQN(entityMapping.getPackage()); final String idClass = entity.getAttributes().getIdField().getDataTypeLabel(); final Set<FileObject> createdFiles = new HashSet<>(); final String entitySimpleName = entity.getClazz(); final String variableName = StringHelper.firstLower(entitySimpleName); final String listVariableName = Inflector.getInstance().pluralize(variableName); // final String constantName = StringHelper.toConstant(entitySimpleName); String facadeFileName = beanData.getPrefixName() + entitySimpleName + beanData.getSuffixName(); String fqFacadeFileName = entity.getPackage(beanData.getPackage()) + '.' + facadeFileName; String controllerFileName = mvcData.getPrefixName() + entitySimpleName + mvcData.getSuffixName(); handler.progress(controllerFileName); FileObject targetFolder = SourceGroupSupport.getFolderForPackage(source, entity.getPackage(mvcData.getPackage()), true); FileObject controllerFO = targetFolder.getFileObject(controllerFileName, JAVA_EXT);//skips here if (controllerFO != null) { if (overrideExisting) { controllerFO.delete();// w ww . j av a 2 s. com } else { throw new IOException("File already exists exception: " + controllerFO.getPath()); } } final FileObject controllerFile = GenerationUtils.createClass(targetFolder, controllerFileName, null); createdFiles.add(controllerFile); String webPath; if (jspData != null) { webPath = jspData.getFolder(); } else { webPath = JSPData.DEFAULT_FOLDER; } if (model != null) { Util.generatePrimaryKeyMethod(controllerFile, entityFQN, model); } // add implements and extends clauses to the facade final Task<WorkingCopy> modificationTask = new Task<WorkingCopy>() { @Override public void run(WorkingCopy wc) throws Exception { wc.toPhase(Phase.RESOLVED); TypeElement classElement = SourceUtils.getPublicTopLevelElement(wc); ClassTree classTree = wc.getTrees().getTree(classElement); assert classTree != null; GenerationUtils genUtils = GenerationUtils.newInstance(wc); TreeMaker maker = wc.getTreeMaker(); if (mvcData.isBeanValidation()) { String utilPackage = StringUtils.isBlank(mvcData.getPackage()) ? UTIL_PACKAGE : mvcData.getPackage() + "." + UTIL_PACKAGE; CompilationUnitTree cut = wc.getCompilationUnit(); CompilationUnitTree newCut = maker.addCompUnitImport(cut, maker.Import(maker.Identifier(utilPackage + "." + ERROR_BEAN_CLASS), false)); newCut = maker.addCompUnitImport(newCut, maker.Import(maker.Identifier(utilPackage + "." + VALIDATION_UTIL_CLASS), false)); wc.rewrite(cut, newCut); } // ExpressionTree packageTree = wc.getCompilationUnit().getPackageName(); // String packageName = packageTree.toString(); List<Tree> members = new ArrayList<>(classTree.getMembers()); members.add(maker.Variable( maker.addModifiersAnnotation(genUtils.createModifiers(Modifier.PRIVATE), genUtils.createAnnotation(INJECT)), MODEL_VAR_DECLARATION, genUtils.createType(MODELS, classElement), null)); members.add(maker.Variable( maker.addModifiersAnnotation(genUtils.createModifiers(Modifier.PRIVATE), genUtils.createAnnotation(INJECT)), SESSION_BEAN_VAR_DECLARATION, genUtils.createType(fqFacadeFileName, classElement), null)); if (mvcData.isBeanValidation()) { members.add(maker.Variable( maker.addModifiersAnnotation(genUtils.createModifiers(Modifier.PRIVATE), genUtils.createAnnotation(INJECT)), BINDING_RESULT_VAR, genUtils.createType(BINDING_RESULT, classElement), null)); members.add(maker.Variable( maker.addModifiersAnnotation(genUtils.createModifiers(Modifier.PRIVATE), genUtils.createAnnotation(INJECT)), ERROR_BEAN_VAR, genUtils.createType(ERROR_BEAN_CLASS, classElement), null)); } List<RestGenerationOptions> restGenerationOptions = getRestFacadeMethodOptions(entityFQN, idClass); ModifiersTree publicModifiers = genUtils.createModifiers(Modifier.PUBLIC); ModifiersTree paramModifier = maker.Modifiers(Collections.<Modifier>emptySet()); for (RestGenerationOptions option : restGenerationOptions) { ModifiersTree modifiersTree = maker.addModifiersAnnotation(publicModifiers, genUtils.createAnnotation(option.getRestMethod().getMethod())); // add @Path annotation String uriPath = option.getRestMethod().getUriPath(); if (uriPath != null) { ExpressionTree annArgument = maker.Literal(uriPath); modifiersTree = maker.addModifiersAnnotation(modifiersTree, genUtils.createAnnotation( RestConstants.PATH, Collections.<ExpressionTree>singletonList(annArgument))); } if (mvcData.isHybridClass()) { // add @Controller annotation modifiersTree = maker.addModifiersAnnotation(modifiersTree, genUtils.createAnnotation(MVCConstants.CONTROLLER)); } // create arguments list List<VariableTree> vars = new ArrayList<>(); String[] paramNames = option.getParameterNames(); int paramLength = paramNames == null ? 0 : option.getParameterNames().length; boolean beanParamExist = false; if (paramLength > 0) { String[] paramTypes = option.getParameterTypes(); String[] annotations = option.getParameterAnnoations(); String[] annotationValues = option.getParameterAnnoationValues(); for (int i = 0; i < paramLength; i++) { ModifiersTree pathParamTree = paramModifier; if (annotations != null && annotations[i] != null) { if (mvcData.isBeanValidation() && BEAN_PARAM.equals(annotations[i])) { pathParamTree = maker.addModifiersAnnotation(pathParamTree, genUtils.createAnnotation(VALID)); beanParamExist = true; } AnnotationTree annotationTree; if (annotationValues[i] != null) { annotationTree = genUtils.createAnnotation(annotations[i], Collections .<ExpressionTree>singletonList(maker.Literal(annotationValues[i]))); } else { annotationTree = genUtils.createAnnotation(annotations[i]); } pathParamTree = maker.addModifiersAnnotation(pathParamTree, annotationTree); } Tree paramTree = genUtils.createType(paramTypes[i], classElement); VariableTree var = maker .Variable( pathParamTree, paramNames[i].replaceAll(ENTITY_NAME_EXP, variableName) .replaceAll(ENTITIES_NAME_EXP, listVariableName), paramTree, null); vars.add(var); } } StringBuilder body = option.getBody(); if (mvcData.isBeanValidation() && beanParamExist) { body.insert(0, VALIDATION_FILTER); // add @ValidateOnExecution annotation modifiersTree = maker.addModifiersAnnotation(modifiersTree, genUtils.createAnnotation(VALIDATE_ON_EXECUTION, Collections.singletonList( genUtils.createAnnotationArgument("type", EXECUTABLE_TYPE, "NONE")))); } if (mvcData.isCSRF() && beanParamExist) { // add @CsrfValid annotation modifiersTree = maker.addModifiersAnnotation(modifiersTree, genUtils.createAnnotation(CSRF_VALID)); } Tree returnType = null; String view = option.getRestMethod().getView(); view = view.replaceAll(ENTITY_NAME_EXP, variableName).replaceAll(FOLDER_NAME_EXP, webPath); if (mvcData.getReturnType() == ControllerReturnType.VIEW_ANNOTATION && !(mvcData.isBeanValidation() && beanParamExist)) { // add @View annotation ExpressionTree annArgument = maker.Literal(view); modifiersTree = maker.addModifiersAnnotation(modifiersTree, genUtils.createAnnotation( MVCConstants.VIEW, Collections.<ExpressionTree>singletonList(annArgument))); returnType = maker.PrimitiveType(TypeKind.VOID); } else if (mvcData.getReturnType() == ControllerReturnType.STRING || (mvcData.getReturnType() == ControllerReturnType.VIEW_ANNOTATION && mvcData.isBeanValidation() && beanParamExist)) { body.append("\n").append("return \"").append(view).append("\";"); returnType = genUtils.createType(String.class.getName(), classElement); } else if (mvcData.getReturnType() == ControllerReturnType.VIEWABLE) { body.append("\n").append("return new ").append(MVCConstants.VIEWABLE_UNQF).append("(\"") .append(view).append("\");"); returnType = genUtils.createType(VIEWABLE, classElement); } else if (mvcData.getReturnType() == ControllerReturnType.JAXRS_RESPONSE) { if (view.startsWith(REDIRECT)) { body.append("\n").append("return ").append(RESPONSE_UNQF).append(".seeOther(") .append(URI.class.getName()).append(".create(\"") .append(view.substring(REDIRECT.length())).append("\")).build()"); } else { body.append("\n").append("return ").append(RESPONSE_UNQF).append(".status(") .append(RESPONSE_UNQF).append(".Status.OK).entity(\"").append(view) .append("\").build()"); } returnType = genUtils.createType(RESPONSE, classElement); } String bodyContent = body.toString().replaceAll(ENTITY_NAME_EXP, variableName) .replaceAll(ENTITIES_NAME_EXP, listVariableName); members.add( maker.Method(modifiersTree, option.getRestMethod().getMethodName() + entitySimpleName, returnType, Collections.EMPTY_LIST, vars, (List<ExpressionTree>) Collections.EMPTY_LIST, "{" + bodyContent + "}", null)); } ModifiersTree modifiersTree = classTree.getModifiers(); if (!mvcData.isHybridClass()) { // add @Controller annotation modifiersTree = maker.addModifiersAnnotation(modifiersTree, genUtils.createAnnotation(MVCConstants.CONTROLLER)); } modifiersTree = maker.addModifiersAnnotation(modifiersTree, genUtils.createAnnotation(RestConstants.PATH, Collections.<ExpressionTree>singletonList(maker.Literal(variableName)))); ClassTree newClassTree = maker.Class(modifiersTree, classTree.getSimpleName(), classTree.getTypeParameters(), classTree.getExtendsClause(), classTree.getImplementsClause(), members); wc.rewrite(classTree, newClassTree); } }; try { JavaSource.forFileObject(controllerFile).runWhenScanFinished((CompilationController controller) -> { controller.toPhase(Phase.ELEMENTS_RESOLVED); JavaSource.forFileObject(controllerFile).runModificationTask(modificationTask).commit(); }, true).get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } return createdFiles; }
From source file:org.versly.rest.wsdoc.AnnotationProcessor.java
private JsonType jsonTypeFromTypeMirror(TypeMirror typeMirror, Collection<String> typeRecursionGuard) { JsonType type;//w w w . j av a 2s. c o m if (_memoizedTypeMirrors.containsKey(typeMirror)) { return _memoizedTypeMirrors.get(typeMirror); } if (isJsonPrimitive(typeMirror)) { type = new JsonPrimitive(typeMirror.toString()); } else if (typeMirror.getKind() == TypeKind.DECLARED) { // some sort of object... walk it DeclaredType declaredType = (DeclaredType) typeMirror; type = jsonTypeForDeclaredType(declaredType, declaredType.getTypeArguments(), typeRecursionGuard); } else if (typeMirror.getKind() == TypeKind.VOID) { type = null; } else if (typeMirror.getKind() == TypeKind.ARRAY) { TypeMirror componentType = ((ArrayType) typeMirror).getComponentType(); type = jsonTypeFromTypeMirror(componentType, typeRecursionGuard); } else if (typeMirror.getKind() == TypeKind.ERROR) { type = new JsonPrimitive("(unresolvable type)"); } else { throw new UnsupportedOperationException(typeMirror.toString()); } _memoizedTypeMirrors.put(typeMirror, type); return type; }