コード例 #1
0
 /** Wraps a JavaFileObject in a UsageAsInputReportingJavaFileObject, shares existing instances. */
 private JavaFileObject map(JavaFileObject item) {
   if (item == null) {
     return item;
   }
   InputUsageRecord usage = inputUsageRecords.get(item.toUri());
   if (usage == null) {
     usage = new InputUsageRecord(item);
     inputUsageRecords.put(item.toUri(), usage);
   }
   return new UsageAsInputReportingJavaFileObject(item, usage);
 }
コード例 #2
0
 /** Returns the name of JavaFileObject, similar to {@link java.io.File#getName} */
 public static String getName(final JavaFileObject fo, final boolean noExt) {
   assert fo != null;
   if (fo instanceof Base) {
     Base baseFileObject = (Base) fo;
     if (noExt) {
       return baseFileObject.getName();
     } else {
       StringBuilder sb = new StringBuilder();
       sb.append(baseFileObject.getName());
       sb.append('.'); // NOI18N
       sb.append(baseFileObject.getExt());
       return sb.toString();
     }
   }
   try {
     final URL url = fo.toUri().toURL();
     String path = url.getPath();
     int index1 = path.lastIndexOf('/'); // NOI18N
     int len;
     if (noExt) {
       final int index2 = path.lastIndexOf('.'); // NOI18N
       if (index2 > index1) {
         len = index2;
       } else {
         len = path.length();
       }
     } else {
       len = path.length();
     }
     path = path.substring(index1 + 1, len);
     return path;
   } catch (MalformedURLException e) {
     return null;
   }
 }
コード例 #3
0
  private String getPackage(JavaFileObject file) throws IOException {
    Iterable<? extends File> prefixes =
        ((JavacFileManager) fileManager).getLocation(StandardLocation.SOURCE_PATH);

    // Figure out the package name by stripping the "-src" prefix and
    // extracting
    // the package part of the fullname.

    String filePath = file.toUri().getPath();
    // go absolute
    filePath = new File(filePath).getCanonicalPath();

    int srcDirLength = 0;
    for (File prefixFile : prefixes) {
      String prefix = prefixFile.getCanonicalPath();
      if (filePath.startsWith(prefix) && prefix.length() > srcDirLength) {
        srcDirLength = prefix.length();
      }
    }

    if (srcDirLength > 0) {
      String fullname = filePath.substring(srcDirLength);
      assert fullname.endsWith(".ceylon");
      fullname = fullname.substring(0, fullname.length() - ".ceylon".length());
      fullname = fullname.replace(File.separator, ".");
      if (fullname.startsWith(".")) fullname = fullname.substring(1);
      String packageName = Convert.packagePart(fullname);
      if (!packageName.equals("")) return packageName;
    }
    return null;
  }
コード例 #4
0
  private void createBeanInfo(TypeElement classElement) throws Exception {
    if (verbose) {
      processingEnv
          .getMessager()
          .printMessage(
              Diagnostic.Kind.NOTE, "Generating BeanInfo for " + classElement.getSimpleName());
    }

    String className = classElement.getSimpleName().toString();
    String qualifiedName = classElement.getQualifiedName().toString();
    PackageElement packageElement = (PackageElement) classElement.getEnclosingElement();
    String packageName = packageElement.getQualifiedName().toString();

    Map<String, VariableElement> fields = new HashMap<String, VariableElement>();

    Writer writer = null;

    try {
      // Build Bean Info
      TypeElement curClassElement = classElement;
      do {

        for (Element e : curClassElement.getEnclosedElements()) {
          if (e.getKind().equals(ElementKind.FIELD)
              && !e.getModifiers().contains(Modifier.TRANSIENT)
              && !e.getModifiers().contains(Modifier.STATIC)) {

            fields.put(e.getSimpleName().toString(), (VariableElement) e);
          }
        }

        TypeMirror t = curClassElement.getSuperclass();
        if (t instanceof DeclaredType) {
          curClassElement = (TypeElement) ((DeclaredType) t).asElement();
        } else {
          curClassElement = null;
        }

      } while (curClassElement != null);
      VelocityContext vc = new VelocityContext();
      vc.put("className", className);
      vc.put("packageName", packageName);
      vc.put("fields", fields);
      // Create source file
      JavaFileObject jfo = processingEnv.getFiler().createSourceFile(qualifiedName + "BeanInfo");
      if (verbose) {
        processingEnv
            .getMessager()
            .printMessage(Diagnostic.Kind.NOTE, "creating source file: " + jfo.toUri());
      }
      writer = jfo.openWriter();
      template.merge(vc, writer);
    } finally {
      closeQuietly(writer);
    }
  }
