Java ILanguageService类代码示例

import org.metaborg.core.language.ILanguageService; //导入依赖的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.language.ILanguageService; //导入依赖的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.language.ILanguageService; //导入依赖的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.language.ILanguageService; //导入依赖的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.language.ILanguageService; //导入依赖的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);
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
@Inject public LanguageSourceFilesPrimitive(ILanguageService languageService,
    ILanguagePathService languagePathService, IProjectService projectService) {
    super("language_source_files", 0, 1);
    this.languageService = languageService;
    this.languagePathService = languagePathService;
    this.projectService = projectService;
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
@Inject public LegacyForeignCallPrimitive(ILanguageService languageService, IContextService contextService,
    IProjectService projectService, IStrategoCommon common) {
    super("SSL_EXT_foreigncall", 0, 2);

    this.languageService = languageService;
    this.contextService = contextService;
    this.projectService = projectService;
    this.common = common;
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
@Inject public LanguageIncludeFilesPrimitive(ILanguageService languageService,
    ILanguagePathService languagePathService, IProjectService projectService) {
    super("language_include_files", 0, 1);
    this.languageService = languageService;
    this.languagePathService = languagePathService;
    this.projectService = projectService;
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
@Inject public ParsePrimitive(IResourceService resourceService, ILanguageService languageService,
    ILanguageIdentifierService languageIdentifierService, IDialectIdentifier dialectIdentifier,
    ISpoofaxUnitService unitService, ISourceTextService sourceTextService, ISpoofaxSyntaxService syntaxService) {
    super("parse", 0, 4);
    this.resourceService = resourceService;
    this.languageService = languageService;
    this.languageIdentifierService = languageIdentifierService;
    this.dialectIdentifier = dialectIdentifier;
    this.unitService = unitService;
    this.sourceTextService = sourceTextService;
    this.syntaxService = syntaxService;
}
 

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

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
public ILanguageService languageService() {
    return languageService;
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
protected void bindLanguage() {
    bind(ILanguageService.class).to(LanguageService.class).in(Singleton.class);
    bind(ILanguageIdentifierService.class).to(LanguageIdentifierService.class).in(Singleton.class);
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
@Inject public DefaultDependencyService(ILanguageService languageService) {
    this.languageService = languageService;
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
@Inject public SpoofaxProcessorRunner(ISpoofaxProcessor processor, ILanguageService languageService) {
    super(processor, languageService);
}
 

import org.metaborg.core.language.ILanguageService; //导入依赖的package包/类
@Inject public LanguageDiscoveryService(ILanguageService languageService,
    ILanguageComponentFactory componentFactory) {
    this.languageService = languageService;
    this.componentFactory = componentFactory;
}