MembersPopulatingContext.java

package jetbrains.mps.baseLanguage.scopes;

/*Generated by MPS */

import java.util.Stack;
import org.jetbrains.mps.openapi.model.SNode;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import jetbrains.mps.baseLanguage.behavior.IClassifierType__BehaviorDescriptor;
import jetbrains.mps.internal.collections.runtime.Sequence;
import java.util.Iterator;
import jetbrains.mps.baseLanguage.behavior.IClassifier__BehaviorDescriptor;
import jetbrains.mps.internal.collections.runtime.MapSequence;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations;
import org.jetbrains.mps.openapi.model.SModel;
import jetbrains.mps.util.JavaNameUtil;
import jetbrains.mps.lang.smodel.generator.smodelAdapter.SLinkOperations;
import jetbrains.mps.smodel.adapter.structure.MetaAdapterFactory;
import java.util.Collections;

public class MembersPopulatingContext {
  private Stack<SNode> classifiers = new Stack<SNode>();
  private boolean isPackageProtectedAvailable = true;
  private final List<SNode> members = new ArrayList<SNode>();
  private final Map<Signature, SNode> addedSignatures = new HashMap<Signature, SNode>();
  private Map<SNode, SNode> typeByTypeVariable = new HashMap<SNode, SNode>();
  private Map<Object, Object> userObjects = new HashMap<Object, Object>();
  public MembersPopulatingContext() {
    // java collections for speed 
  }
  public void hideMembers(Signature signature) {
    if (!(addedSignatures.containsKey(signature))) {
      addedSignatures.put(signature, getCurrentClassifier());
    }
  }
  public void addMember(SNode member, Signature signature) {
    SNode contextClassifier = addedSignatures.get(signature);
    if (contextClassifier == null || contextClassifier == getCurrentClassifier()) {
      // exposing all members using following condition: 
      // 1. member was not "masked" by a member from sub-classifier 
      // 2. showing all members with same signatures if they are defined in the same classifier 
      members.add(member);
    }
  }
  public Iterable<SNode> getMembers() {
    List<SNode> members = new ArrayList<SNode>();
    members.addAll(this.members);
    return members;
  }
  public void putUserObject(Object key, Object value) {
    userObjects.put(key, value);
  }
  public Object getUserObject(Object key) {
    return userObjects.get(key);
  }
  public boolean containsUserObject(Object key) {
    return userObjects.containsKey(key);
  }
  public boolean enterClassifierInternal(SNode classifierType) {
    SNode classifier = IClassifierType__BehaviorDescriptor.getClassifier_id6r77ob2URY9.invoke(classifierType);

    // recursion preventing 
    if (classifiers.contains(classifier)) {
      return false;
    }
    classifiers.add(classifier);

    // set types variables 
    Iterable<SNode> typeParams = IClassifierType__BehaviorDescriptor.getTypeParameters_id6r77ob2URYe.invoke(classifierType);
    if (Sequence.fromIterable(typeParams).isNotEmpty()) {
      Iterator<SNode> typeVars = Sequence.fromIterable(IClassifier__BehaviorDescriptor.getTypeVariables_id6r77ob2URXZ.invoke(classifier)).iterator();
      for (SNode typeParm : typeParams) {
        if (!(typeVars.hasNext())) {
          break;
        }
        SNode typeVar = typeVars.next();
        MapSequence.fromMap(typeByTypeVariable).put(typeVar, typeParm);
      }
    }

    // recalc is package protected available 
    isPackageProtectedAvailable = true;
    String contextClassifierPackage = retrievePackageName(SNodeOperations.getModel(classifiers.get(0)));
    for (SNode inheritedClassifier : classifiers) {
      if (!(retrievePackageName(SNodeOperations.getModel(inheritedClassifier)).equals(contextClassifierPackage))) {
        isPackageProtectedAvailable = false;
        break;
      }
    }

    return true;
  }
  private String retrievePackageName(SModel model) {
    return (model != null ? JavaNameUtil.packageName(model) : "");
  }
  public void exitClassifierInternal(SNode classifier) {
    assert classifiers.pop() == IClassifierType__BehaviorDescriptor.getClassifier_id6r77ob2URY9.invoke(classifier);
  }
  private SNode getCurrentClassifier() {
    return classifiers.lastElement();
  }
  public boolean isPackageProtectedVisible() {
    return isPackageProtectedAvailable;
  }
  public boolean isPrivateVisible() {
    return classifiers.size() == 1;
  }
  public boolean isElementVisible(SNode element) {
    if (SNodeOperations.isInstanceOf(SLinkOperations.getTarget(element, MetaAdapterFactory.getContainmentLink(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x112670d273fL, 0x112670d886aL, "visibility")), MetaAdapterFactory.getConcept(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x10af9586f0cL, "jetbrains.mps.baseLanguage.structure.PrivateVisibility"))) {
      return isPrivateVisible();
    }
    if ((SLinkOperations.getTarget(element, MetaAdapterFactory.getContainmentLink(0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x112670d273fL, 0x112670d886aL, "visibility")) == null)) {
      return isPackageProtectedVisible();
    }
    return true;
  }
  public Map<SNode, SNode> getTypeByTypeVariableMapping() {
    return Collections.unmodifiableMap(typeByTypeVariable);
  }
}