コード例 #5
0
  void emitApplication(ProcessingContext env, ApplicationMetaModel application)
      throws ProcessingException {
    PackageElement elt = env.get(application.getHandle());
    FQN fqn = new FQN(application.getName(), "Application");

    //
    Writer writer = null;
    try {
      JavaFileObject applicationFile = env.createSourceFile(fqn, elt);
      writer = applicationFile.openWriter();

      writer.append("package ").append(fqn.getPackageName()).append(";\n");

      // Imports
      writer.append("import ").append(Tools.getImport(ApplicationDescriptor.class)).append(";\n");

      // Open class
      writer.append("public class ").append(fqn.getSimpleName()).append(" {\n");

      // Field
      writer.append("private final ").append(APPLICATION_DESCRIPTOR).append(" descriptor;\n");

      // Constructor
      writer.append("public ").append(fqn.getSimpleName()).append("() throws Exception {\n");
      writer
          .append("this.descriptor = ")
          .append(APPLICATION_DESCRIPTOR)
          .append(".create(getClass());\n");
      writer.append("}\n");

      // Getter
      writer.append("public ").append(APPLICATION_DESCRIPTOR).append(" getDescriptor() {\n");
      writer.append("return descriptor;\n");
      writer.append("}\n");

      // Close class
      writer.append("}\n");

      //
      env.log("Generated application " + fqn.getName() + " as " + applicationFile.toUri());
    } catch (IOException e) {
      throw TemplateMetaModel.CANNOT_WRITE_APPLICATION.failure(e, elt, application.getName());
    } finally {
      Tools.safeClose(writer);
    }
  }
コード例 #6
0
ファイル: LoadingSJFM.java プロジェクト: holl-/W2
  public JavaFileObject getJavaFileForOutput(
      Location location, String className, Kind kind, FileObject sibling) throws IOException {
    JavaFileObject object =
        standardJavaFileManager.getJavaFileForOutput(location, className, kind, sibling);

    if (kind == Kind.CLASS) {
      className = className.replace("/", ".");
      String enclosingClassName = className.split("\\$")[0];
      String sourceFileName =
          enclosingClassName.substring(enclosingClassName.lastIndexOf(".") + 1) + ".java";
      Optional<PluginSource> source = result.findSource(sourceFileName);
      Path binaryFile = Paths.get(object.toUri());
      URL binaryURL = binaryFile.toUri().toURL();
      PluginBinary binary = new PluginBinary(binaryURL, source, Optional.of(className));
      result.getBinaries().add(binary);
    }
    return object;
  }
コード例 #7
0
 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
   final CompilerMessage.Kind kind;
   switch (diagnostic.getKind()) {
     case ERROR:
       kind = BuildMessage.Kind.ERROR;
       myErrorCount++;
       break;
     case MANDATORY_WARNING:
     case WARNING:
     case NOTE:
       kind = BuildMessage.Kind.WARNING;
       myWarningCount++;
       break;
     default:
       kind = BuildMessage.Kind.INFO;
   }
   File sourceFile = null;
   try {
     // for eclipse compiler just an attempt to call getSource() may lead to an NPE,
     // so calling this method under try/catch to avoid induced compiler errors
     final JavaFileObject source = diagnostic.getSource();
     sourceFile = source != null ? Utils.convertToFile(source.toUri()) : null;
   } catch (Exception e) {
     LOG.info(e);
   }
   final String srcPath =
       sourceFile != null ? FileUtil.toSystemIndependentName(sourceFile.getPath()) : null;
   String message = diagnostic.getMessage(Locale.US);
   if (Utils.IS_TEST_MODE) {
     LOG.info(message);
   }
   myContext.processMessage(
       new CompilerMessage(
           BUILDER_NAME,
           kind,
           message,
           srcPath,
           diagnostic.getStartPosition(),
           diagnostic.getEndPosition(),
           diagnostic.getPosition(),
           diagnostic.getLineNumber(),
           diagnostic.getColumnNumber()));
 }
