EvaluationModule.java

package jetbrains.mps.debugger.java.runtime.evaluation.container;

/*Generated by MPS */

import jetbrains.mps.project.AbstractModule;
import org.jetbrains.mps.openapi.module.SModule;
import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import jetbrains.mps.project.structure.modules.ModuleDescriptor;
import java.util.Set;
import jetbrains.mps.internal.collections.runtime.SetSequence;
import java.util.HashSet;
import java.util.concurrent.atomic.AtomicInteger;
import jetbrains.mps.vfs.IFile;
import jetbrains.mps.project.structure.modules.ModuleReference;
import jetbrains.mps.project.ModuleId;
import org.jetbrains.mps.openapi.persistence.ModelRoot;
import org.jetbrains.mps.openapi.persistence.PersistenceFacade;
import jetbrains.mps.persistence.PersistenceRegistry;
import jetbrains.mps.extapi.persistence.FileBasedModelRoot;
import org.jetbrains.mps.openapi.module.SDependency;
import jetbrains.mps.internal.collections.runtime.Sequence;
import jetbrains.mps.internal.collections.runtime.IWhereFilter;
import jetbrains.mps.extapi.module.TransientSModule;
import jetbrains.mps.internal.collections.runtime.ISelector;
import jetbrains.mps.module.SDependencyImpl;
import org.jetbrains.mps.openapi.module.SDependencyScope;
import org.jetbrains.mps.openapi.language.SLanguage;
import java.util.Collection;
import jetbrains.mps.smodel.Language;
import jetbrains.mps.smodel.ModuleRepositoryFacade;
import jetbrains.mps.internal.collections.runtime.CollectionSequence;
import jetbrains.mps.smodel.adapter.MetaAdapterByDeclaration;

/**
 * This module contains a necessary information for the 'evaluate expression'
 * action during a debug session.
 * Currently extends AbstractModule though it is obviously not one.
 */
public final class EvaluationModule extends AbstractModule implements SModule {
  private static final Logger LOG = LogManager.getLogger(EvaluationModule.class);

  private final ModuleDescriptor myDescriptor;
  private final Set<String> myClassPaths = SetSequence.fromSet(new HashSet<String>());
  private static final AtomicInteger ourCounter = new AtomicInteger();

  private static int incCounter() {
    return ourCounter.incrementAndGet();
  }

  public EvaluationModule() {
    super((IFile) null);
    setModuleReference(new ModuleReference("Evaluation Container Module " + incCounter(), ModuleId.regular()));
    myDescriptor = new ModuleDescriptor();
  }

  @Override
  public String toString() {
    return getModuleName() + " [evaluation module]";
  }

  @Override
  public ModuleDescriptor getModuleDescriptor() {
    return myDescriptor;
  }

  @Override
  protected Iterable<ModelRoot> loadRoots() {
    Set<ModelRoot> result = new HashSet<ModelRoot>();
    for (String stub : myClassPaths) {
      ModelRoot modelRoot = PersistenceFacade.getInstance().getModelRootFactory(PersistenceRegistry.JAVA_CLASSES_ROOT).create();
      if (modelRoot instanceof FileBasedModelRoot) {
        ((FileBasedModelRoot) modelRoot).setContentRoot(stub);
        ((FileBasedModelRoot) modelRoot).addFile(FileBasedModelRoot.SOURCE_ROOTS, stub);
      } else {
        LOG.error("Unexpected model root type: " + modelRoot.getType() + " but need 'java_classes' model root");
      }
      result.add(modelRoot);
    }
    return result;
  }

  public String addClassPathItem(String path) {
    if (SetSequence.fromSet(myClassPaths).contains(path)) {
      path = null;
    } else {
      SetSequence.fromSet(myClassPaths).addElement(path);
      myDescriptor.getAdditionalJavaStubPaths().add(path);
    }
    fireChanged();
    return path;
  }

  @Override
  public Iterable<SDependency> getDeclaredDependencies() {
    Iterable<SModule> modules = getRepository().getModules();
    return Sequence.fromIterable(modules).where(new IWhereFilter<SModule>() {
      public boolean accept(SModule it) {
        return it != EvaluationModule.this && !(it instanceof TransientSModule);
      }
    }).select(new ISelector<SModule, SDependencyImpl>() {
      public SDependencyImpl select(SModule it) {
        return (new SDependencyImpl(it, SDependencyScope.DEFAULT, false));
      }
    }).ofType(SDependency.class);
  }

  @Override
  public Set<SLanguage> getUsedLanguages() {
    Collection<Language> languages = new ModuleRepositoryFacade(getRepository()).getAllModules(Language.class);
    return SetSequence.fromSetWithValues(new HashSet<SLanguage>(), CollectionSequence.fromCollection(languages).select(new ISelector<Language, SLanguage>() {
      public SLanguage select(Language it) {
        return MetaAdapterByDeclaration.getLanguage(it);
      }
    }));
  }

  @Override
  public boolean isReadOnly() {
    return false;
  }
}