/*******************************************************************************
* Copyright (c) 2010-2015 Henshin developers. All rights reserved.
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* TU Berlin, University of Luxembourg, SES S.A.
*******************************************************************************/
package de.tub.tfs.henshin.tggeditor.actions.imports;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAnnotation;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.ETypedElement;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.impl.BasicEObjectImpl;
import org.eclipse.emf.ecore.impl.DynamicEObjectImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.eclipse.emf.ecore.impl.EPackageRegistryImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceFactoryRegistryImpl;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.BasicExtendedMetaData;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.ExtendedMetaData;
import org.eclipse.emf.ecore.util.FeatureMap;
import org.eclipse.emf.ecore.util.FeatureMap.Entry;
import org.eclipse.emf.ecore.util.FeatureMapUtil;
import org.eclipse.emf.ecore.xmi.XMLLoad;
import org.eclipse.emf.ecore.xmi.XMLOptions;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.emf.ecore.xmi.impl.GenericXMLResourceFactoryImpl;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLMapImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLOptionsImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLResourceFactoryImpl;
import org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl;
import org.eclipse.emf.henshin.model.Module;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.ui.actions.SelectionAction;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.dialogs.FileSelectionDialog;
import org.eclipse.xsd.ecore.XSDEcoreBuilder;
import org.eclipse.xsd.util.XSDResourceFactoryImpl;
import org.w3c.dom.Document;
import de.tub.tfs.henshin.tgg.TGG;
import de.tub.tfs.henshin.tggeditor.editparts.tree.graphical.GraphFolderTreeEditPart;
import de.tub.tfs.henshin.tggeditor.util.dialogs.DialogUtil;
import de.tub.tfs.henshin.tggeditor.util.dialogs.SingleElementListSelectionDialog;
import de.tub.tfs.muvitor.ui.utils.EMFModelManager;
import de.tub.tfs.muvitor.ui.utils.FragmentResource;
public class LoadReconstructXMLForSource extends SelectionAction {
static final String XML_ELEMENT_TEXT = "mixedText";
public static final String MIXEDELEMENTFEATURE = "mixed";
public static final String BASESCHEME = "de.tub.tfs.tgg.generated.xml";
public static final String ID = "de.tub.tfs.henshin.tggeditor.actions.create.graph.LoadReconstructXMLForSource";
private TGG transSys;
private boolean loadedPackage;
private EPackage p;
public LoadReconstructXMLForSource(IWorkbenchPart part) {
super(part);
setId(ID);
setText("Load XML File");
setToolTipText("Loads XML File and reconstructs model.");
}
private HashMap<String, Object> buildOptions(Map<Object,EStructuralFeature> map) {
HashMap<String, Object> options = new HashMap<String, Object>();
options.put(XMLResource.OPTION_DECLARE_XML, Boolean.TRUE);
options.put(XMLResource.OPTION_KEEP_DEFAULT_CONTENT, Boolean.TRUE);
options.put(XMLResource.OPTION_ANY_TYPE, null);
options.put(XMLResource.OPTION_SUPPRESS_DOCUMENT_ROOT, false);
options.put(XMLResource.OPTION_RECORD_UNKNOWN_FEATURE,
Boolean.TRUE);
options.put(
XMLResource.OPTION_RECORD_ANY_TYPE_NAMESPACE_DECLARATIONS,
Boolean.TRUE);
XMLOptions xmlOptions = (XMLOptions) options.get(
XMLResource.OPTION_XML_OPTIONS);
if (xmlOptions != null) {
xmlOptions.setProcessSchemaLocations(true);
} else {
xmlOptions = new XMLOptionsImpl();
xmlOptions.setProcessAnyXML(false);
xmlOptions.setProcessSchemaLocations(false);
options.put(XMLResource.OPTION_XML_OPTIONS, xmlOptions);
}
options.put(XMLResource.OPTION_USE_XML_NAME_TO_FEATURE_MAP, map);
return options;
}
@Override
protected boolean calculateEnabled() {
List<?> selectedObjects = getSelectedObjects();
if (selectedObjects.size() != 1) {
return false;
}
Object selecObject = selectedObjects.get(0);
if ((selecObject instanceof EditPart)) {
EditPart editpart = (EditPart) selecObject;
if ((editpart instanceof GraphFolderTreeEditPart)) {
transSys = (TGG) editpart.getParent().getModel();
return true;
}
}
return false;
}
private void cleanUp() {
ReconstructingMetaData.cleanExtendedMetaData(p);
}
private static HashMap<String,String> uriToFileMap = new HashMap<String, String>();
private void exportGeneratedEcoreModel(EPackage p, String uri) {
if (p == null)
return;
String fileUri = uriToFileMap.get(p.getNsURI());
if (fileUri == null){
Shell shell = new Shell();
FileDialog dialog = new FileDialog(shell, SWT.SAVE);
dialog.setOverwrite(true);
dialog.setText("Please specify the location where the new ecore model "+p.getName()+"("+p.getNsURI()+") should be saved.");
fileUri = dialog.open();
if (fileUri == null || fileUri.isEmpty()){
shell.close();
return;
}
uriToFileMap.put(p.getNsURI(), fileUri);
shell.close();
}
Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
Map<String, Object> m = reg.getExtensionToFactoryMap();
m.put("ecore", new XMIResourceFactoryImpl());
// Obtain a new resource set
ResourceSet resSet = new ResourceSetImpl();
// Create a resource
Resource resource = null;
try {
resource = transSys.eResource().getResourceSet().createResource(URI.createFileURI(fileUri));
} catch (Exception ex) {
}
Resource old = p.eResource();
resource.getContents().add(p);
try {
resource.save(Collections.EMPTY_MAP);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (old != null)
old.getContents().add(p);
}
public BasicExtendedMetaData extractModelInformation(String xmlURI,final Stack<String> stack,BasicExtendedMetaData data) {
if (!(data instanceof ReconstructingMetaData))
return data;
String fileType = xmlURI.substring(xmlURI.lastIndexOf(".")+1);
ResourceFactoryRegistryImpl.INSTANCE.getExtensionToFactoryMap().put(
fileType, new XMLResourceFactoryImpl() {
@Override
public Resource createResource(final URI uri) {
return new XMLResourceImpl(uri) {
@Override
protected XMLLoad createXMLLoad() {
return new LoggingXMLLoad(createXMLHelper(),stack);
}
@Override
protected boolean useUUIDs() {
return false;
}
};
}
});
HashMap<Object, EStructuralFeature> map = new HashMap<Object, EStructuralFeature>(){
@Override
public EStructuralFeature put(Object key,
EStructuralFeature value) {
return null;
}
};
HashMap<String, Object> options = buildOptions(map);
if (data instanceof ReconstructingMetaData){
((ReconstructingMetaData) data).setMap(map);
((ReconstructingMetaData) data).setCurrentElement(stack);
}
options.put(XMLResource.OPTION_EXTENDED_META_DATA,data);
ResourceSetImpl set = new ResourceSetImpl() {
@Override
public Resource getResource(URI uri, boolean loadOnDemand) {
return super.getResource(uri, loadOnDemand);
}
@Override
protected void handleDemandLoadException(Resource resource,
IOException exception) throws RuntimeException {
super.handleDemandLoadException(resource, exception);
}
};
set.getLoadOptions().putAll(options);
Resource resource = null;
try {
resource = set.getResource(URI.createFileURI(xmlURI), true);
} catch (Exception ex) {
try {
ex.printStackTrace();
if (resource == null)
resource = set.getResource(URI.createFileURI(xmlURI), true);
} catch (Exception ex1){
}
}
if (resource != null)
try{
//resource.unload();
} catch (Exception ex){
}
//HashSet<EStructuralFeature> wrongRefs = improveModel(data);
//System.out.println(Arrays.deepToString(wrongRefs.toArray()));
map.clear();
stack.clear();
if (loadedPackage){
} else {
//Resource resource2 = transSys.eResource().getResourceSet()
// .createResource(URI.createURI(reconstructedPackage.getNsURI()));
//resource2.getContents().add(reconstructedPackage);
//transSys.eResource().getResourceSet().getResources().add(resource2);
}
return data;
}
public HashSet<EStructuralFeature> improveModel(BasicExtendedMetaData data) {
HashSet<EStructuralFeature> criticalFeatures = new HashSet<EStructuralFeature>();
HashSet<EStructuralFeature> invalidFeat = new HashSet<EStructuralFeature>();
HashSet<EStructuralFeature> wrongRefs = new HashSet<EStructuralFeature>();
EPackage reconstructedPackage = ((ReconstructingMetaData) data).getReconstructedPackage();
for (EClassifier clazz : reconstructedPackage.getEClassifiers()) {
if (clazz instanceof EClass){
EClass eclass = (EClass) clazz;
for (EStructuralFeature feat : eclass.getEStructuralFeatures()) {
if (feat instanceof EReference)
if (feat.getEType() instanceof EDataType)
wrongRefs.add(feat);
else
if (((EClass) feat.getEType()).getEStructuralFeatures()
.isEmpty())
criticalFeatures.add(feat);
else if (((EClass) feat.getEType())
.getEStructuralFeatures().size() == 2
&& ((EClass) feat.getEType())
.getEStructuralFeatures().get(0).getName()
.equals(MIXEDELEMENTFEATURE)&& ((EClass) feat.getEType())
.getEStructuralFeatures().get(1).getName()
.equals(XML_ELEMENT_TEXT) )
criticalFeatures.add(feat);
if (feat instanceof EAttribute){
if (feat.getName() == null || feat.getName().isEmpty()){
invalidFeat.add(feat);
}else
if (!(((EAttribute)feat).getEType() instanceof EDataType )){
criticalFeatures.add(feat);
}
}
}
}
}
Shell shell = new Shell();
for (EStructuralFeature eStructuralFeature : criticalFeatures) {
if (!MessageDialog.openQuestion(shell, "Process " + eStructuralFeature.getName(), "Dou you want to change the EReference " + ((EClass)eStructuralFeature.eContainer()).getName() + "." + eStructuralFeature.getName() + " into an EAttribute with the Type EString?")){
continue;
}
EAttribute eAttribute = EcoreFactory.eINSTANCE.createEAttribute();
eAttribute.setName(eStructuralFeature.getName());
eAttribute.setEType(EcorePackage.Literals.ESTRING);
eAttribute.setDerived(false);
eAttribute.setTransient(false);
eAttribute.setVolatile(false);
eAttribute.setUpperBound(1);
EAnnotation eAnnotation = eAttribute.getEAnnotation("http:///org/eclipse/emf/ecore/util/ExtendedMetaData");
if (eAnnotation == null){
eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
eAnnotation.setSource("http:///org/eclipse/emf/ecore/util/ExtendedMetaData");
eAttribute.getEAnnotations().add(eAnnotation);
}
eAnnotation.getDetails().put( "name", eStructuralFeature.getEAnnotation("http:///org/eclipse/emf/ecore/util/ExtendedMetaData").getDetails().get("name"));
eAnnotation.getDetails().put( "kind", "element");
eAnnotation.getDetails().put( "namespace", "##targetNamespace");
reconstructedPackage.getEClassifiers().remove(eStructuralFeature.getEType());
EClass cont = (EClass) eStructuralFeature.eContainer();
cont.getEStructuralFeatures().add(eAttribute);
cont.getEStructuralFeatures().remove(eStructuralFeature);
}
shell.close();
for (EStructuralFeature eStructuralFeature : invalidFeat) {
((List)eStructuralFeature.eContainer().eGet(eStructuralFeature.eContainingFeature())).remove(eStructuralFeature);
}
return wrongRefs;
}
private Boolean manual = null;
private EClassifier newCl;
private boolean copied;
private HashMap<Object,Object> mappedClasses = new HashMap<Object,Object>();
@Override
public void run() {
manual = null;
Shell shell = new Shell();
try {
FileDialog dialog = new FileDialog(shell,SWT.MULTI);
BasicExtendedMetaData data = null;
dialog.setText("Please select the xml file you want to import.");
String str = dialog.open();
str = str.substring(0, str.lastIndexOf(File.separator + "")+1);
for (String xmlURI : dialog.getFileNames()){
xmlURI = str + xmlURI;
Stack<String> stack = new Stack<String>();
data = loadModelInformations(xmlURI);
try {
data = extractModelInformation(xmlURI,stack,data);
} catch (Exception ex) {
ex.printStackTrace();
}
if (data instanceof ReconstructingMetaData){
p = ((ReconstructingMetaData) data).getReconstructedPackage();
} else {
}
cleanUp();
}
if (MessageDialog.openQuestion(shell, "PostProcessing", "Do you want to run the post processor for the generated ecore model?")){
improveModel(data);
}
exportGeneratedEcoreModel(p,null);
boolean r = MessageDialog.openQuestion(shell, "XSD Replacement", "Do you want to create compatibility entries with an existing XSD Model?");
if (r){
FileDialog d = new FileDialog(shell);
d.setText("Please select the ecore model corresponding to the XSD.");
String ecoreModel = d.open();
ResourceSet set = new ResourceSetImpl();
EObject resPkg = null;
if (ecoreModel.endsWith("ecore")){
Resource resource = set.getResource(URI.createFileURI(ecoreModel), true);
resPkg = resource.getContents().get(0);
} else {
XSDEcoreBuilder xsdEcoreBuilder = new XSDEcoreBuilder();
Collection<EObject> generatedPackages = xsdEcoreBuilder.generate(URI.createFileURI(ecoreModel));
// register the packages loaded from XSD
for (EObject generatedEObject : generatedPackages) {
if (generatedEObject instanceof EPackage) {
if (resPkg == null){
resPkg = generatedEObject;
break;
}
}
}
}
if (resPkg instanceof EPackage){
EPackage pkg = (EPackage) resPkg;
p.setName(pkg.getName());
p.setNsPrefix(pkg.getNsPrefix());
p.setNsURI(pkg.getNsURI());
EPackageRegistryImpl.INSTANCE.put(pkg.getNsURI(), p);
EAnnotation annotation = p.getEAnnotation("EMFModelManager");
if (annotation == null){
annotation = EcoreFactory.eINSTANCE.createEAnnotation();
annotation.setSource("EMFModelManager");
p.getEAnnotations().add(annotation);
}
LinkedList<EClass> copiedClasses = new LinkedList<EClass>();
for (final EClassifier cl : pkg.getEClassifiers()) {
newCl = p.getEClassifier(cl.getName());
if (newCl == null)
newCl = p.getEClassifier(cl.getName().replaceAll("(\\w+)[Tt][Yy][Pp][Ee]\\d*", "$1"));
String guessedNewName = "";
if (newCl != null){
guessedNewName = newCl.getName();
} else {
guessedNewName = annotation.getDetails().get("/" + cl.getName());
;
if (guessedNewName != null && !guessedNewName.isEmpty()){
guessedNewName = guessedNewName.substring(1);
newCl = p.getEClassifier(guessedNewName);
}
}
if (newCl == null){
if (manual == null){
boolean b = MessageDialog.openQuestion(shell, "", "At least one class could not be mapped. Do you want to select the mapped classes by hand?");
manual = b;
}
if (manual && !(cl instanceof EDataType)){
EList<EClassifier> eClassifiers = p.getEClassifiers();
copied = false;
newCl = DialogUtil.runClassSelectionDialog(shell, eClassifiers,cl,new SingleElementListSelectionDialog.ListEntry(){
@Override
public String getText() {
return "Copy EClass to new model.";
}
@Override
public Object execute() {
copied = true;
newCl = EcoreUtil.copy(cl);
p.getEClassifiers().add(newCl);
return newCl;
}
});
if (newCl != null)
guessedNewName = newCl.getName();
else {
annotation.getDetails().put( "/" + cl.getName(), "");
continue;
}
if (copied){
if (newCl instanceof EClass){
copiedClasses.add((EClass) newCl);
}
}
} else {
annotation.getDetails().put( "/" + cl.getName(), "");
continue;
}
}
annotation.getDetails().put( "/" + cl.getName(), "/" + guessedNewName);
mappedClasses.put(cl, newCl);
mappedClasses.put(newCl, cl);
outer: for (EObject attr : cl.eContents()) {
if (attr instanceof EStructuralFeature){
if (!annotation.getDetails().contains( "/" + cl.getName() + "/" + ((EStructuralFeature)attr).getName()))
annotation.getDetails().put( "/" + cl.getName() + "/" + ((EStructuralFeature)attr).getName(), "");
}
if (attr instanceof EReference){
EReference newAttr = null;
String attrName = annotation.getDetails().get("/" + cl.getName() + "/" + ((EStructuralFeature)attr).getName());
if (attrName != null && !attrName.isEmpty()){
attrName = attrName.substring(attrName.lastIndexOf("/")+1);
for (EObject obj : newCl.eContents()) {
if (obj instanceof EReference){
if (attrName.equals(((EReference) attr).getName())){
newAttr = (EReference) obj;
break;
}
}
}
}
if (newAttr == null)
for (EObject obj : newCl.eContents()) {
if (obj instanceof EReference){
if (((EReference) obj).getName().toLowerCase().equals(((EReference) attr).getName().toLowerCase())){
newAttr = (EReference) obj;
break;
}
} if (obj instanceof EAttribute){
if (((EAttribute) obj).getName().toLowerCase().equals(((EReference) attr).getName().toLowerCase())){
continue outer;
}
}
}
if (newAttr != null){
mappedClasses.put(attr, newAttr);
mappedClasses.put(newAttr, attr);
annotation.getDetails().put( "/" + cl.getName() + "/" + ((EStructuralFeature)attr).getName(), "/" + newCl.getName() + "/" + ((EStructuralFeature)newAttr).getName());
} else {
annotation.getDetails().put( "/" + cl.getName() + "/" + ((EStructuralFeature)attr).getName(), "");
}
}
if (attr instanceof EAttribute){
EAttribute newAttr = null;
String attrName = annotation.getDetails().get("/" + cl.getName() + "/" + ((EStructuralFeature)attr).getName());
if (attrName != null && !attrName.isEmpty()){
attrName = attrName.substring(attrName.lastIndexOf("/")+1);
for (EObject obj : newCl.eContents()) {
if (obj instanceof EAttribute){
if (attrName.equals(((EAttribute) attr).getName())){
newAttr = (EAttribute) obj;
break;
}
}
}
}
if (newAttr == null)
for (EObject obj : newCl.eContents()) {
if (obj instanceof EAttribute){
if (((EAttribute) obj).getName().toLowerCase().equals(((EAttribute) attr).getName().toLowerCase())){
newAttr = (EAttribute) obj;
break;
}
} if (obj instanceof EReference){
if (((EReference) obj).getName().toLowerCase().equals(((EAttribute) attr).getName().toLowerCase())){
continue outer;
}
}
}
if (newAttr == null){
EObject copy = EcoreUtil.copy(attr);
((EClass)newCl).getEStructuralFeatures().add((EStructuralFeature) copy);
newAttr = (EAttribute) copy;
}
mappedClasses.put(attr, newAttr);
mappedClasses.put(newAttr, attr);
annotation.getDetails().put( "/" + cl.getName() + "/" + ((EStructuralFeature)attr).getName(), "/" + newCl.getName() + "/" + newAttr.getName());
if (((EAttribute) attr).getEAttributeType().eContainer().equals(cl.eContainer())){
EDataType dataType = (EDataType) p.getEClassifier(((EAttribute) attr).getEType().getName());
if (dataType == null){
dataType = EcoreUtil.copy(((EAttribute) attr).getEAttributeType());
p.getEClassifiers().add(dataType);
}
newAttr.setEType(dataType);
} else {
newAttr.setEType(((EAttribute) attr).getEAttributeType());
}
EAnnotation meta = ((EModelElement) attr).getEAnnotation("http:///org/eclipse/emf/ecore/util/ExtendedMetaData");
if (meta != null){
String ns = meta.getDetails().get("namespace");
if (ns == null && newCl != null){
meta = newAttr.getEAnnotation("http:///org/eclipse/emf/ecore/util/ExtendedMetaData");
meta.getDetails().remove("namespace");
}
}
}
}
}
for (EClass eClass : copiedClasses) {
updateSuperTypes(eClass);
}
for (EClassifier classifier : pkg.getEClassifiers()) {
if (classifier instanceof EClass){
for (EClass superType : ((EClass) classifier).getESuperTypes()) {
EClass newSuperType = (EClass) mappedClasses.get(superType);
if (newSuperType != null){
EClass mappedClass = (EClass) mappedClasses.get(classifier);
if (mappedClass != null && !mappedClass.getESuperTypes().contains(newSuperType) && mappedClass != newSuperType){
if (mappedClass.getESuperTypes().contains(superType)){
mappedClass.getESuperTypes().remove(superType);
}
mappedClass.getESuperTypes().add(newSuperType);
}
}
}
}
}
}
//(eClassifiers xsi:type="ecore:EClass" name="[^"]*")\s*>
exportGeneratedEcoreModel(p,
null);
}
cleanUp();
EPackage.Registry.INSTANCE.put(p.getNsURI(), p);
for (String xmlURI : dialog.getFileNames()){
xmlURI = str + xmlURI;
ResourceImpl res = null;
try {
String fileType = xmlURI.substring(xmlURI.lastIndexOf(".")+1);
res = (ResourceImpl) new XMLResourceFactoryImpl().createResource(URI.createFileURI(xmlURI));
res.unload();
HashMap<String,Object> options = new HashMap<String,Object>();
options.put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
options.put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
options.put(XMLResource.OPTION_SCHEMA_LOCATION, Boolean.TRUE);
options.put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
options.put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
options.put(XMLResource.OPTION_USE_LEXICAL_HANDLER, Boolean.TRUE);
res.load(options);
} catch (Exception ex) {
res = (ResourceImpl) transSys.eResource()
.getResourceSet().getResource(URI.createFileURI(xmlURI), true);
ex.printStackTrace();
}
postprocessModel(res.getContents());
ImportInstanceModelAction action = new ImportInstanceModelAction(
null);
action.setModule(transSys);
action.createAndAddGraph((ResourceImpl) res,
URI.createFileURI(xmlURI));
action.dispose();
}
cleanUp();
MessageDialog.openInformation(shell, "Importing XML", "XML import finished.");
} finally {
shell.close();
}
System.out.println("import finished!");
}
protected void updateSuperTypes(EClass eClass) {
LinkedList<EClass> superTypes = new LinkedList<EClass>();
for (EClass eClass2 : eClass.getESuperTypes()) {
EClass newType = (EClass) mappedClasses.get(eClass2);
newType = eClass2;
superTypes.add(newType);
}
eClass.getESuperTypes().clear();
eClass.getESuperTypes().addAll(superTypes);
}
private void postprocessModel(EList<EObject> contents) {
HashSet<EObject> objects = new HashSet<EObject>();
objects.addAll(contents);
Iterator<EObject> iterator = objects.iterator();
while(!objects.isEmpty()){
EObject obj = iterator.next();
iterator.remove();
if (obj == null)
continue;
EStructuralFeature mixed = null;
if ( (mixed = obj.eClass().getEStructuralFeature(MIXEDELEMENTFEATURE)) != null){
FeatureMap map = (FeatureMap) obj.eGet(mixed);
if (map == null)
continue;
String str = "";
Iterator<Entry> itr = map.iterator();
while(itr.hasNext()){
Entry entry = itr.next();
Object o = entry.getValue();
if (o instanceof String){
str += (String) o;
}
}
if (!str.isEmpty()){
EStructuralFeature feat = obj.eClass().getEStructuralFeature(XML_ELEMENT_TEXT);
if (feat != null){
obj.eSet(feat, str);
}
}
obj.eSet(mixed, null);
}
EList<EStructuralFeature> eAllContainments = obj.eClass().getEStructuralFeatures();
for (EStructuralFeature feat : eAllContainments) {
if (feat instanceof EReference){
EReference ref =(EReference) feat;
if (ref.isContainment()){
if (ref.isMany()){
objects.addAll((List<EObject>)obj.eGet(ref));
} else {
objects.add((EObject) obj.eGet(ref));
}
iterator = objects.iterator();
}
}
}
}
}
private BasicExtendedMetaData loadModelInformations(String xmlFile) {
ReconstructingMetaData result = new ReconstructingMetaData(xmlFile, null, null);
String pkgUri = null;
Document document = null;
EPackage pkg = null;
String rootName = null;
String ns = null;
try {
// getting the default implementation of DOM builder
DocumentBuilderFactory factory
= DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
// parsing the XML file
document = builder.parse(new File(xmlFile));
ns = document.getDocumentElement().getAttribute("xsi:noNamespaceSchemaLocation");
if (ns == "")
ns = document.getDocumentElement().getAttribute("xmlns");
File f = new File( xmlFile.substring(0,xmlFile.lastIndexOf(File.separator)) + File.separator + ns);
loadedPackage = true;
if (f.exists() && !f.isDirectory()){
String xsdURI = f.getAbsoluteFile().toString();
try {
XSDEcoreBuilder xsdEcoreBuilder = new XSDEcoreBuilder();
Collection<EObject> generatedPackages = xsdEcoreBuilder.generate(URI.createFileURI(xsdURI));
// register the packages loaded from XSD
for (EObject generatedEObject : generatedPackages) {
if (generatedEObject instanceof EPackage) {
EPackage generatedPackage = (EPackage) generatedEObject;
EPackage.Registry.INSTANCE.put(generatedPackage.getNsURI(),
generatedPackage);
}
}
// add file extension to registry
ResourceFactoryRegistryImpl.INSTANCE.getExtensionToFactoryMap()
.put("xml", new GenericXMLResourceFactoryImpl());
return new BasicExtendedMetaData();
} catch (Exception e){
}
} else {
if (ns == null || ns.isEmpty()){
ns = xmlFile;
} else {
if (!ns.contains("http://")){
ns = xmlFile.substring(0,xmlFile.lastIndexOf(File.separator)) + File.separator + ns;
}
}
ns = ns.replaceAll("\\\\", "/");
rootName = document.getDocumentElement().getNodeName();
pkgUri = generateReconstructedPackageURI(ns);
pkg = EPackageRegistryImpl.INSTANCE.getEPackage(pkgUri);
if (pkg == null){
Resource r = null;
try {
r = transSys.eResource().getResourceSet().getResource(URI.createURI(pkgUri),true);
if (r != null && !r.getContents().isEmpty() && (r.getContents().get(0) instanceof EPackage)){
pkg = (EPackage) r.getContents().get(0);
EPackageRegistryImpl.INSTANCE.put(pkgUri, pkg);
}
} catch (Exception ex) {
} finally {
if (r != null && pkg == null)
r.unload();
}
}
if (pkg == null){
Resource r = null;
try {
r = transSys.eResource().getResourceSet().getResource(URI.createURI(ns),true);
if (r != null && !r.getContents().isEmpty() && (r.getContents().get(0) instanceof EPackage)){
pkg = (EPackage) r.getContents().get(0);
EPackageRegistryImpl.INSTANCE.put(ns, pkg);
EPackageRegistryImpl.INSTANCE.put(pkgUri,pkg);
}
} catch (Exception ex) {
} finally {
if (r != null && pkg == null)
r.unload();
}
}
}
} catch (Exception e) {
pkg = p;
if (p != null)
ns = p.getNsURI();
e.printStackTrace();
if (pkg == null)
return null;
System.out.println("Could not parse " + xmlFile + " assuming package: " + p.getNsURI());
}
result.reconstructedPackage = pkg;
if (pkg == null){
result.contextURI = null;
loadedPackage = false;
} else
result.contextURI = ns;
result.xmlFile = xmlFile;
result.documentRoot = null;
return result;
}
public static String generateReconstructedPackageURI(String namespace) {
return "http://"
+ BASESCHEME
+ "."
+ namespace.substring(namespace
.lastIndexOf("/") + 1);
}
}