コード例 #8
0
  private File getSingleOutputDirectory(final Location loc, final JavaFileObject sourceFile) {
    if (loc == StandardLocation.CLASS_OUTPUT) {
      if (myOutputsMap.size() > 1 && sourceFile != null) {
        // multiple outputs case
        final File outputDir = findOutputDir(new File(Paths.toURI(sourceFile.toUri().getPath())));
        if (outputDir != null) {
          return outputDir;
        }
      }
    }

    final Iterable<? extends File> location = getStdManager().getLocation(loc);
    if (location != null) {
      final Iterator<? extends File> it = location.iterator();
      if (it.hasNext()) {
        return it.next();
      }
    }
    return null;
  }
コード例 #9
0
  // Dump classfiles onto disk for all compilation units that where successful
  // and do not carry a -d none spec, either directly or inherited from Main.
  @Override
  public void outputClassFiles(CompilationResult unitResult) {
    if (!((unitResult == null) || (unitResult.hasErrors() && !this.proceedOnError))) {
      ClassFile[] classFiles = unitResult.getClassFiles();
      boolean generateClasspathStructure =
          this.fileManager.hasLocation(StandardLocation.CLASS_OUTPUT);
      String currentDestinationPath = this.destinationPath;
      File outputLocation = null;
      if (currentDestinationPath != null) {
        outputLocation = new File(currentDestinationPath);
        outputLocation.mkdirs();
      }
      for (int i = 0, fileCount = classFiles.length; i < fileCount; i++) {
        // retrieve the key and the corresponding classfile
        ClassFile classFile = classFiles[i];
        char[] filename = classFile.fileName();
        int length = filename.length;
        char[] relativeName = new char[length + 6];
        System.arraycopy(filename, 0, relativeName, 0, length);
        System.arraycopy(SuffixConstants.SUFFIX_class, 0, relativeName, length, 6);
        CharOperation.replace(relativeName, '/', File.separatorChar);
        String relativeStringName = new String(relativeName);
        if (this.compilerOptions.verbose) {
          EclipseCompilerImpl.this.out.println(
              Messages.bind(
                  Messages.compilation_write,
                  new String[] {
                    String.valueOf(this.exportedClassFilesCounter + 1), relativeStringName
                  }));
        }
        try {
          JavaFileObject javaFileForOutput =
              this.fileManager.getJavaFileForOutput(
                  StandardLocation.CLASS_OUTPUT,
                  new String(filename),
                  JavaFileObject.Kind.CLASS,
                  this.javaFileObjectMap.get(unitResult.compilationUnit));

          if (generateClasspathStructure) {
            if (currentDestinationPath != null) {
              int index = CharOperation.lastIndexOf(File.separatorChar, relativeName);
              if (index != -1) {
                File currentFolder =
                    new File(currentDestinationPath, relativeStringName.substring(0, index));
                currentFolder.mkdirs();
              }
            } else {
              // create the subfolfers is necessary
              // need a way to retrieve the folders to create
              String path = javaFileForOutput.toUri().getPath();
              int index = path.lastIndexOf('/');
              if (index != -1) {
                File file = new File(path.substring(0, index));
                file.mkdirs();
              }
            }
          }

          OutputStream openOutputStream = javaFileForOutput.openOutputStream();
          BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(openOutputStream);
          bufferedOutputStream.write(classFile.header, 0, classFile.headerOffset);
          bufferedOutputStream.write(classFile.contents, 0, classFile.contentsOffset);
          bufferedOutputStream.flush();
          bufferedOutputStream.close();
        } catch (IOException e) {
          this.logger.logNoClassFileCreated(currentDestinationPath, relativeStringName, e);
        }
        this.logger.logClassFile(
            generateClasspathStructure, currentDestinationPath, relativeStringName);
        this.exportedClassFilesCounter++;
      }
      this.batchCompiler.lookupEnvironment.releaseClassFiles(classFiles);
    }
  }
