@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 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 unregisterModules(MPSModuleOwner owner, Condition<SModule> condition) {
Collection<SModule> modulesToRemove = new ArrayList<SModule>();
for (SModule module : REPO.getModules(owner)) {
if (condition.met(module)) {
modulesToRemove.add(module);
}
}
REPO.unregisterModules(modulesToRemove, owner);
}
public <T extends SModule> Collection<T> getAllModules(Class<T> cls) {
List<T> result = new ArrayList<T>();
for (SModule module : REPO.getAllModules()) {
if (cls.isInstance(module)) result.add((T) module);
}
return result;
}
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;
}
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 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);
}
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);
}
public <T extends SModule> Collection<T> getModules(
MPSModuleOwner moduleOwner, @Nullable Class<T> cls) {
Set<SModule> modules = REPO.getModules(moduleOwner);
if (modules == null) return Collections.emptyList();
List<T> list = new LinkedList<T>();
for (SModule m : modules) {
if (cls == null || cls.isInstance(m)) {
list.add((T) m);
}
}
return list;
}
@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();
}
}
});
}
// intended to use only when module is removed physically
public void removeModuleForced(SModule module) {
Set<MPSModuleOwner> owners = new HashSet<MPSModuleOwner>(REPO.getOwners(module));
for (MPSModuleOwner owner : owners) {
REPO.unregisterModule(module, owner);
}
}
@Override
public void dispose() {
// TODO unregister listeners?
myRepositoryListener.unsubscribeFrom(MPSModuleRepository.getInstance());
INSTANCE = null;
}
public <T extends SModule> T getModule(String fqName, Class<T> cls) {
SModule m = REPO.getModuleByFqName(fqName);
if (!cls.isInstance(m)) return null;
return (T) m;
}
public SModule getModule(@NotNull SModuleReference ref) {
return ref.getModuleId() != null
? REPO.getModuleById(ref.getModuleId())
: REPO.getModuleByFqName(ref.getModuleName());
}
public Set<MPSModuleOwner> getModuleOwners(SModule module) {
return new HashSet<MPSModuleOwner>(REPO.getOwners(module));
}
public void unregisterModules(MPSModuleOwner owner) {
REPO.unregisterModules(new HashSet<SModule>(REPO.getModules(owner)), owner);
}
