VCSPersistenceUtil.java

package jetbrains.mps.vcspersistence;

/*Generated by MPS */

import org.jetbrains.mps.openapi.model.SModel;
import org.jetbrains.mps.openapi.persistence.ModelFactory;
import org.jetbrains.mps.openapi.persistence.PersistenceFacade;
import jetbrains.mps.persistence.ByteArrayInputSource;
import java.util.Collections;
import java.io.IOException;
import jetbrains.mps.vfs.IFile;
import java.io.InputStream;
import jetbrains.mps.util.ReadUtil;
import jetbrains.mps.smodel.SModelHeader;
import org.xml.sax.InputSource;
import java.io.ByteArrayInputStream;
import jetbrains.mps.smodel.loading.ModelLoadResult;
import jetbrains.mps.smodel.loading.ModelLoadingState;
import jetbrains.mps.smodel.InvalidSModel;
import jetbrains.mps.smodel.persistence.def.ModelReadException;
import jetbrains.mps.smodel.TrivialModelDescriptor;
import jetbrains.mps.persistence.PersistenceVersionAware;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.mps.openapi.model.SModelReference;
import jetbrains.mps.util.Pair;
import org.jetbrains.mps.openapi.module.SModuleId;
import org.jetbrains.mps.openapi.model.SModelId;
import org.jetbrains.mps.openapi.module.SModuleReference;
import jetbrains.mps.project.structure.modules.ModuleReference;

public class VCSPersistenceUtil {
  public static SModel loadModel(final byte[] content, String extension) {
    // returns null if an error occured, as its predcessor in PersistenceUtil. 
    // [MM] not sure this is correct, just left it unchanged 

    SModel oldModel = loadFromOldMPSPersistence(content);
    if (oldModel != null) {
      return oldModel;
    }

    ModelFactory factory = PersistenceFacade.getInstance().getModelFactory(extension);
    if (factory == null) {
      return null;
    }
    try {
      SModel model = factory.load(new ByteArrayInputSource(content), Collections.singletonMap(ModelFactory.OPTION_CONTENT_ONLY, Boolean.TRUE.toString()));
      model.load();
      return model;
    } catch (IOException ex) {
      return null;
    }
  }

  public static SModel loadModel(IFile file) {
    InputStream input = null;
    try {
      input = file.openInputStream();
      byte[] bytes = ReadUtil.read(input);
      return loadModel(bytes, file.getName().substring(file.getName().lastIndexOf(".")));
    } catch (IOException e) {
      return null;
    } finally {
      if (input != null) {
        try {
          input.close();
        } catch (IOException e) {
          // do nothing 
        }
      }
    }
  }

  private static SModel loadFromOldMPSPersistence(final byte[] content) {
    SModelHeader header;
    try {
      header = VCSPersistenceSupport.loadDescriptor(new InputSource(new ByteArrayInputStream(content)));
    } catch (IOException e) {
      return null;
    }

    try {
      final ModelLoadResult readModel = VCSPersistenceSupport.readModel(header, new ByteArrayInputSource(content), ModelLoadingState.FULLY_LOADED);

      jetbrains.mps.smodel.SModel model = readModel.getModel();
      if (model instanceof InvalidSModel) {
        return null;
      }

      return new VCSPersistenceUtil.MyModel(model, header);
    } catch (ModelReadException e) {
      return null;
    }
  }
  private static class MyModel extends TrivialModelDescriptor implements PersistenceVersionAware {
    private final SModelHeader myHeader;

    public void setPersistenceVersion(int pv) {
      myHeader.setPersistenceVersion(pv);
    }
    public int getPersistenceVersion() {
      return myHeader.getPersistenceVersion();
    }
    @Nullable
    public ModelFactory getModelFactory() {
      return null;
    }
    public MyModel(jetbrains.mps.smodel.SModel readModel, SModelHeader header) {
      super(readModel);
      myHeader = header;
    }
  }


  public static SModelReference createModelReference(String modelUID) {
    Pair<Pair<SModuleId, String>, Pair<SModelId, String>> parseResult = jetbrains.mps.smodel.SModelReference.parseReference_internal(modelUID);
    SModuleId moduleId = parseResult.o1.o1;
    String moduleName = parseResult.o1.o2;
    SModelId modelId = parseResult.o2.o1;
    String modelName = parseResult.o2.o2;
    SModuleReference moduleRef = (moduleId != null || moduleName != null ? new ModuleReference(moduleName, moduleId) : null);
    if (moduleRef == null && !((modelId.isGloballyUnique()))) {
      // make globally unique anyway to avoid exception for old models without modules 
      modelId = new VCSPersistenceUtil.SModelIdProxy(modelId);
    }
    return new jetbrains.mps.smodel.SModelReference(moduleRef, modelId, modelName);
  }

  private static class SModelIdProxy implements SModelId {
    private final SModelId myOldModelId;
    public SModelIdProxy(SModelId modelId) {
      myOldModelId = modelId;
    }
    public String getType() {
      return myOldModelId.getType();
    }
    public boolean isGloballyUnique() {
      return true;
    }
    public String getModelName() {
      return myOldModelId.getModelName();
    }
    @Override
    public int hashCode() {
      return myOldModelId.hashCode();
    }
    @Override
    public boolean equals(Object object) {
      return object instanceof VCSPersistenceUtil.SModelIdProxy && myOldModelId.equals(((VCSPersistenceUtil.SModelIdProxy) object).myOldModelId);
    }
    @Override
    public String toString() {
      return myOldModelId.toString();
    }

  }
}