@Before public void setup() { ProcessingEnvironment env = ProcessingEnvironmentRunner.getProcessingEnvironment(); elements = env.getElementUtils(); TypeMUtils typeMUtils = new TypeMUtils(); underTest = new BuilderModelProducer(env, typeMUtils); }
@Before public void init() { ProcessingEnvironment processingEnv = mock(ProcessingEnvironment.class); Elements elementUtils = mock(Elements.class); when(processingEnv.getElementUtils()).thenReturn(elementUtils); processor.init(processingEnv); }
@Override public void writeFieldReadStatement( VariableElement field, Collection<ExecutableElement> postCreateChildMethods, JavaWriter writer) throws IOException { DeclaredType type = (DeclaredType) field.asType(); TypeMirror itemType = type.getTypeArguments().get(0); TypeMirror itemTypeErasure = processingEnv.getTypeUtils().erasure(itemType); String collectionInitializer; try { collectionInitializer = initializers.findCollectionInitializer(type); } catch (InvalidTypeException e) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage(), field); collectionInitializer = "null"; } writer.beginControlFlow("if (bundle.containsKey(\"%s\"))", field.getSimpleName()); writer.emitStatement("object.%s = %s", field.getSimpleName(), collectionInitializer); writer.emitStatement( "%1$s.readCollectionFromBundle(object.%2$s, bundle, %3$s.class, \"%2$s\")", CollectionBundler.class.getCanonicalName(), field.getSimpleName(), itemTypeErasure); writePostCreateChildMethodCalls(field, itemType, postCreateChildMethods, writer); writer.endControlFlow(); }
@Override public synchronized void init(ProcessingEnvironment env) { super.init(env); elementUtils = env.getElementUtils(); typeUtils = env.getTypeUtils(); filer = env.getFiler(); }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); note("LensKit Shareable linting active"); typeUtils = processingEnv.getTypeUtils(); elementUtils = processingEnv.getElementUtils(); }
@Override public synchronized void init(ProcessingEnvironment env) { super.init(env); mLogger = new Logger(env); mElements = env.getElementUtils(); mTypes = env.getTypeUtils(); mFiler = env.getFiler(); }
@Override public void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); this.processingEnv = processingEnv; errorListener = new ErrorReceiverImpl( processingEnv.getMessager(), processingEnv.getOptions().containsKey(Const.DEBUG_OPTION.getValue())); }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); Elements elementUtils = processingEnv.getElementUtils(); Types typeUtils = processingEnv.getTypeUtils(); Filer filer = processingEnv.getFiler(); Messager messager = processingEnv.getMessager(); }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); elements = processingEnv.getElementUtils(); types = processingEnv.getTypeUtils(); messager = processingEnv.getMessager(); factoryWriter = new FactoryWriter(processingEnv.getFiler()); providedChecker = new ProvidedChecker(messager); declarationFactory = new AutoFactoryDeclaration.Factory(elements, messager); factoryDescriptorGenerator = new FactoryDescriptorGenerator(messager, elements, declarationFactory); }
@Override public void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); filer = processingEnv.getFiler(); messager = processingEnv.getMessager(); eltUtils = processingEnv.getElementUtils(); outputDir = processingEnv.getOptions().get("structoutputdir"); outputDir = outputDir == null ? "gensrc" : outputDir; basedir = processingEnv.getOptions().get("basedir"); }
/** * Returns {@code true} if debug enabled otherwirse {@code false}. * * @param env the environment. * @return {@code true} if the debug option enabled otherwirse {@code false} . */ public static boolean isDebugEnabled(ProcessingEnvironment env) { String debug = env.getOptions().get(Options.DEBUG); if (debug == null) { return false; } return Boolean.valueOf(debug).booleanValue(); }
@Override public Reader getResource(String resourcePath) throws IOException { return processingEnv .getFiler() .getResource(StandardLocation.CLASS_OUTPUT, "", resourcePath) .openReader(true); }
public void writeXSD(Model m) throws IOException { try { for (MainInfo main : m.getMains()) { List<Element> sources = new ArrayList<Element>(); sources.add(main.getElement()); sources.addAll(main.getInterceptorElements()); FileObject o = processingEnv .getFiler() .createResource( StandardLocation.CLASS_OUTPUT, main.getAnnotation().outputPackage(), main.getAnnotation().outputName(), sources.toArray(new Element[0])); BufferedWriter bw = new BufferedWriter(o.openWriter()); try { assembleXSD(bw, m, main); } finally { bw.close(); } } } catch (FilerException e) { if (e.getMessage().contains("Source file already created")) return; throw e; } }
/** * エラーログ。スタックのフルダンプ。 * * @param t 発生した例外 */ protected void error(Throwable t) { Messager messager = environment.getMessager(); StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); t.printStackTrace(pw); messager.printMessage(Kind.ERROR, sw.toString()); }
/** * ソース生成. * * @throws IOException * @author vvakame */ public void write() throws IOException { Filer filer = processingEnv.getFiler(); String generateClassName = classElement.asType().toString() + postfix; JavaFileObject fileObject = filer.createSourceFile(generateClassName, classElement); Template.write(fileObject, g); }
public static FunctionMirror newInstance(ExecutableElement method, ProcessingEnvironment env) { assertNotNull(env); AnnotationMirror annotationMirror = ElementUtil.getAnnotationMirror(method, Function.class, env); if (annotationMirror == null) { return null; } FunctionMirror result = new FunctionMirror(annotationMirror, method.getSimpleName().toString()); for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : env.getElementUtils().getElementValuesWithDefaults(annotationMirror).entrySet()) { String name = entry.getKey().getSimpleName().toString(); AnnotationValue value = entry.getValue(); if ("catalog".equals(name)) { result.catalog = value; } else if ("schema".equals(name)) { result.schema = value; } else if ("name".equals(name)) { result.name = value; } else if ("queryTimeout".equals(name)) { result.queryTimeout = value; } else if ("mapKeyNaming".equals(name)) { result.mapKeyNaming = value; } else if ("ensureResultMapping".equals(name)) { result.ensureResultMapping = value; } } return result; }
/** * INTERNAL: Visit a packing-info.java file. We currently don't support package level annotations, * but if we did and they impacted canonical model generation we would pick them up here. We * should never hit this visit since we filter out package elements, and package elements can not * be referenced from classes. */ @Override public MetadataClass visitPackage(PackageElement packageElement, MetadataClass metadataClass) { processingEnv .getMessager() .printMessage(Kind.NOTE, "ElementVisitor Package NOT IMPLEMENTED : " + packageElement); return null; }
@Override public Writer newResource(String resourcePath) throws IOException { return processingEnv .getFiler() .createResource(StandardLocation.CLASS_OUTPUT, "", resourcePath) .openWriter(); }
@Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); String option = processingEnv.getOptions().get("rootOverride"); if (option != null) { setRootOverride(Arrays.asList(option.split(","))); } }
private boolean isValidElementFound(String typeName) { try { @Nullable TypeElement typeElement = processing.getElementUtils().getTypeElement(typeName); return typeElement != null && typeElement.asType().getKind() != TypeKind.ERROR; } catch (Exception e) { // type loading problem return false; } }
/** * Returns the java version. * * @param env the environment. * @return java version */ public static double getJavaVersion(ProcessingEnvironment env) { String version = env.getOptions().get(Options.JAVA_VERSION); if (version != null) { try { return Double.valueOf(version); } catch (NumberFormatException ignored) { } } return javaVersion; }
/** * Default constructor for ProcessorContext. Sets all settings to their default values. * * @param processingEnv the ProcessingEnvironment which is provided by the Java Annotation * Processor */ public ProcessorContext(final ProcessingEnvironment processingEnv) { System.out.println(processingEnv.getOptions()); final Map<String, String> options = OptionsSplitter.splitOptions(processingEnv.getOptions()); System.out.println(options); this.processingEnv = processingEnv; this.debug = getBoolean(options, DEBUG, false); this.acceptJavaPersistenceAnnotations = getBoolean(options, ACCEPT_JAVA_PERSISTENCE_ANNOTATIONS, false); setAbstractBuilderClassPrefix(options.get(BUILDER_CLASS_PREFIX)); setBuilderClassPostfix(options.get(BUILDER_CLASS_POSTFIX)); setBuildMethodName(options.get(BUILD_METHOD_NAME)); setMethodPrefix(options.get(METHOD_PREFIX)); setStaticCreate(getBoolean(options, GENERATE_STATIC_CREATE_METHOD, true)); setStaticCreateMethodName(options.get(STATIC_CREATE_METHOD_NAME)); setVarArgsForCollections(getBoolean(options, GENERATE_VARARGS_FOR_COLLECTIONS, true)); setIgnoredClassPrefix(options.get(IGNORED_CLASS_PREFIX)); setUseIndefiniteArticles(getBoolean(options, USE_INDEFINITE_ARTICLES, true)); setIgnoreFields(options.get(IGNORE_FIELDS)); }
/** * @param env the environment * @param annUtil utils * @param d the method */ public MethodHandler( final ProcessingEnvironment env, final AnnUtil annUtil, final ExecutableElement d) { this.env = env; this.annUtil = annUtil; msg = env.getMessager(); staticMethod = d.getModifiers().contains(Modifier.STATIC); methName = d.getSimpleName().toString(); getter = methName.startsWith("get"); setter = methName.startsWith("set"); immutable = d.getAnnotation(Immutable.class) != null; CloneForOverride cfo = d.getAnnotation(CloneForOverride.class); cloneForOverride = cfo != null; if (cloneForOverride) { cloneCollectionType = cfo.cloneCollectionType(); cloneElementType = cfo.cloneElementType(); } returnType = d.getReturnType(); returnsVoid = env.getTypeUtils().getNoType(TypeKind.VOID).equals(returnType); pars = d.getParameters(); thrownTypes = d.getThrownTypes(); if ((setter) && (pars != null) && (pars.size() == 1)) { fieldType = pars.iterator().next().asType(); basicType = fieldType.getKind().isPrimitive(); } if (getter) { fieldType = returnType; basicType = returnType.getKind().isPrimitive(); } if (setter || getter) { ucFieldName = methName.substring(3); fieldName = ucFieldName.substring(0, 1).toLowerCase() + ucFieldName.substring(1); } }
/** * Whether the specified element is assignable to the fqTn parameter * * @param processingEnvironment The environment this runs in * @param fqTn THe fully qualified type name of the element we want to check * @param element The element to check that implements * @return true if element implements the fqTn */ public static boolean isSubclass( ProcessingEnvironment processingEnvironment, String fqTn, TypeElement element) { TypeElement typeElement = processingEnvironment.getElementUtils().getTypeElement(fqTn); if (typeElement == null) { processingEnvironment .getMessager() .printMessage( Diagnostic.Kind.ERROR, "Type Element was null for: " + fqTn + "" + "ensure that the visibility of the class is not private."); return false; } else { TypeMirror classMirror = typeElement.asType(); return classMirror != null && element != null && element.asType() != null && processingEnvironment.getTypeUtils().isSubtype(element.asType(), classMirror); } }
@Override public void writeFieldWriteStatement(VariableElement field, JavaWriter writer) throws IOException { DeclaredType type = (DeclaredType) field.asType(); TypeMirror itemType = type.getTypeArguments().get(0); TypeMirror itemTypeErasure = processingEnv.getTypeUtils().erasure(itemType); writer.beginControlFlow("if (object.%s != null)", field.getSimpleName()); writer.emitStatement( "%1$s.writeCollectionToBundle(object.%2$s, bundle, %3$s.class, \"%2$s\")", CollectionBundler.class.getCanonicalName(), field.getSimpleName(), itemTypeErasure); writer.endControlFlow(); }
@Test public void testBuilderPackage() { // Given: TypeElement pojoTypeElement = env.getElementUtils().getTypeElement(ADDRESS_DTO_CLASSNAME); // When: Output output = underTest.produce(new Input(pojoTypeElement)); BuilderM builder = output.getBuilder(); // Then: assertEquals("builder classname", "AddressDTOBuilder", builder.getType().getSimpleName()); assertEquals("package", "testdata.builder", builder.getType().getPackage()); }
/** * Velocity の実行(Javaソース用)。出力先はパッケージ名とクラス名から自動生成。 * * @param context VelocityContext * @param pkgName パッケージ名 * @param clsName クラス名 * @param templ Velocityテンプレート名。 * @throws Exception */ protected void applyTemplate( VelocityContext context, String pkgName, String clsName, String templ) throws Exception { context.put("packageName", pkgName); context.put("className", clsName); context.put("environment", environment); Template template = getVelocityTemplate(templ); Filer filer = environment.getFiler(); JavaFileObject file = filer.createSourceFile(pkgName + '.' + clsName); PrintWriter writer = new PrintWriter(file.openWriter()); template.merge(context, writer); writer.close(); }
private void assembleAttributeDeclaration(Writer w, AttributeInfo ai) throws IOException { // TODO: default value w.append( "<xsd:attribute name=\"" + ai.getXMLName() + "\" type=\"" + ai.getXSDType(processingEnv.getTypeUtils()) + "\" " + (ai.isRequired() ? "use=\"required\"" : "") + ">\r\n"); assembleDocumentation(w, ai); w.append("</xsd:attribute>\r\n"); }
public Option<IRClass> find(AndroidManifest manifest) { Elements elementUtils = processingEnv.getElementUtils(); String rClass = getRClassPackageName(manifest) + ".R"; TypeElement rType = elementUtils.getTypeElement(rClass); if (rType == null) { LOGGER.error("The generated {} class cannot be found", rClass); return Option.absent(); } LOGGER.info("Found project R class: {}", rType.toString()); return Option.<IRClass>of(new RClass(rType)); }
public ValidateDescriptor(ModelDescriptor modelDescriptor, Element field) { super(modelDescriptor, field); this.validateIf = field.getAnnotation(ValidateIf.class); this.validateIfValue = field.getAnnotation(ValidateIfValue.class); ProcessingEnvironment processingEnv = modelDescriptor.getProcessingEnvironment(); Types typeUtils = processingEnv.getTypeUtils(); this.isMethodValidation = getField().getKind().equals(ElementKind.METHOD); if (this.isMethodValidation) { // Make sure our method validation returns a boolean value if (!((ExecutableElement) this.field).getReturnType().getKind().equals(TypeKind.BOOLEAN)) { modelDescriptor .getMessager() .printMessage( Diagnostic.Kind.ERROR, "Methods annotated with @Validate must return a boolean value!", field); } methodAnnotation = getField().getAnnotation(Validate.class); if (this.methodAnnotation == null) { modelDescriptor .getMessager() .printMessage(Diagnostic.Kind.ERROR, "Could not retrieve method validation annotation"); } } else { this.isList = typeUtils.isAssignable( field.asType(), typeUtils.getDeclaredType( processingEnv .getElementUtils() .getTypeElement(ListContainer.class.getCanonicalName()), typeUtils.getWildcardType(null, null))); } }