コード例 #10
0
ファイル: JavaSourceClassLoader.java プロジェクト: Bio7/bio7
  private void markError(
      DiagnosticCollector<JavaFileObject> diagnosticsCollector, boolean markerCreation) {

    for (Diagnostic diagnostic : diagnosticsCollector.getDiagnostics()) {
      System.out.format("Error on line %d" + " -> ", diagnostic.getLineNumber(), diagnostic);
      System.out.println(diagnostic.getMessage(null) + "\n");
      System.err.println("*** " + diagnostic.toString() + " *** " + diagnostic.getCode());
      JavaFileObject source = (JavaFileObject) diagnostic.getSource();
      String longFileName = source == null ? null : source.toUri().getPath();
      // String shortFileName = source == null ? null : source.getName();

      // System.out.println("Error in: " + longFileName);
      // Path path = new Path(longFileName);
      // IFile ifile =
      // ResourcesPlugin.getWorkspace().getRoot().getFile(path);
      if (diagnostic.getLineNumber() > -1) {
        File fileToOpen = new File(longFileName);

        if (fileToOpen.exists() && fileToOpen.isFile()) {
          final IFileStore fileStore = EFS.getLocalFileSystem().getStore(fileToOpen.toURI());

          Display display = PlatformUI.getWorkbench().getDisplay();
          display.syncExec(
              new Runnable() {

                public void run() {

                  try {
                    IEditorPart part = IDE.openEditorOnFileStore(pag, fileStore);

                    if (part != null) {
                      IEditorInput input = part.getEditorInput();
                      ifile = ((IFileEditorInput) input).getFile();

                      // ... use activeProjectName
                    }

                  } catch (PartInitException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                  }
                }
              });

        } else {
          // Do something if the file does not exist
        }
      }

      // System.out.format("Error on line %d in %s"+"\n",
      // diagnostic.getLineNumber(), diagnostic);
      if (markerCreation == true) {
        int lnr = (int) diagnostic.getLineNumber();
        int startPos = (int) diagnostic.getStartPosition();
        int stopPos = (int) diagnostic.getEndPosition();
        if (ifile != null) {
          IMarker marker;
          try {
            marker = ifile.createMarker(IMarker.PROBLEM);
            marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
            marker.setAttribute(IMarker.MESSAGE, diagnostic.getMessage(null));
            marker.setAttribute(IMarker.LINE_NUMBER, lnr);
            // if (pos.offset != 0) {
            // System.out.println(startPos);
            // System.out.println(stopPos);

            marker.setAttribute(IMarker.CHAR_START, startPos);
            marker.setAttribute(IMarker.CHAR_END, stopPos - 1);
          } catch (CoreException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
        }
      }
    }
  }
コード例 #11
0
ファイル: JavaBridge.java プロジェクト: jeroenpeeters/rascal
  /**
   * Save a compiled class and associated classes to a jar file.
   *
   * <p>With a packageName = "" and recursive = false, it will save clazz and any classes compiled
   * from the same source (I think); this is probably what you want.
   *
   * @param packageName package name prefix to search for classes, or "" for all
   * @param clazz a class that has been previously compiled by this bridge
   * @param mainClazz a class that will be installed as the "Main-Class" of a runnable jar
   * @param outStream output stream
   * @param recursive whether to retrieve classes from rest of the the JavaFileManager hierarchy
   * @throws FileNotFoundException
   * @throws IOException
   */
  public void saveToJar(
      String packageName,
      Class<?> clazz,
      Class<?> mainClazz,
      OutputStream outStream,
      boolean recursive)
      throws IOException {
    JavaFileManager manager = fileManagerCache.get(clazz);
    List<JavaFileObject> list = new ArrayList<JavaFileObject>();

    for (JavaFileObject obj :
        manager.list(
            StandardLocation.CLASS_PATH,
            packageName,
            Collections.singleton(JavaFileObject.Kind.CLASS),
            false)) list.add(obj);

    if (list.iterator().hasNext()) {
      Manifest manifest = new Manifest();
      manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");

      if (mainClazz != null) {
        manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, mainClazz.getName());
      }
      manifest
          .getMainAttributes()
          .put(new Attributes.Name("X-Rascal-Saved-Class"), clazz.getName());
      JarOutputStream target = new JarOutputStream(outStream, manifest);
      JarEntry entry = new JarEntry("META-INF/");
      target.putNextEntry(entry);
      Collection<String> dirs = new ArrayList<String>();

      for (JavaFileObject o : list) {
        String path = o.toUri().getPath().replace(".", "/");
        makeJarDirs(target, dirs, path);
        entry = new JarEntry(path + ".class");
        entry.setTime(o.getLastModified());
        target.putNextEntry(entry);

        try (InputStream stream = o.openInputStream()) {
          byte[] buffer = new byte[8192];
          int c = stream.read(buffer);
          while (c > -1) {
            target.write(buffer, 0, c);
            c = stream.read(buffer);
          }
        }
        target.closeEntry();
      }

      if (mainClazz != null) {
        String name = mainClazz.getName();
        String path = name.replace(".", "/") + ".class";

        String dir = path.substring(0, path.lastIndexOf('/'));
        StringBuilder dirTmp = new StringBuilder(dir.length());
        for (String d : dir.split("/")) {
          dirTmp.append(d);
          dirTmp.append("/");
          String tmp = dirTmp.toString();
          if (!dirs.contains(tmp)) {
            dirs.add(tmp);
            entry = new JarEntry(tmp);
            target.putNextEntry(entry);
          }
        }
        entry = new JarEntry(path);
        target.putNextEntry(entry);

        try (InputStream stream = mainClazz.getClassLoader().getResourceAsStream(path)) {
          byte[] buffer = new byte[8192];
          int c = stream.read(buffer);
          while (c > -1) {
            target.write(buffer, 0, c);
            c = stream.read(buffer);
          }
        }
        target.closeEntry();
      }

      target.close();
    }
  }
