org.eclipse.viatra2.core2/src/org/eclipse/viatra2/exports/VPMExporter.java

/*******************************************************************************
 * Copyright (c) 2004-2008 Andras Schmidt, Andras Balogh, Istvan Rath and Daniel Varro
 * 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:
 *    Andras Schmidt, Andras Balogh, Istvan Rath - initial API and implementation
 *******************************************************************************/

package org.eclipse.viatra2.exports;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

import org.eclipse.viatra2.core.IEntity;
import org.eclipse.viatra2.core.IModelElement;
import org.eclipse.viatra2.core.IModelSpace;
import org.eclipse.viatra2.core.IRelation;
import org.eclipse.viatra2.framework.IFramework;
import org.eclipse.viatra2.framework.properties.VPMProperties;

/**
 * Exports the modelspace into an XML file.
 * 
 * @author Andras Schmidt, Istvan Rath
 * 
 */
public class VPMExporter {

	
	 /**
	  * Filter out non-valid Unicode characters not allowed in XML 1.0 files.
      */
    private final static String stripNonValidXMLCharacters(String in) {
        if (in == null || ("".equals(in))) {
        	return "";
        }
        StringBuffer res = new StringBuffer();
        char c;
        int l = in.length();
        for (int i = 0; i < l; i++) {
            c = in.charAt(i);
            if (isValidXMLUnicodeCharacter(c)) {
            	res.append(c);
            }
        }
        return res.toString();
    }  
    
    private final static boolean isValidXMLUnicodeCharacter(char c) {
    	return ((c == 0x9) || (c == 0xA) || (c == 0xD) || ((c >= 0x20) && (c <= 0xD7FF)) || ((c >= 0xE000) && (c <= 0xFFFD)) || ((c >= 0x10000) && (c <= 0x10FFFF)));
    }
	
	
	/**
	 * Rewritten by Istvan Rath. Based on original by Andras Schmidt.
     * Aim is to create xml documents that contains only valid characters
	 * (mainly international characters), and to avoid xml parser
	 * mis-understanding <, >, & and [ ]
	 * 
	 * @param in
	 *            This string is converted to be valid xml text
	 * @return The string escaped to be valid xml
	 */
	public String escapeCharacters2(String _in) 
	{
		// first, strip all Unicode characters that are not allowed in XML
		String in = stripNonValidXMLCharacters(_in);
		
		StringBuffer ret = new StringBuffer();
		
		for (char ch : in.toCharArray() )
		{			
			if (ch < ' ' || ch > 127 
					|| ch == '<' || ch == '>' 
					|| ch == '&' || ch == '[' 
					|| ch == '"') 
			{
				ret.append(char2escape(ch));
			} 
			else {
				ret.append(ch);
			}
		}
		return ret.toString();
	}
	

	private String char2escape(char ch) {
		return "&#" + (int) ch + ";";
	}

	public void export(IFramework fw, String fileName) throws IOException {
		File f = new File(fileName);
		// f.createNewFile();
		FileOutputStream stream = new FileOutputStream(f);
		export(fw, stream);
	}

