Java ILanguagePathService类代码示例

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject
public JpsSpoofaxMetaBuilder(
        final LanguageSpecBuilder builder,
        final ILanguageManager languageManager,
        final IMetaborgConfigService extensionService,
        final ILanguagePathService languagePathService,
        final IDependencyService dependencyService,
        final SpoofaxProcessorRunner processorRunner,
        final BuilderMessageFormatter messageFormatter,
        final IJpsProjectService projectService,
        final ISpoofaxLanguageSpecService languageSpecService
) {
    this.builder = builder;
    this.languageManager = languageManager;
    this.extensionService = extensionService;
    this.languagePathService = languagePathService;
    this.dependencyService = dependencyService;
    this.processorRunner = processorRunner;
    this.messageFormatter = messageFormatter;
    this.projectService = projectService;
    this.languageSpecService = languageSpecService;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
public static void init(Injector newInjector) {
    if(injector != null) {
        return;
    }

    injector = newInjector;
    resourceService = newInjector.getInstance(IResourceService.class);
    languageService = newInjector.getInstance(ILanguageService.class);
    languageIdentifierService = newInjector.getInstance(ILanguageIdentifierService.class);
    languagePathService = newInjector.getInstance(ILanguagePathService.class);
    projectService = newInjector.getInstance(IProjectService.class);
    languageSpecService = newInjector.getInstance(ISpoofaxLanguageSpecService.class);
    sourceTextService = newInjector.getInstance(ISourceTextService.class);
    unitService = newInjector.getInstance(ISpoofaxUnitService.class);
    syntaxService = newInjector.getInstance(ISpoofaxSyntaxService.class);
    termFactoryService = newInjector.getInstance(ITermFactoryService.class);
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public LanguageSpecBuilder(Injector injector, IResourceService resourceService,
    ISourceTextService sourceTextService, ILanguageIdentifierService languageIdentifierService,
    IDependencyService dependencyService, ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner,
    Set<IBuildStep> buildSteps, ILanguageComponentConfigBuilder componentConfigBuilder,
    ILanguageComponentConfigWriter componentConfigWriter) {
    this.injector = injector;
    this.resourceService = resourceService;
    this.sourceTextService = sourceTextService;
    this.languageIdentifierService = languageIdentifierService;
    this.dependencyService = dependencyService;
    this.languagePathService = languagePathService;
    this.runner = runner;
    this.componentConfigBuilder = componentConfigBuilder;
    this.componentConfigWriter = componentConfigWriter;
    this.buildSteps = buildSteps;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public Builder(IResourceService resourceService, ILanguageIdentifierService languageIdentifier,
    ILanguagePathService languagePathService, IUnitService<I, P, A, AU, TP, TA> unitService,
    ISourceTextService sourceTextService, ISyntaxService<I, P> syntaxService, IContextService contextService,
    IAnalysisService<P, A, AU> analysisService, ITransformService<P, A, TP, TA> transformService,
    IParseResultUpdater<P> parseResultUpdater, IAnalysisResultUpdater<P, A> analysisResultUpdater,
    Provider<IBuildOutputInternal<P, A, AU, T>> buildOutputProvider) {
    this.resourceService = resourceService;
    this.languageIdentifier = languageIdentifier;
    this.languagePathService = languagePathService;
    this.unitService = unitService;
    this.sourceTextService = sourceTextService;
    this.syntaxService = syntaxService;
    this.contextService = contextService;
    this.analysisService = analysisService;
    this.transformService = transformService;

    this.parseResultUpdater = parseResultUpdater;
    this.analysisResultUpdater = analysisResultUpdater;

    this.buildOutputProvider = buildOutputProvider;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public LocalAnalyzeCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
                                   ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner, IStrategoCommon strategoCommon,
                                   ProjectPathDelegate languageSpecPathDelegate, InputDelegate inputDelegate, LanguagesDelegate languagesDelegate) {
    super(sourceTextService, dependencyService, languagePathService, runner, strategoCommon, languageSpecPathDelegate,
        inputDelegate);
    this.languagesDelegate = languagesDelegate;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public LocalParseCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
                                 ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner, IStrategoCommon strategoCommon,
                                 ProjectPathDelegate projectPathDelegate, InputDelegate inputDelegate, LanguagesDelegate languagesDelegate) {
    super(sourceTextService, dependencyService, languagePathService, runner, strategoCommon, projectPathDelegate,
        inputDelegate);
    this.languagesDelegate = languagesDelegate;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public LocalTransformCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
                                     ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner,
                                     IStrategoCommon strategoTransformerCommon, ProjectPathDelegate languageSpecPathDelegate, InputDelegate inputDelegate,
                                     LanguagesDelegate languagesDelegate) {
    super(sourceTextService, dependencyService, languagePathService, runner, strategoTransformerCommon,
            languageSpecPathDelegate, inputDelegate);
    this.languagesDelegate = languagesDelegate;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public BuildCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
    ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner,
    ProjectPathDelegate projectPathDelegate) {
    this.sourceTextService = sourceTextService;
    this.dependencyService = dependencyService;
    this.languagePathService = languagePathService;
    this.runner = runner;
    this.projectPathDelegate = projectPathDelegate;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
public AnalyzeCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
    ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner, IStrategoCommon strategoCommon,
    ProjectPathDelegate projectPathDelegate, InputDelegate inputDelegate) {
    this.sourceTextService = sourceTextService;
    this.dependencyService = dependencyService;
    this.languagePathService = languagePathService;
    this.runner = runner;
    this.strategoCommon = strategoCommon;
    this.projectPathDelegate = projectPathDelegate;
    this.inputDelegate = inputDelegate;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public ParseCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
    ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner, IStrategoCommon strategoCommon,
    ProjectPathDelegate projectPathDelegate, InputDelegate inputDelegate) {
    this.sourceTextService = sourceTextService;
    this.dependencyService = dependencyService;
    this.languagePathService = languagePathService;
    this.runner = runner;
    this.strategoCommon = strategoCommon;
    this.projectPathDelegate = projectPathDelegate;
    this.inputDelegate = inputDelegate;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public TransformCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
    ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner,
    IStrategoCommon strategoTransformerCommon, ProjectPathDelegate projectPathDelegate,
    InputDelegate inputDelegate) {
    this.sourceTextService = sourceTextService;
    this.dependencyService = dependencyService;
    this.languagePathService = languagePathService;
    this.runner = runner;
    this.common = strategoTransformerCommon;
    this.projectPathDelegate = projectPathDelegate;
    this.inputDelegate = inputDelegate;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public RemoteParseCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
                                  ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner, IStrategoCommon strategoCommon,
                                  ProjectPathDelegate projectPathDelegate, InputDelegate inputDelegate, ILanguageService languageService) {
    super(sourceTextService, dependencyService, languagePathService, runner, strategoCommon, projectPathDelegate,
        inputDelegate);
    this.languageService = languageService;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public RemoteTransformCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
                                      ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner,
                                      IStrategoCommon strategoTransformerCommon, ProjectPathDelegate languageSpecPathDelegate, InputDelegate inputDelegate,
                                      ILanguageService languageService) {
    super(sourceTextService, dependencyService, languagePathService, runner, strategoTransformerCommon,
            languageSpecPathDelegate, inputDelegate);
    this.languageService = languageService;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
@Inject public RemoteAnalyzeCommand(ISourceTextService sourceTextService, IDependencyService dependencyService,
                                    ILanguagePathService languagePathService, ISpoofaxProcessorRunner runner, IStrategoCommon strategoCommon,
                                    ProjectPathDelegate languageSpecPathDelegate, InputDelegate inputDelegate, ILanguageService languageService) {
    super(sourceTextService, dependencyService, languagePathService, runner, strategoCommon, languageSpecPathDelegate,
        inputDelegate);
    this.languageService = languageService;
}
 

import org.metaborg.core.build.paths.ILanguagePathService; //导入依赖的package包/类
/**
 * Instantiate the MetaBorg API.
 * 
 * @param loader
 *            Module plugin loader to use.
 * @param module
 *            MetaBorg module to use.
 * @param additionalModules
 *            Additional modules to use.
 * 
 * @throws MetaborgException
 *             When loading plugins or dependency injection fails.
 */
@SuppressWarnings("unchecked") public MetaBorg(IModulePluginLoader loader, MetaborgModule module,
    Module... additionalModules) throws MetaborgException {
    final Collection<Module> metaborgModules = Lists.newArrayList(additionalModules);
    metaborgModules.add(module);
    final Iterable<Module> modules = InjectorFactory.modules(loader, metaborgModules);
    this.injector = InjectorFactory.create(modules);

    this.autoCloseables = (Set<AutoCloseable>) injector.getInstance(Key.get(Types.setOf(AutoCloseable.class)));

    this.resourceService = injector.getInstance(IResourceService.class);
    this.languageService = injector.getInstance(ILanguageService.class);
    this.languageComponentFactory = injector.getInstance(ILanguageComponentFactory.class);
    this.languageDiscoveryService = injector.getInstance(ILanguageDiscoveryService.class);
    this.languageIdentifierService = injector.getInstance(ILanguageIdentifierService.class);
    this.languagePathService = injector.getInstance(ILanguagePathService.class);
    this.dialectProcessor = injector.getInstance(IDialectProcessor.class);

    this.contextService = injector.getInstance(IContextService.class);

    this.dependencyService = injector.getInstance(IDependencyService.class);
    this.projectService = injector.getInstance(IProjectService.class);

    this.sourceTextService = injector.getInstance(ISourceTextService.class);

    this.editorRegistry = injector.getInstance(IEditorRegistry.class);
}