plugins/org.eclipse.m2m.qvt.oml.emf.util/src/org/eclipse/m2m/internal/qvt/oml/emf/util/EmfUtil.java - mmt/org.eclipse.qvto - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2018 Borland Software Corporation and others.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v20.html
  *
  * Contributors:
  *     Borland Software Corporation - initial API and implementation
  *     Christopher Gerking - bugs 428620, 537041
  *     Ed Willink - bug 533564
  *******************************************************************************/
 package org.eclipse.m2m.internal.qvt.oml.emf.util;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.resource.URIConverter;
 import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.ecore.xmi.XMIResource;
 import org.eclipse.emf.ecore.xmi.XMLResource;
 import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
 import org.eclipse.osgi.util.NLS;

 /**
  * @author pkobiakov
  */
 public class EmfUtil {
 	private EmfUtil() {}

 	public static final String PATH_SEPARATOR = "::"; //$NON-NLS-1$

 	public static ModelContent loadModel(URI uri) {
 		return loadModel(uri, getDefaultLoadOptions(), null);
 	}

 	public static ModelContent loadModel(URI uri, ResourceSet rs) {
 		return loadModel(uri, getDefaultLoadOptions(), rs);
 	}

 	private static ModelContent loadModel(URI uri, Map<Object, Object> options, ResourceSet rs) {
 		if(uri == null) {
 			return null;
 		}
 		ResourceSet resourceSet = (rs != null) ? rs : createResourceSet(options);
 		Map<URI, URI> uriMap = resourceSet.getURIConverter().getURIMap();
 		Map<URI, URI> platformURIMap = EcorePlugin.computePlatformURIMap(true);
 		uriMap.putAll(platformURIMap);
 		String fragment = uri.fragment();
 		if (fragment != null && fragment.length() > 0) {
 			EObject eObject = resourceSet.getEObject(uri, true);
 			if (eObject == null) {
 				return null;
 			}
 			return new ModelContent(Collections.singletonList(eObject));
 		}
 		Resource resource = resourceSet.getResource(uri.trimFragment(), true);
 		if (resource == null) {
 			return null;
 		}
 		return new ModelContent(resource.getContents());
 	}

 	public static ModelContent safeLoadModel(URI uri, ResourceSet rs) {
 		return safeLoadModel(uri, getDefaultLoadOptions(), rs);
 	}

 	private static ModelContent safeLoadModel(URI uri, Map<Object, Object> options, ResourceSet rs) {
 		try {
 			return loadModel(uri, options, rs);
 		}
 		catch(Exception e){
 			return null;
 		}
 	}

 	public static Resource loadResource(URI uri) {
 		return createResourceSet(getDefaultLoadOptions()).getResource(uri, true);
 	}

 	private static ResourceSet createResourceSet(Map<Object, Object> options) {
 		ResourceSet resourceSet = new ResourceSetImpl();
 		resourceSet.getLoadOptions().putAll(options);

 		return resourceSet;
 	}

 	public static EObject resolveSource(EObject in, EObject inputType) {
 		if (inputType == null || inputType.eResource() == null) {
 			return in;
 		}
 		return resolveSource(in, inputType.eResource().getResourceSet());
 	}

 	public static EObject resolveSource(EObject in, ResourceSet rs) {
 		if (rs != null && EmfUtil.isDynamic(in)) {
 			ResourceSet inRS = in.eResource() != null ? in.eResource().getResourceSet() : null;
 			if (rs != inRS) {
 				URI uri = EcoreUtil.getURI(in);
 				if (uri != null && !"#//".equals(uri.toString())) { //$NON-NLS-1$
 					return rs.getEObject(uri, true);
 				}
 			}
 		}
 		return in;
 	}

 	public static Set<EObject> getResolvedContent(Collection<EObject> content, EObject metamodel) {
 		ResourceSet rs = (metamodel != null && metamodel.eResource() != null ? metamodel.eResource().getResourceSet() : null);
 		return getResolvedContent(content, rs);
 	}

 	public static Set<EObject> getResolvedContent(Collection<EObject> content, ResourceSet rs) {
 		Set<EObject> resolvedObjs = new LinkedHashSet<EObject>(content.size());
 		for (EObject obj : content) {
 			EObject resolved = null;
 			try {
 				resolved = resolveSource(obj, rs);
 			}
 			catch (Exception ex) {
 			}
 			resolvedObjs.add(resolved != null ? resolved : obj);
 		}
 		return resolvedObjs;
 	}

 	public static boolean isUriExistsAsEObject(URI uri, ResourceSet rs, boolean validateNonEmpty) {
 		ModelContent loadModel = null;
 		try {
 			loadModel = loadModel(uri, rs);
 		}
 		catch (Exception e) {
 		}
 		if (loadModel == null) {
 			return false;
 		}
 		return validateNonEmpty ? !loadModel.getContent().isEmpty() : true;
 	}

 	public static boolean isDynamic(EObject eObject) {
 		return eObject instanceof EStructuralFeature.Internal.DynamicValueHolder;
 	}


 	public static void saveModel(EObject eObject, URI uri, Map<Object, Object> opts) throws EmfException {
 		ResourceSet resourceSet = getOutputResourceSet();

 		Resource resource = resourceSet.createResource(uri);
 		resource.getContents().add(eObject);

 		Map<Object, Object> options = new HashMap<Object, Object>(opts);
 		options.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$

 		if(isDynamic(eObject)) {
 			options.put("SCHEMA_LOCATION", Boolean.TRUE); //$NON-NLS-1$
 		}

 		try {
 			resource.save(options);
 		} catch (Exception e) {
 			throw new EmfException(NLS.bind(Messages.EmfUtil_1, uri), e);
 		}
 	}

 	public static void saveModel(Resource modelExtent, Map<Object, Object> opts) throws EmfException {
 		Map<Object, Object> options = new HashMap<Object, Object>(opts);
 		options.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$
 		options.put(XMIResource.OPTION_PROCESS_DANGLING_HREF, XMIResource.OPTION_PROCESS_DANGLING_HREF_DISCARD);
 		for (EObject eObject : modelExtent.getContents()) {
 			if(isDynamic(eObject)) {
 				options.put("SCHEMA_LOCATION", Boolean.TRUE); //$NON-NLS-1$
 				break;
 			}
 		}

 		try {
 			modelExtent.save(options);
 		} catch (Exception e) {
 			throw new EmfException(NLS.bind(Messages.EmfUtil_1, modelExtent.getURI()), e);
 		}
 	}

 	public static ResourceSet getOutputResourceSet() {
 		return new ResourceSetImpl();
 	}

 	public static EPackage getRootPackage(EPackage pack) {
 		EPackage parent = pack.getESuperPackage();
 		if(parent == null) {
 			return pack;
 		}
 		else {
 			return getRootPackage(parent);
 		}
 	}

 	public static String getFullName(EClassifier cls) {
 		return getFullName(cls, PATH_SEPARATOR);
 	}

 	private static String getFullName(EClassifier cls, String delim) {
 		if(cls.getEPackage() == null) {
 			return cls.getName();
 		}
 		return getFullName(cls.getEPackage(), delim) + delim + cls.getName();
 	}

 	public static String getFullName(EPackage pack) {
 		return getFullName(pack, PATH_SEPARATOR);
 	}

 	private static String getFullName(EPackage pack, String delim) {
 		if(pack.getESuperPackage() != null) {
 			return getFullName(pack.getESuperPackage(), delim) + delim + pack.getName();
 		} else {
 			return pack.getName();
 		}
 	}

 	/**
 	 * Get the given package full name relative to the specified owning package
 	 *
 	 * @param ePackage
 	 *            the package of which to retrieve the full name
 	 * @param baseOwningPackage
 	 *            the package representing the root context for relative name
 	 *            resolution.
 	 *            <p>
 	 *            This package and its possible super-packages will be excluded
 	 *            from the full-name. If it is the immediate owning package of
 	 *            the <code>ePackage</code>, the local name of <code>ePackage</code> is
 	 *            returned.
 	 */
 	public static String getFullNameRelativeToPackage(EPackage ePackage, EPackage baseQwningPackage) {
 		if(ePackage.getESuperPackage() != null && ePackage.getESuperPackage() != baseQwningPackage) {
 			StringBuilder buf = new StringBuilder();

 			EPackage nextPackage = ePackage;
 			for(int i = 0; nextPackage != null && nextPackage != baseQwningPackage ; i++) {
 				if(i > 0) {
 					buf.insert(0, PATH_SEPARATOR);
 				}
 				buf.insert(0, nextPackage.getName());

 				nextPackage = nextPackage.getESuperPackage();
 			}

 			return getFullNameRelativeToPackage(ePackage.getESuperPackage(), baseQwningPackage) + PATH_SEPARATOR + ePackage.getName();
 		} else {
 			return ePackage.getName();
 		}
 	}

 	/**
 	 * Get the given classifier's full name relative to the specified owning package
 	 *
 	 * @param eClassifier
 	 *            the classifier of which to retrieve name
 	 * @param baseOwningPackage
 	 *            the package representing the root context for relative name
 	 *            resolution.
 	 *            <p>
 	 *            This package and its possible super-packages will be excluded
 	 *            from the full-name. If it is the immediate owning package of
 	 *            the given classifier, the local name of the classifier is
 	 *            returned.
 	 */
 	public static String getFullNameRelativeToPackage(EClassifier eClassifier, EPackage baseOwningPackage) {
 		EPackage immediateOwner = eClassifier.getEPackage();
 		if(baseOwningPackage != null && immediateOwner != null && baseOwningPackage != immediateOwner) {
 			String parentName = EmfUtil.getFullNameRelativeToPackage(immediateOwner, baseOwningPackage);
 			return parentName + PATH_SEPARATOR + eClassifier.getName();
 		}
 		return eClassifier.getName();
 	}

 	public static EClass getEClass(EPackage root, String[] fullName) throws EmfException {
 		EClassifier classifier = getEClassifier(root, fullName);
 		if(classifier instanceof EClass == false) {
 			throw new EmfException(NLS.bind(Messages.EmfUtil_6, fullName[fullName.length-1]));
 		}

 		return (EClass)classifier;
 	}

 	private static EClassifier getEClassifier(EPackage root, String[] fullName) throws EmfException {
 		if(fullName.length < 2) {
 			throw new EmfException(NLS.bind(Messages.EmfUtil_2, Arrays.asList(fullName)));
 		}

 		String rootPackName = fullName[0];
 		if(!rootPackName.equals(root.getName())) {
 			throw new EmfException(NLS.bind(Messages.EmfUtil_3, rootPackName, root.getName()));
 		}

 		MAIN:
 			for(int i = 1; i < fullName.length-1; i++) {
 				for (EPackage pack : root.getESubpackages()) {
 					if(fullName[i].equals(pack.getName())) {
 						root = pack;
 						continue MAIN;
 					}
 				}

 				throw new EmfException(NLS.bind(Messages.EmfUtil_5, fullName[i]));
 			}

 		EClassifier classifier = root.getEClassifier(fullName[fullName.length-1]);
 		return classifier;
 	}

 	public static URI makeUri(String uriString) {
 		if(uriString == null || uriString.length() == 0) {
 			return null;
 		}

 		URI uri = null;
 		try {
 			uri = URI.createURI(uriString);
 		}
 		catch (Exception e) {
 			return null;
 		}

 		return uri;
 	}

 	public static String getRootPackageUri(EClassifier cls) {
 		String uri = cls == null ? null : getRootPackage(cls.getEPackage()).getNsURI();
 		return uri;
 	}

 	public static boolean isAssignableFrom(EClassifier type, EClassifier from) {
 		if (type == from) {
 			return true;
 		}
 		if (false == from instanceof EClass) {
 			return false;
 		}
 		return ((EClass) from).getEAllSuperTypes().contains(type);
 	}

 	public static Map<Object, Object> getDefaultLoadOptions() {
 		Map<Object, Object> options = new HashMap<Object, Object>();
 		// create new session to avoid problems with parallel filling of containments lists (#31662, etc.)
 		return options;
 	}

 	public static Resource createResource(URI uri, ResourceSet outResourceSet) {
 		Resource resource = outResourceSet.createResource(uri);
 		if(resource != null) {
 			return resource;
 		}

 		Object possibleFactory = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().get(uri.fileExtension());
 		Resource.Factory factory = null;
 		if (possibleFactory instanceof Resource.Factory) {
 			factory = (Resource.Factory) possibleFactory;
 		}
 		if (possibleFactory instanceof Resource.Factory.Descriptor) {
 			factory = ((Resource.Factory.Descriptor) possibleFactory).createFactory();
 		}

 		if(factory == null) {
 			factory = new XMIResourceFactoryImpl();
 		}

 		return factory.createResource(uri);
 	}

 	public static boolean isUriMapped(ResourceSet resourceSet, URI uri) {
 		if (uri != null) {
 			URIConverter converter = resourceSet.getURIConverter();
 			if (converter != null) {
 				Map<URI, URI> uriMap = converter.getURIMap();
 				if (uriMap != null) {
 					return uriMap.containsKey(uri);
 				}
 			}
 		}
 		return false;
 	}

 	public static void cleanupResourceSet(ResourceSet rs) {
 		URI uri = URI.createURI(""); //$NON-NLS-1$

 		List<Resource> resCopy = new ArrayList<Resource>(rs.getResources());
 		for (Resource res : resCopy) {
 			if (res.eAdapters().contains(RESOURCE_PERSISTED_ADAPTER)) {
 				continue;
 			}

 			//			for (TreeIterator<EObject> it = res.getAllContents(); it.hasNext();) {
 			//				EObject eObject = it.next();
 			//				eObject.eAdapters().clear();
 			//			}
 			//			res.getContents().clear();
 			//			res.eAdapters().clear();

 			if (res.isLoaded()) {
 				for (TreeIterator<EObject> it = res.getAllContents(); it.hasNext();) {
 					EObject eObject = it.next();
 					((InternalEObject) eObject).eSetProxyURI(uri);
 				}
 				res.unload();
 			}
 		}
 		rs.getResources().clear();
 		rs.eAdapters().clear();
 	}

 	public static boolean isUriExists(URI uri, ResourceSet rs, boolean validateNonEmpty) {
 		URIConverter uriConverter = (rs != null ? rs.getURIConverter() : URIConverter.INSTANCE);
 		if (uriConverter.exists(uri, Collections.emptyMap())) {
 			return true;
 		}
 		return isUriExistsAsEObject(uri, rs, validateNonEmpty);
 	}

 	public static EPackage getFirstEPackageContent(Resource resource) {
 		for (EObject content : resource.getContents()) {
 			if (content instanceof EPackage) {
 				return (EPackage) content;
 			}
 		}
 		return null;
 	}


 	public static final Adapter RESOURCE_PERSISTED_ADAPTER = new AdapterImpl();

 	public static final Map<Object, Object> DEFAULT_SAVE_OPTIONS = new HashMap<Object, Object>();
 	static {
 		DEFAULT_SAVE_OPTIONS.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2007, 2018 Borland Software Corporation and others.
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v20.html
	*
	* Contributors:
	* Borland Software Corporation - initial API and implementation
	* Christopher Gerking - bugs 428620, 537041
	* Ed Willink - bug 533564
	*******************************************************************************/
	package org.eclipse.m2m.internal.qvt.oml.emf.util;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.emf.common.notify.Adapter;
	import org.eclipse.emf.common.notify.impl.AdapterImpl;
	import org.eclipse.emf.common.util.TreeIterator;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EClassifier;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EPackage;
	import org.eclipse.emf.ecore.EStructuralFeature;
	import org.eclipse.emf.ecore.InternalEObject;
	import org.eclipse.emf.ecore.plugin.EcorePlugin;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecore.resource.URIConverter;
	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
	import org.eclipse.emf.ecore.util.EcoreUtil;
	import org.eclipse.emf.ecore.xmi.XMIResource;
	import org.eclipse.emf.ecore.xmi.XMLResource;
	import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
	import org.eclipse.osgi.util.NLS;

	/**
	* @author pkobiakov
	*/
	public class EmfUtil {
	private EmfUtil() {}

	public static final String PATH_SEPARATOR = "::"; //$NON-NLS-1$

	public static ModelContent loadModel(URI uri) {
	return loadModel(uri, getDefaultLoadOptions(), null);
	}

	public static ModelContent loadModel(URI uri, ResourceSet rs) {
	return loadModel(uri, getDefaultLoadOptions(), rs);
	}

	private static ModelContent loadModel(URI uri, Map<Object, Object> options, ResourceSet rs) {
	if(uri == null) {
	return null;
	}
	ResourceSet resourceSet = (rs != null) ? rs : createResourceSet(options);
	Map<URI, URI> uriMap = resourceSet.getURIConverter().getURIMap();
	Map<URI, URI> platformURIMap = EcorePlugin.computePlatformURIMap(true);
	uriMap.putAll(platformURIMap);
	String fragment = uri.fragment();
	if (fragment != null && fragment.length() > 0) {
	EObject eObject = resourceSet.getEObject(uri, true);
	if (eObject == null) {
	return null;
	}
	return new ModelContent(Collections.singletonList(eObject));
	}
	Resource resource = resourceSet.getResource(uri.trimFragment(), true);
	if (resource == null) {
	return null;
	}
	return new ModelContent(resource.getContents());
	}

	public static ModelContent safeLoadModel(URI uri, ResourceSet rs) {
	return safeLoadModel(uri, getDefaultLoadOptions(), rs);
	}

	private static ModelContent safeLoadModel(URI uri, Map<Object, Object> options, ResourceSet rs) {
	try {
	return loadModel(uri, options, rs);
	}
	catch(Exception e){
	return null;
	}
	}

	public static Resource loadResource(URI uri) {
	return createResourceSet(getDefaultLoadOptions()).getResource(uri, true);
	}

	private static ResourceSet createResourceSet(Map<Object, Object> options) {
	ResourceSet resourceSet = new ResourceSetImpl();
	resourceSet.getLoadOptions().putAll(options);

	return resourceSet;
	}

	public static EObject resolveSource(EObject in, EObject inputType) {
	if (inputType == null \|\| inputType.eResource() == null) {
	return in;
	}
	return resolveSource(in, inputType.eResource().getResourceSet());
	}

	public static EObject resolveSource(EObject in, ResourceSet rs) {
	if (rs != null && EmfUtil.isDynamic(in)) {
	ResourceSet inRS = in.eResource() != null ? in.eResource().getResourceSet() : null;
	if (rs != inRS) {
	URI uri = EcoreUtil.getURI(in);
	if (uri != null && !"#//".equals(uri.toString())) { //$NON-NLS-1$
	return rs.getEObject(uri, true);
	}
	}
	}
	return in;
	}

	public static Set<EObject> getResolvedContent(Collection<EObject> content, EObject metamodel) {
	ResourceSet rs = (metamodel != null && metamodel.eResource() != null ? metamodel.eResource().getResourceSet() : null);
	return getResolvedContent(content, rs);
	}

	public static Set<EObject> getResolvedContent(Collection<EObject> content, ResourceSet rs) {
	Set<EObject> resolvedObjs = new LinkedHashSet<EObject>(content.size());
	for (EObject obj : content) {
	EObject resolved = null;
	try {
	resolved = resolveSource(obj, rs);
	}
	catch (Exception ex) {
	}
	resolvedObjs.add(resolved != null ? resolved : obj);
	}
	return resolvedObjs;
	}

	public static boolean isUriExistsAsEObject(URI uri, ResourceSet rs, boolean validateNonEmpty) {
	ModelContent loadModel = null;
	try {
	loadModel = loadModel(uri, rs);
	}
	catch (Exception e) {
	}
	if (loadModel == null) {
	return false;
	}
	return validateNonEmpty ? !loadModel.getContent().isEmpty() : true;
	}

	public static boolean isDynamic(EObject eObject) {
	return eObject instanceof EStructuralFeature.Internal.DynamicValueHolder;
	}


	public static void saveModel(EObject eObject, URI uri, Map<Object, Object> opts) throws EmfException {
	ResourceSet resourceSet = getOutputResourceSet();

	Resource resource = resourceSet.createResource(uri);
	resource.getContents().add(eObject);

	Map<Object, Object> options = new HashMap<Object, Object>(opts);
	options.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$

	if(isDynamic(eObject)) {
	options.put("SCHEMA_LOCATION", Boolean.TRUE); //$NON-NLS-1$
	}

	try {
	resource.save(options);
	} catch (Exception e) {
	throw new EmfException(NLS.bind(Messages.EmfUtil_1, uri), e);
	}
	}

	public static void saveModel(Resource modelExtent, Map<Object, Object> opts) throws EmfException {
	Map<Object, Object> options = new HashMap<Object, Object>(opts);
	options.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$
	options.put(XMIResource.OPTION_PROCESS_DANGLING_HREF, XMIResource.OPTION_PROCESS_DANGLING_HREF_DISCARD);
	for (EObject eObject : modelExtent.getContents()) {
	if(isDynamic(eObject)) {
	options.put("SCHEMA_LOCATION", Boolean.TRUE); //$NON-NLS-1$
	break;
	}
	}

	try {
	modelExtent.save(options);
	} catch (Exception e) {
	throw new EmfException(NLS.bind(Messages.EmfUtil_1, modelExtent.getURI()), e);
	}
	}

	public static ResourceSet getOutputResourceSet() {
	return new ResourceSetImpl();
	}

	public static EPackage getRootPackage(EPackage pack) {
	EPackage parent = pack.getESuperPackage();
	if(parent == null) {
	return pack;
	}
	else {
	return getRootPackage(parent);
	}
	}

	public static String getFullName(EClassifier cls) {
	return getFullName(cls, PATH_SEPARATOR);
	}

	private static String getFullName(EClassifier cls, String delim) {
	if(cls.getEPackage() == null) {
	return cls.getName();
	}
	return getFullName(cls.getEPackage(), delim) + delim + cls.getName();
	}

	public static String getFullName(EPackage pack) {
	return getFullName(pack, PATH_SEPARATOR);
	}

	private static String getFullName(EPackage pack, String delim) {
	if(pack.getESuperPackage() != null) {
	return getFullName(pack.getESuperPackage(), delim) + delim + pack.getName();
	} else {
	return pack.getName();
	}
	}

	/**
	* Get the given package full name relative to the specified owning package
	*
	* @param ePackage
	* the package of which to retrieve the full name
	* @param baseOwningPackage
	* the package representing the root context for relative name
	* resolution.
	* <p>
	* This package and its possible super-packages will be excluded
	* from the full-name. If it is the immediate owning package of
	* the <code>ePackage</code>, the local name of <code>ePackage</code> is
	* returned.
	*/
	public static String getFullNameRelativeToPackage(EPackage ePackage, EPackage baseQwningPackage) {
	if(ePackage.getESuperPackage() != null && ePackage.getESuperPackage() != baseQwningPackage) {
	StringBuilder buf = new StringBuilder();

	EPackage nextPackage = ePackage;
	for(int i = 0; nextPackage != null && nextPackage != baseQwningPackage ; i++) {
	if(i > 0) {
	buf.insert(0, PATH_SEPARATOR);
	}
	buf.insert(0, nextPackage.getName());

	nextPackage = nextPackage.getESuperPackage();
	}

	return getFullNameRelativeToPackage(ePackage.getESuperPackage(), baseQwningPackage) + PATH_SEPARATOR + ePackage.getName();
	} else {
	return ePackage.getName();
	}
	}

	/**
	* Get the given classifier's full name relative to the specified owning package
	*
	* @param eClassifier
	* the classifier of which to retrieve name
	* @param baseOwningPackage
	* the package representing the root context for relative name
	* resolution.
	* <p>
	* This package and its possible super-packages will be excluded
	* from the full-name. If it is the immediate owning package of
	* the given classifier, the local name of the classifier is
	* returned.
	*/
	public static String getFullNameRelativeToPackage(EClassifier eClassifier, EPackage baseOwningPackage) {
	EPackage immediateOwner = eClassifier.getEPackage();
	if(baseOwningPackage != null && immediateOwner != null && baseOwningPackage != immediateOwner) {
	String parentName = EmfUtil.getFullNameRelativeToPackage(immediateOwner, baseOwningPackage);
	return parentName + PATH_SEPARATOR + eClassifier.getName();
	}
	return eClassifier.getName();
	}

	public static EClass getEClass(EPackage root, String[] fullName) throws EmfException {
	EClassifier classifier = getEClassifier(root, fullName);
	if(classifier instanceof EClass == false) {
	throw new EmfException(NLS.bind(Messages.EmfUtil_6, fullName[fullName.length-1]));
	}

	return (EClass)classifier;
	}

	private static EClassifier getEClassifier(EPackage root, String[] fullName) throws EmfException {
	if(fullName.length < 2) {
	throw new EmfException(NLS.bind(Messages.EmfUtil_2, Arrays.asList(fullName)));
	}

	String rootPackName = fullName[0];
	if(!rootPackName.equals(root.getName())) {
	throw new EmfException(NLS.bind(Messages.EmfUtil_3, rootPackName, root.getName()));
	}

	MAIN:
	for(int i = 1; i < fullName.length-1; i++) {
	for (EPackage pack : root.getESubpackages()) {
	if(fullName[i].equals(pack.getName())) {
	root = pack;
	continue MAIN;
	}
	}

	throw new EmfException(NLS.bind(Messages.EmfUtil_5, fullName[i]));
	}

	EClassifier classifier = root.getEClassifier(fullName[fullName.length-1]);
	return classifier;
	}

	public static URI makeUri(String uriString) {
	if(uriString == null \|\| uriString.length() == 0) {
	return null;
	}

	URI uri = null;
	try {
	uri = URI.createURI(uriString);
	}
	catch (Exception e) {
	return null;
	}

	return uri;
	}

	public static String getRootPackageUri(EClassifier cls) {
	String uri = cls == null ? null : getRootPackage(cls.getEPackage()).getNsURI();
	return uri;
	}

	public static boolean isAssignableFrom(EClassifier type, EClassifier from) {
	if (type == from) {
	return true;
	}
	if (false == from instanceof EClass) {
	return false;
	}
	return ((EClass) from).getEAllSuperTypes().contains(type);
	}

	public static Map<Object, Object> getDefaultLoadOptions() {
	Map<Object, Object> options = new HashMap<Object, Object>();
	// create new session to avoid problems with parallel filling of containments lists (#31662, etc.)
	return options;
	}

	public static Resource createResource(URI uri, ResourceSet outResourceSet) {
	Resource resource = outResourceSet.createResource(uri);
	if(resource != null) {
	return resource;
	}

	Object possibleFactory = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().get(uri.fileExtension());
	Resource.Factory factory = null;
	if (possibleFactory instanceof Resource.Factory) {
	factory = (Resource.Factory) possibleFactory;
	}
	if (possibleFactory instanceof Resource.Factory.Descriptor) {
	factory = ((Resource.Factory.Descriptor) possibleFactory).createFactory();
	}

	if(factory == null) {
	factory = new XMIResourceFactoryImpl();
	}

	return factory.createResource(uri);
	}

	public static boolean isUriMapped(ResourceSet resourceSet, URI uri) {
	if (uri != null) {
	URIConverter converter = resourceSet.getURIConverter();
	if (converter != null) {
	Map<URI, URI> uriMap = converter.getURIMap();
	if (uriMap != null) {
	return uriMap.containsKey(uri);
	}
	}
	}
	return false;
	}

	public static void cleanupResourceSet(ResourceSet rs) {
	URI uri = URI.createURI(""); //$NON-NLS-1$

	List<Resource> resCopy = new ArrayList<Resource>(rs.getResources());
	for (Resource res : resCopy) {
	if (res.eAdapters().contains(RESOURCE_PERSISTED_ADAPTER)) {
	continue;
	}

	// for (TreeIterator<EObject> it = res.getAllContents(); it.hasNext();) {
	// EObject eObject = it.next();
	// eObject.eAdapters().clear();
	// }
	// res.getContents().clear();
	// res.eAdapters().clear();

	if (res.isLoaded()) {
	for (TreeIterator<EObject> it = res.getAllContents(); it.hasNext();) {
	EObject eObject = it.next();
	((InternalEObject) eObject).eSetProxyURI(uri);
	}
	res.unload();
	}
	}
	rs.getResources().clear();
	rs.eAdapters().clear();
	}

	public static boolean isUriExists(URI uri, ResourceSet rs, boolean validateNonEmpty) {
	URIConverter uriConverter = (rs != null ? rs.getURIConverter() : URIConverter.INSTANCE);
	if (uriConverter.exists(uri, Collections.emptyMap())) {
	return true;
	}
	return isUriExistsAsEObject(uri, rs, validateNonEmpty);
	}

	public static EPackage getFirstEPackageContent(Resource resource) {
	for (EObject content : resource.getContents()) {
	if (content instanceof EPackage) {
	return (EPackage) content;
	}
	}
	return null;
	}


	public static final Adapter RESOURCE_PERSISTED_ADAPTER = new AdapterImpl();

	public static final Map<Object, Object> DEFAULT_SAVE_OPTIONS = new HashMap<Object, Object>();
	static {
	DEFAULT_SAVE_OPTIONS.put(XMLResource.OPTION_ENCODING, "UTF-8"); //$NON-NLS-1$
	}

	}