	public void export(IFramework fw, OutputStream outputStream)
			throws IOException {
		IModelSpace ms = fw.getTopmodel();
		// FileWriter fw = new FileWriter(fileName);
		PrintWriter out = new PrintWriter(outputStream);
		out.println("<?xml version=\"1.0\" ?>");
		out.println("<VPM>");
		boolean writeProperties = true;
		if (writeProperties) {
			out.println("<PROPERTIES>");
			VPMProperties props = fw.getProperties();
			// Export properties alphabetically ordered
			TreeMap<Object, Object> ts = new TreeMap<Object, Object>(props
					.getJavaProperties());
			for (Map.Entry<Object, Object> entry : ts.entrySet()) {
				String name = entry.getKey().toString();
				String value = entry.getValue().toString();
				name = escapeCharacters2(name);
				value = escapeCharacters2(value);
				out.println("<PROPERTY name=\"" + name + "\" value=\"" + value
						+ "\"/>");
			}
			out.println("</PROPERTIES>");
		}
		out.println("<MODEL>");
		out.println("<ROOTENTITY id=\""
				+ ms.getModelManager().getRoot().getID() + "\"/>");
		//out.println("<NOPARENTENTITY id=\""+ms.getModelManager().getNoParent()
		// .getID()+"\"/>");

		for (int i = 0; i < 2; ++i) {
			Iterator<? extends IModelElement> it = null;
			String type = "";
			String tagClose = "";
			if (i == 0) {
				type = "ENTITY";
				out.println("<ENTITIES>");
				it = ms.getModelManager().getEntities().iterator();
				tagClose = "</ENTITIES>";
			}
			if (i == 1) {
				type = "RELATION";
				out.println("<RELATIONS>");
				it = ms.getModelManager().getRelations().iterator();
				tagClose = "</RELATIONS>";
			}

			while (it.hasNext()) {
				IModelElement e = it.next();
				if (e.equals(ms.getModelManager().getRoot())) {
					continue;
				}
				String isAny = "";
				if (i == 1) {
					// Relation
					IRelation rel = (IRelation) e;
					isAny = " isAnyFrom=\""
							+ Boolean.toString(rel.getIsAnyFrom()) + "\""
							+ " isAnyTo=\""
							+ Boolean.toString(rel.getIsAnyTo()) + "\"";
				}
				out.println("<" + type + " id=\"" + e.getID() + "\"" + isAny
						+ ">");
				out.println("<NAME>" + escapeCharacters2(e.getName())
						+ "</NAME>");
				if (e.getViewInfo() != null)
					out
							.println("<VIEWINFO>"
									+ escapeCharacters2(e.getViewInfo())
									+ "</VIEWINFO>");

				// added by Istvan Rath
				out.println("<ISFINALTYPE>" + e.getIsFinalType()
						+ "</ISFINALTYPE>");

				if (e.getTypes() != null) {
					Iterator<IModelElement> j = e.getTypes().iterator();
					while (j.hasNext()) {
						IModelElement me = j.next();
						out.println("<TYPE><MODELELEMENT idref=\"" + me.getID()
								+ "\"/></TYPE>");
					}
				}
				if (e.getSupertypes() != null) {
					Iterator<IModelElement> j = e.getSupertypes().iterator();
					while (j.hasNext()) {
						IModelElement me = j.next();
						out.println("<SUPERTYPE><MODELELEMENT idref=\""
								+ me.getID() + "\"/></SUPERTYPE>");
					}
				}
				if (e instanceof IEntity) {
					IEntity ent = (IEntity) e;
					if (ent.getParent() != null) {
						IModelElement me = ent.getParent();
						out.println("<PARENT><ENTITY idref=\"" + me.getID()
								+ "\"/></PARENT>");
					}
				}
				if (e instanceof IEntity) {
					IEntity ent = (IEntity) e;
					out.println("<VALUE>" + escapeCharacters2(ent.getValue())
							+ "</VALUE>");
				}
				if (e instanceof IRelation) {
					IRelation r = (IRelation) e;
					if (r.getFrom() != null)
						out.println("<FROM><ENTITY idref=\""
								+ r.getFrom().getID() + "\"/></FROM>");
					if (r.getTo() != null)
						out.println("<TO><ENTITY idref=\"" + r.getTo().getID()
								+ "\"/></TO>");

					//out.print("<MULTIPLICITY>"+r.getFromMinMultiplicity()+","+
					// r
					// .getFromMaxMultiplicity()+","+r.getToMinMultiplicity()+","
					// +r.getToMaxMultiplicity()+"</MULTIPLICITY>");
					out.print("<MULTIPLICITY>" + r.getMultiplicity().toString()
							+ "</MULTIPLICITY>");
					out.print("<ISAGGREGATION>" + r.getIsAggregation()
							+ "</ISAGGREGATION>");
					if (r.getInverse() != null) {
						out.print("<INVERSE><RELATION idref=\""
								+ r.getInverse().getID() + "\"/></INVERSE>");
					}

				}
				out.println("</" + type + ">");
			}
			out.println(tagClose);
		}
		out.println("</MODEL>");
		out.println("</VPM>");
		out.flush();
		out.close();
	}
}