| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 IBM Corporation and others. |
| // 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: |
| // IBM Corporation - initial implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.persistence.migration.internal; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.emf.common.CommonPlugin; |
| 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.impl.EPackageRegistryImpl; |
| import org.eclipse.emf.ecore.resource.Resource; |
| 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.util.ExtendedMetaData; |
| import org.eclipse.emf.ecore.xmi.IllegalValueException; |
| import org.eclipse.emf.ecore.xmi.XMLHelper; |
| import org.eclipse.emf.ecore.xmi.XMLResource; |
| import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl; |
| import org.eclipse.emf.ecore.xml.type.AnyType; |
| import org.eclipse.emf.mapping.ecore2xml.Ecore2XMLPackage; |
| import org.eclipse.emf.mapping.ecore2xml.Ecore2XMLRegistry; |
| import org.eclipse.emf.mapping.ecore2xml.impl.Ecore2XMLRegistryImpl; |
| import org.eclipse.emf.mapping.ecore2xml.util.Ecore2XMLExtendedMetaData; |
| import org.eclipse.epf.persistence.MultiFileResourceSetImpl; |
| import org.eclipse.epf.persistence.MultiFileURIConverter; |
| import org.eclipse.epf.persistence.MultiFileXMIHelperImpl; |
| import org.eclipse.epf.persistence.MultiFileXMIResourceImpl; |
| import org.eclipse.epf.persistence.migration.UMA2UMAResourceHandler; |
| import org.eclipse.epf.persistence.util.PersistenceResources; |
| import org.eclipse.epf.persistence.util.PersistenceUtil; |
| import org.eclipse.epf.resourcemanager.ResourceDescriptor; |
| import org.eclipse.epf.resourcemanager.ResourceManager; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.BreakdownElement; |
| import org.eclipse.epf.uma.ContentDescription; |
| import org.eclipse.epf.uma.Guideline; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodLibrary; |
| import org.eclipse.epf.uma.MethodPackage; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.epf.uma.ProcessComponent; |
| import org.eclipse.epf.uma.ProcessPackage; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.util.ContentDescriptionFactory; |
| import org.eclipse.epf.uma.util.UmaUtil; |
| |
| /** |
| * Migrates one version of UMA library to another using the provided Ecore2XML |
| * mapping files and UMA2UMAResourceHandler. The Ecore2XML mapping files |
| * specifies the name changes of classes/attributes while UMA2UMAResourceHandler |
| * handles the data moving. |
| * |
| * @author Phong Nguyen Le |
| * @since 1.0 |
| */ |
| public class Migrator { |
| private static final String[] NS_URIs = { Migrator.OLD_UMA_NS_URI, |
| Migrator.OLD_UMA_NS_URI, Migrator.UMA_NS_URI }; |
| |
| private static final URI[] ECORE2XML_URIs = { |
| URI |
| .createURI("platform:/plugin/com.ibm.rpm.library.persistence/migration/uma.ecore2xml") //$NON-NLS-1$ |
| , |
| URI |
| .createURI("platform:/plugin/com.ibm.rpm.library.persistence/migration/uma2.ecore2xml") //$NON-NLS-1$ |
| , |
| URI |
| .createURI("platform:/plugin/com.ibm.rpm.library.persistence/migration/uma3.ecore2xml") //$NON-NLS-1$ |
| }; |
| |
| public static final String OLD_UMA_NS_URI = "http:///com/ibm/uma.ecore"; //$NON-NLS-1$ |
| |
| public static final String UMA_NS_URI = "http://www.ibm.com/uma/1.0.2/uma.ecore"; //$NON-NLS-1$ |
| |
| private ExtendedMetaData[] extendedMetaDatas; |
| |
| private UMA2UMAResourceHandler0 resourceHandler; |
| |
| public HashMap oldPathToNewURIMap = new HashMap(); |
| |
| public Collection anyTypeFeatureValues = new ArrayList(); |
| |
| private static final ExtendedMetaData getExtendedMetaData(String oldNsURI, |
| URI ecore2XMLURI) { |
| EPackage.Registry ePackageRegistry = new EPackageRegistryImpl( |
| EPackage.Registry.INSTANCE); |
| ePackageRegistry.put(oldNsURI, UmaPackage.eINSTANCE); |
| |
| Ecore2XMLRegistry ecore2xmlRegistry = new Ecore2XMLRegistryImpl( |
| Ecore2XMLRegistry.INSTANCE); |
| |
| ecore2xmlRegistry |
| .put(oldNsURI, EcoreUtil.getObjectByType(new ResourceSetImpl() |
| .getResource(ecore2XMLURI, true).getContents(), |
| Ecore2XMLPackage.eINSTANCE.getXMLMap())); |
| |
| return new Ecore2XMLExtendedMetaData(ePackageRegistry, |
| ecore2xmlRegistry) { |
| public EClassifier getType(EPackage ePackage, String name) { |
| EClassifier type = super.getType(ePackage, name); |
| |
| if (type == null) { |
| // try to get type from the package with the given name |
| // |
| List eClassifiers = ePackage.getEClassifiers(); |
| for (int i = 0, size = eClassifiers.size(); i < size; ++i) { |
| EClassifier eClassifier = (EClassifier) eClassifiers |
| .get(i); |
| if (name.equals(eClassifier.getName())) { |
| return eClassifier; |
| } |
| } |
| |
| } |
| |
| return type; |
| } |
| }; |
| } |
| |
| public Migrator() { |
| this(NS_URIs, ECORE2XML_URIs); |
| } |
| |
| public Migrator(String[] nsURIs, URI[] ecore2XMLURIs) { |
| int size = ecore2XMLURIs.length; |
| extendedMetaDatas = new ExtendedMetaData[size]; |
| for (int i = 0; i < ecore2XMLURIs.length; i++) { |
| extendedMetaDatas[i] = getExtendedMetaData(nsURIs[i], |
| ecore2XMLURIs[i]); |
| } |
| this.resourceHandler = new UMA2UMAResourceHandler0(); |
| } |
| |
| private static void updateStatus(IProgressMonitor monitor, String msg) { |
| if (monitor != null) { |
| monitor.setTaskName(msg); |
| } else { |
| System.out.println(msg); |
| } |
| } |
| |
| private static class AnyTypeFeatureValue { |
| String ownerId; |
| |
| EObject owner; |
| |
| EStructuralFeature feature; |
| |
| String valueId; |
| |
| AnyType value; |
| |
| int index; |
| } |
| |
| class MigratorURIConverter extends MultiFileURIConverter { |
| private ResourceManager oldResMgr; |
| |
| /** |
| * @param resourceSet |
| */ |
| public MigratorURIConverter(MultiFileResourceSetImpl resourceSet) { |
| super(resourceSet); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uma.persistence.MultiFileURIConverter#normalize(org.eclipse.emf.common.util.URI) |
| */ |
| public URI normalize(URI uri) { |
| URI normalized = super.normalize(uri); |
| if (normalized == null && SCHEME.equalsIgnoreCase(uri.scheme())) { |
| if (oldResMgr != null) { |
| String id = uri.authority(); |
| normalized = getURIFromOldResourceManager(id); |
| if (normalized != null) { |
| if (uri.hasFragment()) { |
| normalized = normalized.appendFragment(uri |
| .fragment()); |
| } else { |
| normalized = normalized.appendFragment(id); |
| } |
| } |
| } |
| |
| } |
| return normalized; |
| } |
| |
| public URI getURIFromOldResourceManager(String id) { |
| if (oldResMgr == null) |
| return null; |
| ResourceDescriptor desc = oldResMgr.getResourceDescriptor(id); |
| if (desc != null) { |
| URI normalized = desc.getResolvedURI(); |
| URI newURI = (URI) oldPathToNewURIMap.get(normalized |
| .toFileString()); |
| if (newURI != null) { |
| normalized = newURI; |
| } |
| return normalized; |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uma.persistence.MultiFileURIConverter#dispose() |
| */ |
| public void dispose() { |
| if (oldResMgr != null) { |
| oldResMgr.dispose(); |
| oldResMgr = null; |
| } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * @param resMgr2 |
| */ |
| public void setOldResourceManager(ResourceManager resMgr) { |
| oldResMgr = resMgr; |
| } |
| |
| public ResourceManager getOldResourceManager() { |
| return oldResMgr; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uma.persistence.MultiFileURIConverter#setURIMapping(org.eclipse.emf.ecore.EObject, |
| * org.eclipse.emf.common.util.URI, java.util.Set) |
| */ |
| public void setURIMapping(EObject e, URI uri, Set modifiedResources) { |
| // code to support migration from older version |
| // |
| if (e instanceof MethodElement) { |
| MigratorURIConverter uriConverter = (MigratorURIConverter) ((MultiFileResourceSetImpl) e |
| .eResource().getResourceSet()).getURIConverter(); |
| ResourceManager oldResMgr = uriConverter |
| .getOldResourceManager(); |
| if (oldResMgr != null) { |
| ResourceDescriptor desc = oldResMgr |
| .getResourceDescriptor(((MethodElement) e) |
| .getGuid()); |
| if (desc != null) { |
| oldPathToNewURIMap.put(desc.getResolvedURI() |
| .toFileString(), uri); |
| } |
| } |
| } |
| |
| super.setURIMapping(e, uri, modifiedResources); |
| } |
| } |
| |
| class MigratorResourceSet extends MultiFileResourceSetImpl { |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uma.persistence.MultiFileResourceSetImpl#getURIConverter() |
| */ |
| public URIConverter getURIConverter() { |
| if (uriConverter == null) { |
| uriConverter = new MigratorURIConverter(this); |
| } |
| return uriConverter; |
| } |
| |
| private void loadOldResourceManager(String libPath) throws IOException { |
| // trying to load the resource descriptors file |
| // |
| String libDir = new File(libPath).getParent() + File.separator; |
| File file = new File(libDir, RESMGR_XMI); |
| ResourceManager resMgr = null; |
| MultiFileURIConverter multiFileURIConverter = (MultiFileURIConverter) getURIConverter(); |
| if (file.exists()) { |
| Resource resMgrRes = new XMIResourceImpl(URI.createFileURI(file |
| .getAbsolutePath())); // super.getResource(URI.createFileURI(file.getAbsolutePath()), |
| // true); |
| resMgrRes.load(null); |
| if (!resMgrRes.getContents().isEmpty()) { |
| Object obj = resMgrRes.getContents().get(0); |
| if (obj instanceof ResourceManager) { |
| resMgr = (ResourceManager) obj; |
| // resMgr.resolve(); |
| } else { |
| System.err |
| .println("Invalid ResourceManager file: " + file); //$NON-NLS-1$ |
| } |
| } |
| } |
| ((MigratorURIConverter) multiFileURIConverter) |
| .setOldResourceManager(resMgr); |
| } |
| |
| public MethodLibrary loadLibrary(String path) throws Exception { |
| loadOldResourceManager(path); |
| |
| return loadLibraryWithoutReset(path); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uma.persistence.MultiFileResourceSetImpl#findEObjectInUnloadedResources(java.lang.String) |
| */ |
| protected EObject findEObjectInUnloadedResources(String id) { |
| Object object = null; |
| if (getResourceManager() != null) { |
| object = super.findEObjectInUnloadedResources(id); |
| } |
| if (object == null) { |
| URI uri = ((MigratorURIConverter) getURIConverter()) |
| .getURIFromOldResourceManager(id); |
| Resource resource = super.getResource(uri, true); |
| return resource.getEObject(id); |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uma.persistence.MultiFileResourceSetImpl#getEObject(org.eclipse.emf.common.util.URI, |
| * boolean) |
| */ |
| public EObject getEObject(URI uri, boolean loadOnDemand) { |
| // EObject eObj = superGetEObject(uri, loadOnDemand); |
| EObject eObj = super.getEObject(uri, loadOnDemand); |
| if (eObj == null |
| && MigratorURIConverter.SCHEME.equalsIgnoreCase(uri |
| .scheme()) && !uri.hasFragment()) { |
| eObj = super.getEObject(uri.authority()); |
| } |
| // if(uri.authority().equals("{11B60A4B-A0C7-4D5C-891A-346E8652A4EB}")) |
| // { |
| // System.out.println("MigratorResourceSet.getEObject(): eObj = " + |
| // eObj); |
| // } |
| if (eObj == null || eObj.eIsProxy()) { |
| throw new RuntimeException( |
| "Could not load object with URI '" + uri + "' (normalized URI: '" + getURIConverter().normalize(uri) + "').\nPlease see log file for more details."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| return eObj; |
| } |
| |
| public EObject superGetEObject(URI uri, boolean loadOnDemand) { |
| try { |
| URI normalized = getURIConverter().normalize(uri); |
| if (normalized == null) { |
| return null; |
| } |
| Resource resource = null; |
| resource = getResource(normalized.trimFragment(), loadOnDemand); |
| if (resource != null) { |
| String fragment = normalized.fragment(); |
| if (fragment == null || fragment.length() == 0) { |
| return PersistenceUtil.getMethodElement(resource); |
| } |
| try { |
| return resource.getEObject(fragment); |
| } catch (NullPointerException e) { |
| throw e; |
| } |
| } else { |
| return null; |
| } |
| } catch (RuntimeException e) { |
| // |
| } |
| return null; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see com.ibm.uma.persistence.MultiFileResourceSetImpl#createResource(org.eclipse.emf.common.util.URI) |
| */ |
| public Resource createResource(URI uri) { |
| Resource result = new MultiFileXMIResourceImpl(uri) { |
| protected XMLHelper createXMLHelper() { |
| return new MultiFileXMIHelperImpl(this) { |
| public void setValue(EObject object, |
| EStructuralFeature feature, Object value, |
| int position) { |
| boolean old = logError; |
| try { |
| logError = false; |
| super |
| .setValue(object, feature, value, |
| position); |
| } catch (RuntimeException e) { |
| if (value instanceof AnyType |
| && object instanceof MethodElement |
| // && object instanceof WorkBreakdownElement |
| // && feature == |
| // UmaPackage.eINSTANCE.getWorkBreakdownElement_LinkToPredecessor() |
| ) { |
| AnyTypeFeatureValue fvalue = new AnyTypeFeatureValue(); |
| // fvalue.owner = object; |
| fvalue.ownerId = ((MethodElement) object) |
| .getGuid(); |
| fvalue.feature = feature; |
| // fvalue.value = (AnyType) value; |
| fvalue.valueId = (String) UMA2UMAResourceHandler |
| .getSingleValue(((AnyType) value) |
| .getAnyAttribute(), "guid"); //$NON-NLS-1$ |
| fvalue.index = position; |
| anyTypeFeatureValues.add(fvalue); |
| } else { |
| throw e; |
| } |
| } finally { |
| logError = old; |
| } |
| } |
| |
| public List setManyReference( |
| org.eclipse.emf.ecore.xmi.XMLHelper.ManyReference reference, |
| String location) { |
| List exceptions = super.setManyReference(reference, |
| location); |
| if (exceptions == null) |
| return null; |
| for (Iterator iter = exceptions.iterator(); iter |
| .hasNext();) { |
| Object ex = iter.next(); |
| if (ex instanceof IllegalValueException) { |
| IllegalValueException ive = (IllegalValueException) ex; |
| if (ive.getValue() instanceof AnyType |
| && ive.getObject() instanceof MethodElement) { |
| AnyTypeFeatureValue fvalue = new AnyTypeFeatureValue(); |
| fvalue.ownerId = ((MethodElement) ive |
| .getObject()).getGuid(); |
| fvalue.feature = ive.getFeature(); |
| fvalue.valueId = (String) UMA2UMAResourceHandler |
| .getSingleValue(((AnyType) ive |
| .getValue()) |
| .getAnyAttribute(), |
| "guid"); //$NON-NLS-1$ |
| fvalue.index = -1; |
| anyTypeFeatureValues.add(fvalue); |
| iter.remove(); |
| } |
| } |
| } |
| if (exceptions.isEmpty()) { |
| return null; |
| } |
| return exceptions; |
| } |
| }; |
| } |
| }; |
| result.setTrackingModification(true); |
| getResources().add(result); |
| return result; |
| } |
| } |
| |
| public void migrate(String libPath, IProgressMonitor monitor) |
| throws Exception { |
| Set classNames = new HashSet(); |
| classNames.add("Technique"); //$NON-NLS-1$ |
| |
| MultiFileResourceSetImpl resourceSet = new MigratorResourceSet(); |
| // ResourceManager oldResMgr = null; |
| for (int i = 0; i < extendedMetaDatas.length; i++) { |
| resourceSet.getLoadOptions().put( |
| XMLResource.OPTION_RECORD_UNKNOWN_FEATURE, Boolean.TRUE); |
| if (i < 2) { |
| resourceSet.getLoadOptions().put( |
| XMLResource.OPTION_RESOURCE_HANDLER, resourceHandler); |
| } |
| resourceSet.getLoadOptions() |
| .put(XMLResource.OPTION_EXTENDED_META_DATA, |
| extendedMetaDatas[i]); |
| |
| if (i == 0) { |
| resourceHandler.savePresentationURIFor(classNames); |
| } else { |
| resourceHandler.savePresentationURIFor(null); |
| } |
| |
| updateStatus(monitor, PersistenceResources.loadLibraryTask_name); |
| |
| // if(oldResMgr != null) { |
| // ((MigratorURIConverter)resourceSet.getURIConverter()).setOldResourceManager(oldResMgr); |
| // resourceSet.loadLibraryWithoutReset(libPath); |
| // } |
| // else { |
| resourceSet.loadLibrary(libPath); |
| // } |
| |
| MethodLibrary lib = resourceSet.getMethodLibrary(); |
| if (lib == null) |
| return; |
| |
| // load all the resources in memory |
| // |
| updateStatus(monitor, PersistenceResources.loadResourcesTask_name); |
| |
| for (Iterator iter = lib.eAllContents(); iter.hasNext();) { |
| EObject element = (EObject) iter.next(); |
| if (element instanceof Guideline && i > 0) { |
| // hack to restore the right presentation for old Technique |
| // |
| Guideline guideline = (Guideline) element; |
| URI uri = resourceHandler.getPresentationURI(guideline |
| .getGuid()); |
| if (uri != null) { |
| ContentDescription presentation = (ContentDescription) resourceSet |
| .getEObject(uri, true); |
| guideline.setPresentation(presentation); |
| } |
| } |
| if (element instanceof MethodElement) { |
| try { |
| for (Iterator iterator = element.eCrossReferences() |
| .iterator(); iterator.hasNext();) { |
| iterator.next(); |
| } |
| } catch (Exception e) { |
| CommonPlugin.INSTANCE.log(e); |
| System.err |
| .println("Error iterate thru cross references of element: " + element); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| if (i == 0) { |
| // oldResMgr = |
| // ((MigratorURIConverter)resourceSet.getURIConverter()).getOldResourceManager(); |
| |
| migrateProcessContentDescriptions(monitor, lib); |
| |
| updateStatus(monitor, PersistenceResources.moveDataTask_name); |
| |
| } |
| |
| if (i < 2) { |
| resourceHandler.moveData(); |
| resourceHandler.clearMoveInfos(); |
| } |
| |
| if (i == extendedMetaDatas.length - 1) { |
| migrateProcesses(monitor, lib); |
| |
| restoreReferences(resourceSet); |
| |
| } |
| |
| updateStatus(monitor, PersistenceResources.saveLibraryTask_name); |
| |
| resourceSet.save(null, true); |
| resourceSet.reset(); |
| |
| } |
| |
| // delete old resmgr.xmi |
| // |
| try { |
| File resMgrFile = new File(new File(libPath).getParentFile(), |
| MultiFileResourceSetImpl.RESMGR_XMI); |
| if (resMgrFile.exists()) { |
| resMgrFile.delete(); |
| } |
| |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| private void restoreReferences(MultiFileResourceSetImpl resourceSet) { |
| for (Iterator iter = anyTypeFeatureValues.iterator(); iter.hasNext();) { |
| AnyTypeFeatureValue element = (AnyTypeFeatureValue) iter.next(); |
| if (element.ownerId != null && element.valueId != null) { |
| EObject owner = resourceSet.getEObject(element.ownerId); |
| Object value = resourceSet.getEObject(element.valueId); |
| UMA2UMAResourceHandler.setValue(owner, element.feature, value); |
| } |
| } |
| anyTypeFeatureValues.clear(); |
| } |
| |
| private static void migrateProcesses(IProgressMonitor monitor, |
| MethodLibrary lib) { |
| updateStatus(monitor, PersistenceResources.fixPresentationNameTask_name); |
| |
| String[][] procPkgPaths = MultiFileResourceSetImpl.PROCESS_PACKAGE_PATHS; |
| for (Iterator iter = lib.getMethodPlugins().iterator(); iter.hasNext();) { |
| MethodPlugin plugin = (MethodPlugin) iter.next(); |
| ArrayList procPkgs = new ArrayList(); |
| for (int j = 0; j < procPkgPaths.length; j++) { |
| MethodPackage pkg = UmaUtil.findMethodPackage(plugin, |
| procPkgPaths[j]); |
| if (pkg != null) { |
| procPkgs.add(pkg); |
| } |
| } |
| for (Iterator iterator = procPkgs.iterator(); iterator.hasNext();) { |
| ProcessPackage pkg = (ProcessPackage) iterator.next(); |
| for (Iterator iterator1 = pkg.getChildPackages().iterator(); iterator1 |
| .hasNext();) { |
| EObject childPkg = (EObject) iterator1.next(); |
| if (childPkg instanceof ProcessComponent) { |
| org.eclipse.epf.uma.Process proc = ((ProcessComponent) childPkg) |
| .getProcess(); |
| if (proc != null) { |
| try { |
| fixPresentationName(proc); |
| } catch (RuntimeException e) { |
| throw e; |
| } |
| } else { |
| String msg = Migrator.class.getName() |
| + ": invalid ProcessComponent (with no Process): " + childPkg //$NON-NLS-1$ |
| + "\n ProcessComponent's resource URI: " + (childPkg.eResource() != null ? childPkg.eResource().getURI() : null) //$NON-NLS-1$ |
| + "\n Parent package: " + pkg //$NON-NLS-1$ |
| + "\n Parent package's resource URI: " + (pkg.eResource() != null ? pkg.eResource().getURI() : null) //$NON-NLS-1$ |
| ; |
| CommonPlugin.INSTANCE.log(msg); |
| System.err.println(msg); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private static void migrateProcessContentDescriptions( |
| IProgressMonitor monitor, MethodLibrary lib) { |
| updateStatus(monitor, |
| PersistenceResources.migrateContentDescriptionsTask_name); |
| |
| String[][] procPkgPaths = MultiFileResourceSetImpl.PROCESS_PACKAGE_PATHS; |
| for (Iterator iter = lib.getMethodPlugins().iterator(); iter.hasNext();) { |
| MethodPlugin plugin = (MethodPlugin) iter.next(); |
| ArrayList procPkgs = new ArrayList(); |
| for (int j = 0; j < procPkgPaths.length; j++) { |
| MethodPackage pkg = UmaUtil.findMethodPackage(plugin, |
| procPkgPaths[j]); |
| if (pkg != null) { |
| procPkgs.add(pkg); |
| } |
| } |
| for (Iterator iterator = procPkgs.iterator(); iterator.hasNext();) { |
| ProcessPackage pkg = (ProcessPackage) iterator.next(); |
| for (Iterator iterator1 = pkg.getChildPackages().iterator(); iterator1 |
| .hasNext();) { |
| Object childPkg = (Object) iterator1.next(); |
| if (childPkg instanceof ProcessComponent) { |
| org.eclipse.epf.uma.Process proc = ((ProcessComponent) childPkg) |
| .getProcess(); |
| migrateContentDescription(proc); |
| } |
| } |
| } |
| } |
| } |
| |
| private static void migrateContentDescription(BreakdownElement e) { |
| if (ContentDescriptionFactory.hasPresentation(e)) { |
| ContentDescription content = e.getPresentation(); |
| EClass eCls = ContentDescriptionFactory |
| .getContentDescriptionEClass(e); |
| if (eCls != content) { |
| ContentDescription newContent = ContentDescriptionFactory |
| .createContentDescription(e); |
| newContent.setMainDescription(content.getMainDescription()); |
| newContent.setKeyConsiderations(content.getKeyConsiderations()); |
| newContent.getSections().addAll(content.getSections()); |
| e.setPresentation(newContent); |
| } |
| } |
| if (e instanceof Activity) { |
| for (Iterator iter = ((Activity) e).getBreakdownElements() |
| .iterator(); iter.hasNext();) { |
| migrateContentDescription((BreakdownElement) iter.next()); |
| } |
| } |
| } |
| |
| private static void fixPresentationName(BreakdownElement e) { |
| if (e.getPresentationName() == null |
| || e.getPresentationName().trim().length() == 0) { |
| e.setPresentationName(e.getName()); |
| } |
| if (e instanceof Activity) { |
| for (Iterator iter = ((Activity) e).getBreakdownElements() |
| .iterator(); iter.hasNext();) { |
| fixPresentationName((BreakdownElement) iter.next()); |
| } |
| } |
| } |
| |
| } |