@Override public SModule resolve(SModuleReference reference) { if (reference == null) { return null; } SModule module; if (reference.getModuleId() != null) { module = MPSModuleRepository.getInstance().getModule(reference.getModuleId()); } else { module = MPSModuleRepository.getInstance().getModuleByFqName(reference.getModuleName()); } if (module == null) { return null; } synchronized (LOCK) { initialize(); if (myVisibleModules.contains(module) || myUsedLanguages.contains(module) || myUsedDevkits.contains(module)) { return module; } else { return null; } } }
protected boolean checkLibraryName(String libraryName) { if (MPSModuleRepository.getInstance().getModuleByUID(libraryName) != null) { myThis.getDialog().setErrorText("Duplicate library name: " + libraryName); return false; } return true; }
private static <T extends AbstractModule> T registerModule(T module, MPSModuleOwner moduleOwner) { T registered = MPSModuleRepository.getInstance().registerModule(module, moduleOwner); if (registered == module) { // we can't do it in AbstractModule#attach because we need module without models in // SRepositoryListener#moduleAdded event registered.reloadAfterDescriptorChange(); } return registered; }
protected void removeSolution(String name) { ModuleReference ref = new ModuleReference(null, ModuleId.foreign(name)); MPSModuleRepository repository = MPSModuleRepository.getInstance(); IModule m = ModuleRepositoryFacade.getInstance().getModule(ref); if (m == null) { return; } repository.unregisterModule(m, this); }
public void createModule(final SModule module) { if (myModuleMap.containsKey(module)) { return; } final TransientModelsModule transientModelsModule = new TransientModelsModule(module, TransientModelsProvider.this); MPSModuleRepository.getInstance().registerModule(transientModelsModule, myOwner); myModuleMap.put(module, transientModelsModule); }
protected void addListeners() { VirtualFileManager.getInstance().addVirtualFileManagerListener(myRefreshListener); SModelRepository.getInstance().addModelRepositoryListener(mySModelRepositoryListener); ModelAccess.instance().addCommandListener(myModelAccessListener); MPSModuleRepository.getInstance().addModuleRepositoryListener(myRepositoryListener); if (IMakeService.INSTANCE.isSessionActive()) { IMakeService.INSTANCE.get().addListener(myMakeNotificationListener); } ClassLoaderManager.getInstance().addReloadHandler(myReloadListener); }
protected void removeListeners() { ClassLoaderManager.getInstance().removeReloadHandler(myReloadListener); SModelRepository.getInstance().removeModelRepositoryListener(mySModelRepositoryListener); ModelAccess.instance().removeCommandListener(myModelAccessListener); MPSModuleRepository.getInstance().removeModuleRepositoryListener(myRepositoryListener); if (IMakeService.INSTANCE.hasMakeService()) { IMakeService.INSTANCE.get().removeListener(myMakeNotificationListener); } VirtualFileManager.getInstance().removeVirtualFileManagerListener(myRefreshListener); }
@Override public SModel resolve(SRepository repo) { if (myModuleReference != null) { final SRepository repository; if (repo == null) { // see StaticReference, which seems to be the only place we pass null as repository repository = MPSModuleRepository.getInstance(); } else { repository = repo; } Computable<SModel> c = new Computable<SModel>() { @Override public SModel compute() { SModule module = repository.getModule(myModuleReference.getModuleId()); if (module == null) { return null; } return module.getModel(myModelId); } }; if (!repository.getModelAccess().canRead()) { LOG.warn( "Attempt to resolve a model not from read action. What are you going to do with return value? Hint: at least, read. Please ensure proper model access then.", new Throwable()); return new ModelAccessHelper(repository).runReadAction(c); } else { return c.compute(); } } // FIXME !!! use supplied SRepository, not global model repo !!! // If there's no module reference, and model id is global, it's supposed we shall get the model // from a global repository. // However, at the moment, there's no easy way to get model from SRepository (other than to // iterate over all modules and models, // which doesn't sound like a good approach). Either shall provide method to find model from // SRepository, or drop // 'globally unique' model id altogether. What's the benefit of them? // NOTE, shall tolerate null repo unless every single piece of code that expects StaticReference // of a newly created node // hanging in the air to resolve. @see StaticReference#getTargetSModel return SModelRepository.getInstance().getModelDescriptor(this); }
@Override public void init() { if (INSTANCE != null) { throw new IllegalStateException("double initialization"); } INSTANCE = this; myRepositoryListener.subscribeTo(MPSModuleRepository.getInstance()); GlobalSModelEventsManager.getInstance() .addGlobalCommandListener( new SModelCommandListener() { @Override public void eventsHappenedInCommand(List<SModelEvent> events) { for (SModelEvent e : events) { if (!LanguageAspect.STRUCTURE.is(e.getModelDescriptor())) continue; invalidateCache(); } } }); }
@Override public void dispose() { // TODO unregister listeners? myRepositoryListener.unsubscribeFrom(MPSModuleRepository.getInstance()); INSTANCE = null; }