Java 类org.eclipse.xtext.generator.JavaIoFileSystemAccess 实例源码

@Before
public void setup() throws Exception {
    temporaryOutputDirectory = Files.createTempDir();
    temporaryOutputDirectory.deleteOnExit();
    InvocationArguments arguments = new InvocationArguments();
    arguments.setGenerationLanguage("java");
    arguments.setModelPath("src/test/resources");
    arguments.setOutputPath(temporaryOutputDirectory.getAbsolutePath());

    Injector francaInjector = new FrancaIDLStandaloneSetup().createInjectorAndDoEMFRegistration()
                                                            .createChildInjector(new AbstractModule() {

                                                                @Override
                                                                protected void configure() {
                                                                    bind(IFileSystemAccess.class).to(JavaIoFileSystemAccess.class);
                                                                }
                                                            });
    francaInjector.injectMembers(this);
    generator = new JoynrJavaGenerator();
    Injector injector = francaInjector.createChildInjector(generator.getGeneratorModule());
    injector.injectMembers(this);
    injector.injectMembers(generator);
    FileSystemAccessUtil.createFileSystemAccess(outputFileSystem, arguments.getOutputPath());
}

protected void generate(final List<Resource> sourceResources) {
  final GeneratorContext context = new GeneratorContext();
  context.setCancelIndicator(CancelIndicator.NullImpl);
  for (final Resource it : sourceResources) {
    {
      String _lastSegment = it.getURI().lastSegment();
      String _plus = ("Starting generator for input: \'" + _lastSegment);
      String _plus_1 = (_plus + "\'");
      StandaloneBuilder.LOG.info(_plus_1);
      this.registerCurrentSource(it.getURI());
      final LanguageAccess access = this.languageAccess(it.getURI());
      final JavaIoFileSystemAccess fileSystemAccess = this.getFileSystemAccess(access);
      boolean _isWriteStorageResources = this.isWriteStorageResources();
      if (_isWriteStorageResources) {
        boolean _matched = false;
        if (it instanceof StorageAwareResource) {
          IResourceStorageFacade _resourceStorageFacade = ((StorageAwareResource)it).getResourceStorageFacade();
          boolean _tripleNotEquals = (_resourceStorageFacade != null);
          if (_tripleNotEquals) {
            _matched=true;
            ((StorageAwareResource)it).getResourceStorageFacade().saveResource(((StorageAwareResource)it), fileSystemAccess);
          }
        }
      }
      access.getGenerator().generate(it, fileSystemAccess, context);
    }
  }
}

private JavaIoFileSystemAccess getFileSystemAccess(final LanguageAccess language) {
  JavaIoFileSystemAccess fsa = this.configuredFsas.get(language);
  if ((fsa == null)) {
    File _file = new File(this.baseDir);
    fsa = language.createFileSystemAccess(_file);
    fsa = this.configureFileSystemAccess(fsa, language);
    this.configuredFsas.put(language, fsa);
  }
  return fsa;
}

public Executor(final InvocationArguments arguments) throws ClassNotFoundException,
                                                    InstantiationException,
                                                    IllegalAccessException {
    arguments.checkArguments();
    this.arguments = arguments;

    // Get an injector and inject into the current instance
    Injector francaInjector = new FrancaIDLStandaloneSetup().createInjectorAndDoEMFRegistration();

    // Use a child injector that contains configuration parameters passed to this Executor
    Injector injector = francaInjector.createChildInjector(new AbstractModule() {
        @Override
        protected void configure() {
            bind(IFileSystemAccess.class).to(JavaIoFileSystemAccess.class);
            String generationId = arguments.getGenerationId();
            if (generationId != null) {
                bindConstant().annotatedWith(Names.named("generationId")).to(generationId);
            } else {
                // Guice does not allow null binding - use an empty string to show there is no generationId
                bindConstant().annotatedWith(Names.named("generationId")).to("");
            }
            bind(Boolean.class).annotatedWith(Names.named(JoynrGeneratorExtensions.JOYNR_GENERATOR_GENERATE))
                               .toInstance(arguments.generate());
            bind(Boolean.class).annotatedWith(Names.named(JoynrGeneratorExtensions.JOYNR_GENERATOR_CLEAN))
                               .toInstance(arguments.clean());
        }
    });
    this.outputFileSystem = injector.getInstance(IFileSystemAccess.class);
    this.generator = createGenerator(injector);
}