コード例 #12
0
  @SuppressWarnings({"unchecked", "ConstantConditions"})
  private void manageType(TypeElement enclosingElement, Logger logger) {

    // Make sure we don't process twice the same type
    String simpleName = enclosingElement.getSimpleName().toString();
    String qualifiedName = enclosingElement.getQualifiedName().toString();
    String packageName = Utils.getElementPackageName(enclosingElement);
    if (managedTypes.contains(qualifiedName)) return;
    managedTypes.add(qualifiedName);

    // Prepare the output file
    try {
      JavaFileObject classFile =
          processingEnv.getFiler().createSourceFile(qualifiedName + INJECTOR_SUFFIX);
      logger.note("Writing " + classFile.toUri().getRawPath());
      Writer out = classFile.openWriter();
      JavaWriter writer = new JavaWriter(out);

      writer.emitPackage(packageName);

      // Initial imports
      writer
          .emitImports(AsyncService.class, Injector.class, Message.class, Set.class, HashSet.class)
          .emitImports(
              "com.joanzapata.android.asyncservice.api.annotation.OnMessage.Priority",
              "android.os.Handler",
              "android.os.Looper")
          .emitStaticImports(
              "com.joanzapata.android.asyncservice.api.annotation.OnMessage.Priority.*");

      // Generates "public final class XXXInjector extends Injector<XXX>"
      writer
          .emitEmptyLine()
          .beginType(
              simpleName + INJECTOR_SUFFIX,
              "class",
              of(PUBLIC, FINAL),
              "Injector<" + simpleName + ">");

      // Generate a handler to execute runnables on the UI Thread
      writer
          .emitEmptyLine()
          .emitField(
              "Handler", "__handler", of(PRIVATE, FINAL), "new Handler(Looper.getMainLooper())");

      // Keep trace of when a method has received data which is not from cache
      writer
          .emitEmptyLine()
          .emitField(
              "Set<String>",
              "__receivedFinalResponses",
              of(PRIVATE, FINAL),
              "new HashSet<String>()");

      // Generates "protected void inject(XXX target) { ..."
      writer
          .emitEmptyLine()
          .emitAnnotation(Override.class)
          .beginMethod("void", "inject", of(PROTECTED), simpleName, "target");

      // Here, inject all services
      List<Element> elementsAnnotatedWith =
          findElementsAnnotatedWith(enclosingElement, InjectService.class);
      for (Element element : elementsAnnotatedWith) {
        if (isPublicOrPackagePrivate(element)) {
          writer.emitStatement(
              "target.%s = new %s(target)",
              element.getSimpleName(),
              element.asType().toString() + AsyncServiceAP.GENERATED_CLASS_SUFFIX);
        }
      }

      // End of inject()
      writer.endMethod().emitEmptyLine();

      // Generates "protected void dispatch(XXX target, Message event)"
      writer
          .emitAnnotation(Override.class)
          .beginMethod(
              "void",
              "dispatch",
              of(PROTECTED),
              "final " + simpleName,
              "target",
              "final " + Message.class.getSimpleName(),
              "event",
              Priority.class.getSimpleName(),
              "priority");

      // Once the user has received a "remote" result, make sure no cache is sent anymore
      writer
          .emitField(
              "boolean",
              "__hasBeenReceivedAlready",
              of(FINAL),
              "event.getQuery() != null && __receivedFinalResponses.contains(event.getQuery())")
          .emitStatement("if (event.isCached() && __hasBeenReceivedAlready) return")
          .emitStatement(
              "if (!__hasBeenReceivedAlready && !event.isCached() && priority == LAST) __receivedFinalResponses.add(event.getQuery())");

      // Here, dispatch events to methods
      List<Element> responseReceivers =
          findElementsAnnotatedWith(enclosingElement, OnMessage.class);
      for (Element responseReceiver : responseReceivers) {
        ExecutableElement annotatedMethod = (ExecutableElement) responseReceiver;
        AnnotationMirror annotationMirror = getAnnotation(annotatedMethod, OnMessage.class);
        List<? extends VariableElement> parameters = annotatedMethod.getParameters();

        if (parameters.size() > 1)
          logger.error(
              responseReceiver, "@OnMessage annotated methods can't have more than 1 argument");

        // Define event type given parameter or @InjectResponse value
        List<String> eventTypes;
        boolean hasArg = parameters.size() == 1;
        if (hasArg) {
          TypeMirror typeMirror = parameters.get(0).asType();
          eventTypes = asList(typeMirror.toString());
          if (hasTypeParameters(processingEnv, typeMirror))
            logger.error(
                parameters.get(0),
                "You can't receive typed parameters in @OnMessage annotated methods");

        } else {
          List<AnnotationValue> parameterTypeClasses =
              getAnnotationValue(annotationMirror, "value");

          // Validate each parameter type given in the annotation
          eventTypes = new ArrayList<String>();
          for (AnnotationValue value : parameterTypeClasses) {
            DeclaredType parameterTypeClass = (DeclaredType) value.getValue();
            if (parameterTypeClass == null)
              logger.error(
                  annotatedMethod, "Either declare an argument or give @OnMessage a value.");
            if (hasTypeParameters(processingEnv, parameterTypeClass))
              logger.error(
                  annotatedMethod,
                  annotationMirror,
                  "value",
                  "You can't receive typed parameters in @OnMessage method");
            eventTypes.add(parameterTypeClass.toString());
          }
        }

        // Define whether we should check emitter or not dependeing on the annotation value
        VariableElement from = getAnnotationValue(annotationMirror, "from");
        boolean checkEmitter = !ALL.toString().equals("" + from);

        // Check the priority of the method
        VariableElement priorityValue = getAnnotationValue(annotationMirror, "priority");
        Priority priority = !LAST.toString().equals("" + priorityValue) ? FIRST : LAST;
        writer.beginControlFlow("if (priority == %s)", priority);

        // Write the code to call the user method
        if (checkEmitter) writer.beginControlFlow("if (event.getEmitter() == getTarget())");

        // Create a new inner class for the Runnable to run on UI thread
        StringWriter buffer = new StringWriter();
        JavaWriter inner = new JavaWriter(buffer);
        inner
            .emitPackage("")
            .beginType("Runnable()", "new")
            .emitAnnotation("Override")
            .beginMethod("void", "run", of(PUBLIC));
        if (hasArg)
          inner.emitStatement(
              "target.%s((%s) event.getPayload())",
              annotatedMethod.getSimpleName(), eventTypes.get(0));
        else inner.emitStatement("target.%s()", annotatedMethod.getSimpleName());
        inner.endMethod().endType();

        // For each type (can be multiple)
        for (int i = 0; i < eventTypes.size(); i++) {
          String eventType = eventTypes.get(i);
          writer
              .beginControlFlow(
                  "%sif (event.getPayload() instanceof %s)", i != 0 ? "else " : "", eventType)
              .emitStatement("__handler.post(%s)", buffer.toString())
              .endControlFlow();
        }

        if (checkEmitter) writer.endControlFlow();
        writer.endControlFlow();
      }

      // End of inject();
      writer.endMethod().emitEmptyLine();

      // End of file
      writer.endType();
      out.flush();
      out.close();
    } catch (IOException e) {
      throw new IllegalStateException("Error while create the injector for " + qualifiedName, e);
    }
  }