package jetbrains.mps.smodel.persistence.def.v4;
/*Generated by MPS */
import jetbrains.mps.logging.Logger;
import org.apache.log4j.LogManager;
import org.jdom.Element;
import jetbrains.mps.smodel.DefaultSModel;
import org.jdom.Document;
import jetbrains.mps.smodel.SModelHeader;
import jetbrains.mps.smodel.SModelVersionsInfo;
import org.jetbrains.mps.openapi.model.SModelReference;
import jetbrains.mps.vcspersistence.VCSPersistenceUtil;
import jetbrains.mps.vcspersistence.VCSPersistenceSupport;
import java.util.List;
import jetbrains.mps.smodel.SModelLegacy;
import org.jetbrains.mps.openapi.persistence.PersistenceFacade;
import jetbrains.mps.smodel.SModel;
import java.util.ArrayList;
import jetbrains.mps.smodel.persistence.def.IReferencePersister;
import org.jetbrains.mps.openapi.model.SNode;
import jetbrains.mps.smodel.persistence.def.VisibleModelElements;
import org.jetbrains.annotations.Nullable;
import jetbrains.mps.vcspersistence.SNodeFactory;
import org.jetbrains.mps.openapi.model.SNodeId;
import org.jetbrains.mps.openapi.model.SNodeAccessUtil;
import jetbrains.mps.util.SNodeOperations;
public class ModelReader4 implements IModelReader {
private static final Logger LOG = Logger.wrap(LogManager.getLogger(ModelReader4.class));
protected String getLegacyImportedModelUIDString(Element element) {
return null;
}
protected ReferencePersister4 createReferencePersister() {
return new ReferencePersister4();
}
@Override
public DefaultSModel readModel(Document document, SModelHeader header) {
SModelVersionsInfo versionsInfo = new SModelVersionsInfo();
Element rootElement = document.getRootElement();
SModelReference modelReference = VCSPersistenceUtil.createModelReference(rootElement.getAttributeValue(VCSPersistenceSupport.MODEL_UID));
DefaultSModel model = new DefaultSModel(modelReference, header);
// languages
List languages = rootElement.getChildren(VCSPersistenceSupport.LANGUAGE);
for (Object language : languages) {
Element element = (Element) language;
String languageNamespace = element.getAttributeValue(VCSPersistenceSupport.NAMESPACE);
new SModelLegacy(model).addLanguage(PersistenceFacade.getInstance().createModuleReference(languageNamespace));
List<Element> aspectElements = element.getChildren(VCSPersistenceSupport.LANGUAGE_ASPECT);
// aspect models versions
readLanguageAspects(model, aspectElements);
}
// additional aspects
List<Element> aspectElements = rootElement.getChildren(VCSPersistenceSupport.LANGUAGE_ASPECT);
readLanguageAspects(model, aspectElements);
// languages engaged on generation
List languagesEOG = rootElement.getChildren(VCSPersistenceSupport.LANGUAGE_ENGAGED_ON_GENERATION);
for (Object languageEOG : languagesEOG) {
Element element = (Element) languageEOG;
String languageNamespace = element.getAttributeValue(VCSPersistenceSupport.NAMESPACE);
new SModelLegacy(model).addEngagedOnGenerationLanguage(PersistenceFacade.getInstance().createModuleReference(languageNamespace));
}
// devkits
List devkits = rootElement.getChildren(VCSPersistenceSupport.DEVKIT);
for (Object devkit : devkits) {
Element element = (Element) devkit;
String devkitNamespace = element.getAttributeValue(VCSPersistenceSupport.NAMESPACE);
model.addDevKit(PersistenceFacade.getInstance().createModuleReference(devkitNamespace));
}
// imports
List imports = rootElement.getChildren(VCSPersistenceSupport.IMPORT_ELEMENT);
for (Object anImport : imports) {
Element element = (Element) anImport;
String indexValue = element.getAttributeValue(VCSPersistenceSupport.MODEL_IMPORT_INDEX, element.getAttributeValue("referenceID"));
int importIndex = Integer.parseInt(indexValue);
String importedModelUIDString = element.getAttributeValue(VCSPersistenceSupport.MODEL_UID);
if (importedModelUIDString == null) {
// read in old manner...
importedModelUIDString = getLegacyImportedModelUIDString(element);
}
if (importedModelUIDString == null) {
LOG.error("Error loading import element for index " + importIndex + " in " + model.getReference());
continue;
}
SModelReference importedModelReference = VCSPersistenceUtil.createModelReference(importedModelUIDString);
model.addModelImport(new SModel.ImportElement(importedModelReference, importIndex, -1));
}
ArrayList<IReferencePersister> referenceDescriptors = new ArrayList<IReferencePersister>();
readRefactorings(rootElement, model);
// nodes
List children = rootElement.getChildren(VCSPersistenceSupport.NODE);
for (Object child : children) {
Element element = (Element) child;
SNode snode = readNode(element, model, referenceDescriptors, false, versionsInfo);
if (snode != null) {
model.addRootNode(snode);
}
}
VisibleModelElements visibleModelElements = new DOMVisibleModelElements(rootElement);
for (IReferencePersister referencePersister : referenceDescriptors) {
referencePersister.createReferenceInModel(model, visibleModelElements);
}
return model;
}
protected void readRefactorings(Element rootElement, DefaultSModel model) {
rootElement.getChild("refactoringHistory");
// no-op, we do not care about refactorings in that old persistence versions
}
protected void readLanguageAspects(DefaultSModel model, List<Element> aspectElements) {
for (Element aspectElement : aspectElements) {
String aspectModelUID = aspectElement.getAttributeValue(VCSPersistenceSupport.MODEL_UID);
String versionString = aspectElement.getAttributeValue(VCSPersistenceSupport.VERSION);
int version = -1;
if (versionString != null) {
try {
version = Integer.parseInt(versionString);
} catch (Throwable t) {
LOG.error(t);
}
}
if (aspectModelUID != null) {
model.getImplicitImportsSupport().addAdditionalModelVersion(VCSPersistenceUtil.createModelReference(aspectModelUID), version);
}
}
}
public SNode readNode(Element nodeElement, SModel model) {
return readNode(nodeElement, model, true, null, new SModelVersionsInfo());
}
@Nullable
protected SNode readNode(Element nodeElement, SModel model, boolean useUIDs, VisibleModelElements visibleModelElements, SModelVersionsInfo versionsInfo) {
List<IReferencePersister> referenceDescriptors = new ArrayList<IReferencePersister>();
SNode result = readNode(nodeElement, model, referenceDescriptors, useUIDs, versionsInfo);
for (IReferencePersister referencePersister : referenceDescriptors) {
referencePersister.createReferenceInModel(model, visibleModelElements);
}
return result;
}
@Nullable
protected SNode readNode(Element nodeElement, SModel model, List<IReferencePersister> referenceDescriptors, boolean useUIDs, SModelVersionsInfo versionsInfo) {
String rawFqName = nodeElement.getAttributeValue(VCSPersistenceSupport.TYPE);
String conceptFqName = VersionUtil.getConceptFQName(rawFqName);
jetbrains.mps.smodel.SNode node = SNodeFactory.newRegular(conceptFqName);
VersionUtil.fetchConceptVersion(rawFqName, node, versionsInfo);
String idValue = nodeElement.getAttributeValue(VCSPersistenceSupport.ID);
if (idValue != null) {
SNodeId id = jetbrains.mps.smodel.SNodeId.fromString(idValue);
if (id == null) {
LOG.error("invalid id string");
return null;
}
node.setId(id);
}
List properties = nodeElement.getChildren(VCSPersistenceSupport.PROPERTY);
for (Object property : properties) {
Element propertyElement = (Element) property;
String raw = propertyElement.getAttributeValue(VCSPersistenceSupport.NAME);
String propertyName = VersionUtil.getPropertyName(raw, node, versionsInfo);
String propertyValue = propertyElement.getAttributeValue(VCSPersistenceSupport.VALUE);
if (propertyValue != null) {
SNodeAccessUtil.setProperty(node, propertyName, propertyValue);
}
}
List links = nodeElement.getChildren(VCSPersistenceSupport.LINK);
for (Object link : links) {
Element linkElement = (Element) link;
ReferencePersister4 referencePersister = createReferencePersister();
referencePersister.fillFields(linkElement, node, useUIDs, versionsInfo);
referenceDescriptors.add(referencePersister);
}
List childNodes = nodeElement.getChildren(VCSPersistenceSupport.NODE);
for (Object childNode1 : childNodes) {
Element childNodeElement = (Element) childNode1;
String rawRole = childNodeElement.getAttributeValue(VCSPersistenceSupport.ROLE);
String role = VersionUtil.getRole(rawRole);
SNode childNode = readNode(childNodeElement, model, referenceDescriptors, useUIDs, versionsInfo);
if (role == null || childNode == null) {
LOG.errorWithTrace("Error reading child node in node " + SNodeOperations.getDebugText(node));
} else {
node.addChild(role, childNode);
VersionUtil.fetchChildNodeRoleVersion(rawRole, childNode, versionsInfo);
}
}
return node;
}
}