@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;
}