/**
 * Private constructor to prevent accidental instantiation.
 */
@Inject
private N4HeadlessCompiler(JavaIoFileSystemAccess fsa) {
    this.fsa = fsa;
}

public Class<? extends AbstractFileSystemAccess2> bindAbstractFileSystemAccess2() {
    return JavaIoFileSystemAccess.class;
}

public JavaIoFileSystemAccess createFileSystemAccess(final File baseDir) {
    JavaIoFileSystemAccess fsa = resourceServiceProvider.get(JavaIoFileSystemAccess.class);
    configureFileSystemAccess(baseDir, fsa);
    return fsa;
}

protected Class<JavaIoFileSystemAccess> bindJavaIoFileSystemAccess() {
  return JavaIoFileSystemAccess.class;
}

protected JavaIoFileSystemAccess configureFileSystemAccess(final JavaIoFileSystemAccess fsa, final LanguageAccess language) {
  return fsa;
}

public Class<? extends AbstractFileSystemAccess2> bindAbstractFileSystemAccess2() {
    return JavaIoFileSystemAccess.class;
}

public Class<? extends AbstractFileSystemAccess2> bindAbstractFileSystemAccess2() {
    return JavaIoFileSystemAccess.class;
}

private void resetGenerationSettings(final String projectPath, final String path) {
  GenerationStep.javaPackagePrefix = SensIDLConstants.JAVA_PROJECT_PACKAGE_PREFIX;
  String _filePathOf = this.getFilePathOf(path);
  FileGenerationStep.setFilePath(_filePathOf);
  ((JavaIoFileSystemAccess) this.fsa).setOutputPath(projectPath);
}

/**
 * Start the Code generator
 * 
 * @param path
 *            the path where the files will be saves
 * @param modelPath
 *            the path to the model form with the code will be generated
 * @param language
 *            the language in which the Code will be generated
 * @return true if the code was generated
 * @throws NoSidlFileException
 *             Throws this Exception when the given file is not a sidl file
 * @throws FileNotFoundException
 *             Throws this Exception when there is no file at the given path
 * 
 */
public static boolean generate(String path, String modelPath, String language, Resource sensidlmodel)
        throws NoSidlFileException, FileNotFoundException {
    setGenerationLanguage(language);
    Injector injector = new SensidlStandaloneSetup().createInjectorAndDoEMFRegistration();

    // get resource
    Resource resource = null;
    if (sensidlmodel != null) {
        resource = sensidlmodel;
    } else {
        ResourceSet rs = new ResourceSetImpl();
        File file = new File(modelPath);

        // Exception handling for not existing input files
        if (!file.exists()) {
            throw new FileNotFoundException("File not found");
        }
        // Exception handling for input files in the wrong format
        if (!FilenameUtils.getExtension(modelPath).equals("sidl")) {
            throw new NoSidlFileException("No SIDL file found");
        }

        resource = rs.getResource(URI.createURI(file.toURI().toString()), true);
    }
    // Use the JavaIoFileSystemAccess and set the path
    final JavaIoFileSystemAccess fsa = new JavaIoFileSystemAccess();
    fsa.setOutputPath(path);

    generator = injector.getInstance(SensidlGenerator.class); // set up the
    // generator
    generator.setGenerationLanguage(generationLanguage);

    // inject fsa
    Guice.createInjector(new AbstractGenericModule() {
        @SuppressWarnings("unused")
        public Class<? extends IEncodingProvider> bindIEncodingProvider() {
            return IEncodingProvider.Runtime.class;
        }
    }).injectMembers(fsa);

    // generate
    generator.doGenerate(resource, fsa);

    return true;

}