package jetbrains.mps.smodel.persistence.def;
/*Generated by MPS */
import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import org.jetbrains.mps.openapi.model.SModelReference;
import java.util.Map;
import jetbrains.mps.internal.collections.runtime.MapSequence;
import java.util.HashMap;
import jetbrains.mps.smodel.SModel;
import org.apache.log4j.Level;
import org.jetbrains.mps.openapi.persistence.PersistenceFacade;
import org.jetbrains.annotations.NotNull;
import jetbrains.mps.util.Pair;
import org.jetbrains.mps.openapi.model.SNodeReference;
import org.jetbrains.mps.openapi.model.SNodeId;
import jetbrains.mps.smodel.SNodePointer;
import jetbrains.mps.baseLanguage.tuples.runtime.Tuples;
import jetbrains.mps.smodel.runtime.ConceptKind;
import jetbrains.mps.smodel.runtime.StaticScope;
import jetbrains.mps.baseLanguage.tuples.runtime.MultiTuple;
public class ReadHelper {
private static final Logger LOG = LogManager.getLogger(ReadHelper.class);
private static final char MODEL_SEPARATOR_CHAR = '.';
private static final String DYNAMIC_REFERENCE_ID = "^";
private SModelReference myModelRef;
private Map<String, SModelReference> myModelByIx;
private int myMaxImportIndex = 0;
public ReadHelper(SModelReference modelRef) {
myModelByIx = MapSequence.fromMap(new HashMap<String, SModelReference>());
myModelRef = modelRef;
}
public void addModelRef(String index, SModelReference modelRef) {
MapSequence.fromMap(myModelByIx).put(index, modelRef);
}
public void addImportToModel(SModel model, String index, String modelUID, int version, boolean implicit) {
if (modelUID == null) {
if (LOG.isEnabledFor(Level.ERROR)) {
LOG.error("Error loading import element for index " + index + " in " + myModelRef);
}
return;
}
SModelReference modelRef = PersistenceFacade.getInstance().createModelReference(modelUID);
SModel.ImportElement elem = new SModel.ImportElement(modelRef, ++myMaxImportIndex, version);
if (implicit) {
model.getImplicitImportsSupport().addAdditionalModelVersion(elem);
} else {
model.addModelImport(elem);
}
addModelRef(index, modelRef);
}
public SModelReference getSModelReference(@NotNull String ix) {
return ((ix == null || ix.length() == 0) ? myModelRef : MapSequence.fromMap(myModelByIx).get(ix));
}
@NotNull
public Pair<Boolean, SNodeReference> readLink_internal(String src) {
// returns <true, xxx> - if src is Dynamic Reference
// [modelID.]nodeID | [modelID.]^
Pair<Boolean, SNodeReference> result = new Pair<Boolean, SNodeReference>(false, null);
if (src == null) {
return result;
}
int dotIndex = src.indexOf(MODEL_SEPARATOR_CHAR);
String text = decode(src.substring(dotIndex + 1, src.length()));
result.o1 = DYNAMIC_REFERENCE_ID.equals(text);
SModelReference modelRef = getSModelReference((dotIndex < 0 ? "" : src.substring(0, dotIndex)));
SNodeId nodeId = (result.o1 ? null : jetbrains.mps.smodel.SNodeId.fromString(text));
result.o2 = new SNodePointer(modelRef, nodeId);
return result;
}
public SNodeReference readLinkId(String src) {
// [modelID.]nodeID[:version] | [modelID.]^[:version]
return readLink_internal(src).o2;
}
public boolean isInterfaceNode(String nodeInfo) {
return nodeInfo.startsWith("i");
}
public boolean isImplementationNode(String nodeInfo) {
return nodeInfo != null && (nodeInfo.startsWith("l") || nodeInfo.startsWith("s"));
}
public boolean isImplementationWithStubNode(String nodeInfo) {
return nodeInfo != null && nodeInfo.startsWith("s");
}
public String getStubConceptQualifiedName(String type) {
String originalConcept = readType(type);
int lastDot = originalConcept.lastIndexOf('.');
if (lastDot == -1) {
return null;
}
return originalConcept.substring(0, lastDot + 1) + "Stub" + originalConcept.substring(lastDot + 1);
}
public Tuples._3<ConceptKind, StaticScope, Boolean> readNodeInfo(String s) {
ConceptKind kind;
StaticScope scope;
if (s.length() != 3 && s.length() != 2) {
return null;
}
switch (s.charAt(0)) {
case 'n':
kind = ConceptKind.NORMAL;
break;
case 'i':
kind = ConceptKind.INTERFACE;
break;
case 'l':
kind = ConceptKind.IMPLEMENTATION;
break;
case 's':
kind = ConceptKind.IMPLEMENTATION_WITH_STUB;
break;
default:
return null;
}
switch (s.charAt(1)) {
case 'g':
scope = StaticScope.GLOBAL;
break;
case 'r':
scope = StaticScope.ROOT;
break;
case 'n':
scope = StaticScope.NONE;
break;
default:
return null;
}
boolean unordered = false;
if (s.length() == 3) {
if (s.charAt(2) == 'u') {
unordered = true;
} else {
return null;
}
}
return MultiTuple.<ConceptKind,StaticScope,Boolean>from(kind, scope, unordered);
}
public String readType(String s) {
int ix = s.indexOf(MODEL_SEPARATOR_CHAR);
if (ix <= 0) {
// no model ID - fqName is here
if (LOG.isEnabledFor(Level.ERROR)) {
LOG.error("Broken reference to type=" + s + " in model " + myModelRef);
}
return s.substring(ix + 1);
}
SModelReference modelRef = getSModelReference(s.substring(0, ix));
if (modelRef == null) {
if (LOG.isEnabledFor(Level.ERROR)) {
LOG.error("couldn't create node '" + s.substring(ix + 1) + "' : import for index [" + s.substring(0, ix) + "] not found");
}
return s.substring(ix + 1);
} else {
return modelRef.getName().getLongName() + '.' + s.substring(ix + 1);
}
}
public String readRole(String s) {
return s;
}
public String readName(String s) {
return s;
}
public static String decode(String s) {
return s.replace("%d", ".").replace("%c", ":").replace("%p", "%");
}
}