ReferencePersister4.java

package jetbrains.mps.smodel.persistence.def.v4;

/*Generated by MPS */

import jetbrains.mps.smodel.persistence.def.IReferencePersister;
import jetbrains.mps.logging.Logger;
import org.apache.log4j.LogManager;
import org.jetbrains.mps.openapi.model.SNode;
import org.jdom.Element;
import jetbrains.mps.smodel.SModelVersionsInfo;
import jetbrains.mps.vcspersistence.VCSPersistenceSupport;
import org.jetbrains.mps.openapi.model.SReference;
import jetbrains.mps.smodel.SModel;
import jetbrains.mps.smodel.persistence.def.VisibleModelElements;
import org.jetbrains.mps.openapi.model.SModelReference;
import jetbrains.mps.vcspersistence.VCSPersistenceUtil;
import jetbrains.mps.util.SNodeOperations;
import jetbrains.mps.smodel.DynamicReference;
import jetbrains.mps.smodel.StaticReference;
import jetbrains.mps.smodel.SNodeId;
import org.jetbrains.annotations.Nullable;

public class ReferencePersister4 implements IReferencePersister {
  private static final Logger LOG = Logger.wrap(LogManager.getLogger(ReferencePersister4.class));
  protected SNode mySourceNode;
  protected String myRole;
  protected String myTargetId;
  protected String myResolveInfo;
  protected String myImportedModelInfo = "-1";
  protected boolean myUseUIDs;
  private boolean myNotImported;
  @Override
  public void fillFields(Element linkElement, SNode sourceNode, boolean useUIDs) {
    fillFields(linkElement, sourceNode, useUIDs, new SModelVersionsInfo());
  }
  public void fillFields(Element linkElement, SNode sourceNode, boolean useUIDs, SModelVersionsInfo versionsInfo) {
    fillFields(linkElement.getAttributeValue(VCSPersistenceSupport.ROLE), linkElement.getAttributeValue(VCSPersistenceSupport.RESOLVE_INFO), linkElement.getAttributeValue(VCSPersistenceSupport.TARGET_NODE_ID), sourceNode, useUIDs, versionsInfo);
  }
  public void fillFields(String role_, String resolveInfo, String targetNodeId_, SNode sourceNode, boolean useUIDs, SModelVersionsInfo versionsInfo) {
    String role = VersionUtil.getLinkRole(role_, sourceNode, versionsInfo);
    String attTargetNodeId = VersionUtil.getTargetNodeId(targetNodeId_, role, sourceNode, versionsInfo);
    this.myUseUIDs = useUIDs;
    this.mySourceNode = sourceNode;
    this.myRole = role;
    if (attTargetNodeId != null) {
      ReferencePersister4.ReferenceTargetDescriptor targetDescriptor = parseAttTargetNodeId(attTargetNodeId, useUIDs);
      this.myTargetId = targetDescriptor.targetInfo;
      this.myImportedModelInfo = targetDescriptor.importedModelInfo;
      this.myNotImported = targetDescriptor.notImported;
    }
    this.myResolveInfo = resolveInfo;
  }
  private ReferencePersister4.ReferenceTargetDescriptor parseAttTargetNodeId(String attTargetNodeId, boolean useUIDs) {
    ReferencePersister4.ReferenceTargetDescriptor referenceTargetDescriptor = new ReferencePersister4.ReferenceTargetDescriptor();
    int i;
    if (useUIDs) {
      i = attTargetNodeId.indexOf('#');
    } else {
      i = attTargetNodeId.indexOf('.');
    }
    if (i > 0) {
      referenceTargetDescriptor.importedModelInfo = attTargetNodeId.substring(0, i);
      String info = referenceTargetDescriptor.importedModelInfo;
      if (info.endsWith("v")) {
        referenceTargetDescriptor.notImported = true;
        referenceTargetDescriptor.importedModelInfo = info.substring(0, info.length() - 1);
      }
      referenceTargetDescriptor.targetInfo = attTargetNodeId.substring(i + 1);
    } else {
      referenceTargetDescriptor.importedModelInfo = "-1";
      referenceTargetDescriptor.targetInfo = attTargetNodeId;
    }
    return referenceTargetDescriptor;
  }
  @Override
  public SNode getSourceNode() {
    return mySourceNode;
  }
  @Override
  public String getRole() {
    return myRole;
  }
  @Override
  public String getTargetId() {
    return myTargetId;
  }
  @Override
  public String getResolveInfo() {
    return myResolveInfo;
  }
  @Override
  public String getExtResolveInfo() {
    return null;
  }
  private SReference createReferenceInModelDoNotAddToSourceNode(SModel model, VisibleModelElements visibleModelElements) {
    SModelReference importedModelReference = model.getReference();
    if (myUseUIDs) {
      if (!(myImportedModelInfo.equals("-1"))) {
        importedModelReference = VCSPersistenceUtil.createModelReference(myImportedModelInfo);
      }
    } else
    if (getImportIndex() > -1) {
      if (myNotImported) {
        importedModelReference = visibleModelElements.getModelUID(getImportIndex());
      } else {
        importedModelReference = getImportedModelUID(model, getImportIndex());
      }
      if (importedModelReference == null) {
        LOG.error("couldn't create reference '" + this.getRole() + "' from " + SNodeOperations.getDebugText(this.getSourceNode()) + " : import for index [" + getImportIndex() + "] not found");
        return null;
      }
    }
    if (this.getTargetId() == null) {
      LOG.error("couldn't create reference '" + this.getRole() + "' from " + SNodeOperations.getDebugText(this.getSourceNode()) + " : target node id is null");
      return null;
    }
    if (this.getTargetId().equals("^")) {
      return new DynamicReference(this.getRole(), this.getSourceNode(), importedModelReference, this.getResolveInfo());
    }
    return new StaticReference(this.getRole(), this.getSourceNode(), importedModelReference, SNodeId.fromString(this.getTargetId()), this.getResolveInfo());
  }
  @Nullable
  private static SModelReference getImportedModelUID(SModel sModel, int referenceID) {
    for (SModel.ImportElement importElement : sModel.importedModels()) {
      if (importElement.getReferenceID() == referenceID) {
        return importElement.getModelReference();
      }
    }
    return null;
  }
  @Override
  public void createReferenceInModel(SModel model, VisibleModelElements visibleModelElements) {
    SReference reference = createReferenceInModelDoNotAddToSourceNode(model, visibleModelElements);
    if (reference != null) {
      this.getSourceNode().setReference(reference.getRole(), reference);
    }
  }
  @Override
  public void saveReference(Element parentElement, SReference reference, boolean useUIDs, VisibleModelElements visibleModelElements) {
    // no-op, we do not support serialization in old formats 
  }
  @Override
  public int getImportIndex() {
    try {
      return Integer.parseInt(myImportedModelInfo);
    } catch (NumberFormatException e) {
      return -1;
    }
  }
  @SuppressWarnings(value = {"InstanceVariableNamingConvention"})
  public static class ReferenceTargetDescriptor {
    public boolean notImported = false;
    public String targetInfo;
    public String importedModelInfo;
  }
  @SuppressWarnings(value = {"InstanceVariableNamingConvention"})
  protected static class ReferenceDescriptor {
    public SNode sourceNode;
    public String role;
    public String resolveInfo;
    public String targetNodeId;
  }
}