//------------------------------------------------------------------------------
// 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;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
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.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.common.CommonPlugin;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl;
import org.eclipse.epf.common.utils.StrUtil;
import org.eclipse.epf.library.persistence.ILibraryResourceSet;
import org.eclipse.epf.library.persistence.LibraryResourceException;
import org.eclipse.epf.persistence.refresh.RefreshJob;
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.resourcemanager.ResourcemanagerFactory;
import org.eclipse.epf.services.ILibraryPersister;
import org.eclipse.epf.uma.BreakdownElementDescription;
import org.eclipse.epf.uma.CapabilityPattern;
import org.eclipse.epf.uma.ContentDescription;
import org.eclipse.epf.uma.DeliveryProcess;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.MethodUnit;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ecore.impl.MultiResourceEObject;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.osgi.util.NLS;
import com.ibm.icu.text.SimpleDateFormat;
import com.ibm.icu.util.Calendar;
/**
* Utility class with static routines for XMI persistence
*
* @author Phong Nguyen Le
* @author Jinhua Xi
* @since 1.0
*/
public final class MultiFileSaveUtil {
public static final String DEFAULT_MODEL_FILENAME = "model.xmi"; //$NON-NLS-1$
public static final String DEFAULT_CONTENT_FILENAME = "content.xmi"; //$NON-NLS-1$
public static final String DEFAULT_LIBRARY_MODEL_FILENAME = "library.xmi"; //$NON-NLS-1$
public static final String DEFAULT_PLUGIN_EXPORT_FILENAME = "export.xmi"; //$NON-NLS-1$
public static final String DEFAULT_PLUGIN_MODEL_FILENAME = "plugin.xmi"; //$NON-NLS-1$
public static final String DEFAULT_FILE_EXTENSION = ".xmi"; //$NON-NLS-1$
public static final String LIBRARY_FILE_EXTENSION = "uma"; //$NON-NLS-1$
public static final String CAPABILITY_PATTERN_PATH = "capabilitypatterns"; //$NON-NLS-1$
public static final String DELIVERY_PROCESS_PATH = "deliveryprocesses"; //$NON-NLS-1$
public static final String PROCESS_CONTRIBUTION_PATH = "processcontributions"; //$NON-NLS-1$
public static final String METHOD_CONFIGURATION_FOLDER_NAME = "configurations"; //$NON-NLS-1$
public static final boolean DEBUG = PersistencePlugin.getDefault()
.isDebugging();
static final boolean PROFILE = false;
private static final SimpleDateFormat dateFormatter = new SimpleDateFormat(
"yyMMddHHmmss.S"); //$NON-NLS-1$
public static boolean isValidFileName(String name) {
if (name == null)
return false;
if (name.indexOf('/') != -1 || name.indexOf('\\') != -1
|| name.indexOf(':') != -1 || name.indexOf('*') != -1
|| name.indexOf('?') != -1 || name.indexOf('"') != -1
|| name.indexOf('<') != -1 || name.indexOf('>') != -1
|| name.indexOf('|') != -1)
return false;
return true;
}
public static String getPath(MethodElement e) {
StringBuffer strBuff = new StringBuffer(String.valueOf(e.getName()));
for (e = (MethodElement) ((EObject) e).eContainer(); e != null; e = (MethodElement) ((EObject) e)
.eContainer()) {
strBuff.insert(0, String.valueOf(e.getName()) + " > "); //$NON-NLS-1$
}
return strBuff.toString();
}
public static String createDirName(MethodElement obj) {
String name = ((MethodElement) obj).getName();
if (isValidFileName(name))
return name;
throw new MultiFileIOException(NLS.bind(
PersistenceResources.invalidNameError_msg, name), obj);
}
public static EObject resolve(EObject proxy) {
if (!(proxy instanceof InternalEObject))
return proxy;
InternalEObject obj = (InternalEObject) proxy;
if (obj.eProxyURI() == null)
return proxy;
XMIResourceImpl res = new XMIResourceImpl(obj.eProxyURI());
try {
res.load(null);
return PersistenceUtil.getMethodElement(res);
} catch (IOException e) {
e.printStackTrace();
}
return proxy;
}
static Resource save(EObject o, URI uri, Map options) {
ResourceSet resourceSet = o.eResource().getResourceSet();
MultiFileXMIResourceImpl resource = save(resourceSet, o, uri, options);
if (options == null) {
options = ((MultiFileResourceSetImpl) resourceSet)
.getDefaultSaveOptions();
}
String str = (String) options
.get(MultiFileXMISaveImpl.REFRESH_NEW_RESOURCE);
if (str != null && Boolean.valueOf(str).booleanValue()) {
// notify RefreshJob the this resource is saved so it will not be
// reloaded after refreshing it
//
RefreshJob.getInstance().resourceSaved(resource);
// refresh the newly created resource so it is in synch with the
// workspace
//
FileManager.getInstance().refresh(resource);
}
return resource;
}
public static boolean canSaveTogether(Map options, Object obj) {
Set saveTogetherClasses = (Set) options
.get(MultiFileXMISaveImpl.SAVE_TOGETHER_CLASS_SET);
if (saveTogetherClasses == null)
return false;
for (Iterator iter = saveTogetherClasses.iterator(); iter.hasNext();) {
EClass eCls = (EClass) iter.next();
if (eCls.isInstance(obj))
return true;
}
return false;
}
/**
* Adds the given object to the given resource while still preserving
* object's container reference.
*
* @param resource
* @param o
*/
private static void addTo(Resource resource, MultiResourceEObject o) {
BasicEList contents = ((BasicEList) resource.getContents());
if (contents.isEmpty()) {
// this will flag resource as loaded
//
contents.clear();
contents.setData(1, new Object[] { o });
} else {
Object[] data = contents.toArray();
Object[] newData = new Object[data.length + 1];
System.arraycopy(data, 0, newData, 0, data.length);
newData[data.length] = o;
contents.setData(newData.length, newData);
}
o.eSetResource((Resource.Internal) resource);
}
/**
* Saves a new contained EObject in its own new resource.
*
* @param o
* @param uri
* @param options
*/
private static MultiFileXMIResourceImpl save(ResourceSet resourceSet,
EObject o, URI uri, Map options) {
return save(resourceSet, o, uri, options, true);
}
static MultiFileXMIResourceImpl save(ResourceSet resourceSet,
EObject o, URI uri, Map options, boolean registerWithResourceManager) {
// Detach the object from container resource
//
MultiResourceEObject mrEObj = (MultiResourceEObject) o;
MultiFileXMIResourceImpl currentResource = (MultiFileXMIResourceImpl) o
.eResource();
if (currentResource != null) {
currentResource.detached(o);
}
List newResourceDescriptors = null;
Set modifiedResources = (Set) options
.get(MultiFileXMISaveImpl.MODIFIED_RESOURCE_SET);
MultiFileXMIResourceImpl res = null;
if (canSaveTogether(options, o)) {
MultiFileResourceSetImpl mfResourceSet = ((MultiFileResourceSetImpl) resourceSet);
// if the uri has a temporary URI, use it instead to locate the
// resource that is in process of saving
//
URI tempURI = (URI) mfResourceSet.getURIToTempURIMap().get(uri);
if (tempURI != null) {
uri = tempURI;
}
res = (MultiFileXMIResourceImpl) mfResourceSet.getResource(uri);
if (res != null) {
if (!res.getContents().contains(o)) {
if (res.getFinalURI() == res.getURI()) {
if (MultiFileXMISaveImpl.checkModifyRequired(options)) {
// not a temp file of fail-safe persistence
// transaction
// check for writeable
//
MultiFileSaveUtil.checkModify(res);
}
}
addTo(res, mrEObj);
ResourceDescriptor desc = null;
try {
if(registerWithResourceManager) {
// register this new object with ResourceManager
//
ResourceManager resMgr = getResourceManagerFor(o,
modifiedResources);
desc = registerWithResourceManager(resMgr, o, res
.getFinalURI());
if (desc != null && modifiedResources != null) {
modifiedResources.add(resMgr.eResource());
}
}
res.setModified(true);
mfResourceSet.save(res, options, false);
res.attachedAll(o);
} catch (Exception e) {
// rollback
//
// remove this object from the resource
res.getContents().remove(mrEObj);
mrEObj.eSetResource((Resource.Internal) null);
// remove the created ResourceDescriptor
if (desc != null) {
EcoreUtil.remove(desc);
}
// re-attach to container resource
if (currentResource != null) {
currentResource.attached(o);
}
throw new MultiFileIOException(e.getMessage());
}
}
return res;
}
}
res = (MultiFileXMIResourceImpl) resourceSet.createResource(uri);
addTo(res, mrEObj);
if(mrEObj instanceof MethodPlugin) {
addResourceManager(res);
}
Map objToContainerMap = null;
try {
if(registerWithResourceManager) {
newResourceDescriptors = registerWithResourceManager(res,
modifiedResources);
}
// back up the container references and set content object's
// container to null
//
objToContainerMap = removeContainers(res);
res.save(options);
res.attachedAll(o);
} catch (Exception e) {
CommonPlugin.INSTANCE.log(e);
// rollback
//
// remove the failed reousrce from the resource set
resourceSet.getResources().remove(res);
mrEObj.eSetResource((Resource.Internal) null);
// remove the created ResourceDescriptors
if(newResourceDescriptors != null && !newResourceDescriptors.isEmpty()) {
for (Iterator iter = newResourceDescriptors.iterator(); iter
.hasNext();) {
EcoreUtil.remove((EObject) iter.next());
}
}
// re-attach to container resource
if (currentResource != null) {
currentResource.attached(o);
}
throw new MultiFileIOException(e.getMessage());
} finally {
// restore the container references for the content objects
//
restoreContainers(res, objToContainerMap);
}
if(registerWithResourceManager) {
ResourceManager resMgr = addNewResourceManager(res);
if (resMgr == null) {
if (o instanceof MethodPlugin) {
// create new ResourceManager for new MethodPlugin
//
resMgr = getResourceManagerFor(o, modifiedResources);
}
} else if (modifiedResources != null) {
modifiedResources.add(resMgr.eContainer().eResource());
}
}
res.updateTimeStamps();
return res;
}
private static Map removeContainers(Resource resource) {
int size = resource.getContents().size();
Map objToContainerMap = new HashMap();
for (int i = 0; i < size; i++) {
MultiResourceEObject multiResEObj = (MultiResourceEObject) resource
.getContents().get(i);
InternalEObject container = (InternalEObject) multiResEObj
.eContainer();
if (container != null) {
objToContainerMap.put(multiResEObj, container);
multiResEObj.eBasicSetContainer(null, multiResEObj
.eContainerFeatureID());
}
}
return objToContainerMap;
}
/**
* Gets the containers of objects in resource's contents
*
* @param resource
* @return map of object to container entries
*/
static Map getContainers(Resource resource) {
int size = resource.getContents().size();
Map objToContainerMap = new HashMap();
for (int i = 0; i < size; i++) {
MultiResourceEObject multiResEObj = (MultiResourceEObject) resource
.getContents().get(i);
InternalEObject container = (InternalEObject) multiResEObj
.eContainer();
if (container != null) {
objToContainerMap.put(multiResEObj, container);
}
}
return objToContainerMap;
}
/**
* Restores the containers of the objects in resource's contents that
* previously saved in a map returned from getContainers(Resource resource)
* or removeContainers(Resource resource)
*
* @param resource
* @param objToContainerMap
* @see #getContainers(Resource)
* @see #removeContainers(Resource)
*/
private static void restoreContainers(Resource resource,
Map objToContainerMap) {
int size = resource.getContents().size();
for (int i = 0; i < size; i++) {
MultiResourceEObject multiResEObj = (MultiResourceEObject) resource
.getContents().get(i);
InternalEObject container = (InternalEObject) objToContainerMap
.get(multiResEObj);
if (container != null) {
multiResEObj.eBasicSetContainer(container, multiResEObj
.eContainerFeatureID());
}
}
}
public static void checkModify(Resource resource) {
checkModify(Collections.singleton(resource));
}
static void doCheckModify(Collection<Resource> resources) {
ArrayList<String> pathList = new ArrayList<String>();
for (Iterator iter = resources.iterator(); iter.hasNext();) {
Resource resource = (Resource) iter.next();
// skip checking on resource that is currently being saved to a temporary
// file
//
if(resource instanceof MultiFileXMIResourceImpl && ((MultiFileXMIResourceImpl)resource).hasTempURI()) {
continue;
}
pathList.add(FileManager.toFileString(resource.getURI()));
}
if(!pathList.isEmpty()) {
String[] paths = new String[pathList.size()];
pathList.toArray(paths);
IStatus status = FileManager.getInstance().checkModify(paths,
PersistencePlugin.getDefault().getContext()/*MsgBox.getDefaultShell()*/);
if (!status.isOK()) {
String msg = UmaUtil.getMessage(status);
if (msg == null) {
msg = NLS.bind(PersistenceResources.modifyFileError_msg, Arrays
.asList(paths));
}
throw new MultiFileIOException(msg);
}
}
}
public static void checkModify(Collection<Resource> resources) {
Map<ILibraryResourceSet, Collection<Resource>> libResourceSetToResourcesMap = new HashMap<ILibraryResourceSet, Collection<Resource>>();
Collection<Resource> otherResources = new ArrayList<Resource>();
for (Iterator iter = resources.iterator(); iter.hasNext();) {
Resource resource = (Resource) iter.next();
ResourceSet resourceSet = resource.getResourceSet();
if(resourceSet instanceof ILibraryResourceSet) {
Collection<Resource> collection = libResourceSetToResourcesMap.get(resourceSet);
if(collection == null) {
collection = new ArrayList<Resource>();
libResourceSetToResourcesMap.put((ILibraryResourceSet) resourceSet, collection);
}
collection.add(resource);
}
else {
otherResources.add(resource);
}
}
if(!libResourceSetToResourcesMap.isEmpty()) {
for (Iterator<Map.Entry<ILibraryResourceSet, Collection<Resource>>> iter = libResourceSetToResourcesMap.entrySet().iterator(); iter.hasNext();) {
Map.Entry<ILibraryResourceSet, Collection<Resource>> entry = iter.next();
ILibraryResourceSet resourceSet = entry.getKey();
Resource[] resourceArray = new Resource[entry.getValue().size()];
entry.getValue().toArray(resourceArray);
try {
resourceSet.checkModify(resourceArray, PersistencePlugin.getDefault().getContext()/*MsgBox.getDefaultShell()*/);
} catch (LibraryResourceException e) {
throw new MultiFileIOException(e.getMessage());
}
}
}
if(!otherResources.isEmpty()) {
doCheckModify(otherResources);
}
}
public static void checkOutOfSynch(Collection<Resource> resources, Map saveOptions) {
Collection<Resource> resourcesToCheckOutOfSynch;
Collection<Resource> overwritableResources = (Collection<Resource>) saveOptions.get(
ILibraryPersister.FailSafeMethodLibraryPersister.OPTIONS_OVERWRITABLE_RESOURCES);
if(overwritableResources != null && !overwritableResources.isEmpty()) {
resourcesToCheckOutOfSynch = new ArrayList<Resource>(resources);
resourcesToCheckOutOfSynch.removeAll(overwritableResources);
}
else {
resourcesToCheckOutOfSynch = resources;
}
if(!resourcesToCheckOutOfSynch.isEmpty()) {
checkOutOfSynch(resourcesToCheckOutOfSynch);
}
}
private static void checkOutOfSynch(Collection resources) {
// check for out-of-synch
//
for (Iterator iter = resources.iterator(); iter.hasNext();) {
MultiFileXMIResourceImpl res = (MultiFileXMIResourceImpl) iter
.next();
if(res.isLoaded() && !res.hasTempURI()) {
File file = new File(res.getURI().toFileString());
if(file.exists()) {
// long lastModified = file.lastModified();
// if (res.getFileLastModified() != lastModified && !same(lastModified, res.getFileLastModified())) {
// String msg = NLS.bind(
// PersistenceResources.resourceOutOfSynch_msg, res
// .getURI().toFileString());
// throw new MultiFileIOException(msg);
// }
if(!res.isSynchronized()) {
String msg = NLS.bind(
PersistenceResources.resourceOutOfSynch_msg,
res.getURI().toFileString());
throw new MultiFileIOException(msg);
}
}
}
}
}
/**
* Saves the existing own resource of a contained EObject. Adds resources
* that have been modifed after this call to the MODIFIED_RESOURCE_SET of
* the save options.
*
* @param resource
* @param options
* @return true if the given resource has been saved successfully, false otherwise
*/
public static boolean save(Resource resource, Map options) {
if (resource.getContents().isEmpty())
return false;
Set modifiedResources = (Set) options
.get(MultiFileXMISaveImpl.MODIFIED_RESOURCE_SET);
// should not change resource location automatically without letting
// user know about it
//
// adjustLocation(resource, modifiedResources);
// back up the container references and set content object's container
// to null
//
Map objToContainerMap = removeContainers(resource);
try {
resource.save(options);
} catch (IOException e) {
e.printStackTrace();
throw new MultiFileIOException(e.getMessage());
} finally {
// restore the container references for the content objects
//
restoreContainers(resource, objToContainerMap);
}
ResourceManager resMgr = addNewResourceManager(resource);
if (resMgr != null && modifiedResources != null) {
modifiedResources.add(resMgr.eContainer().eResource());
}
return true;
}
/**
*
* @param resource
* @return ResourceManager that is just added to the resource manager tree
* or null.
*/
private static ResourceManager addNewResourceManager(Resource resource) {
ResourceManager resMgr = getResourceManager(resource);
MethodElement e = PersistenceUtil.getMethodElement(resource);
if (e == null) {
return null;
}
EObject container = e.eContainer();
if (resMgr != null && container != null && resMgr.eContainer() == null) {
// new ResourceManager is added to the resource
//
ResourceManager parentResMgr = getResourceManager(container
.eResource());
// check if resMgr is already a sub manager of parentResMgr before
// adding it
//
if (!parentResMgr.getSubManagers().contains(resMgr)) {
parentResMgr.getSubManagers().add(resMgr);
registerWithResourceManager(parentResMgr, e, MultiFileSaveUtil.getFinalURI(resource));
return resMgr;
}
// registerWithResourceManager(parentResMgr, resMgr,
// resMgr.eResource().getURI().appendFragment(resMgr.getGuid()));
// return resMgr;
}
return null;
}
private static String toFileString(EObject eObj) {
return eObj.eResource().getResourceSet().getURIConverter().normalize(
eObj.eResource().getURI()).toFileString();
}
static boolean hasOwnFolder(Object e) {
return e instanceof MethodPlugin || e instanceof ProcessComponent;
}
static boolean hasOwnResource(Object obj, Collection saveSeparatelyClassSet) {
if (obj instanceof MethodUnit)
return true;
if (saveSeparatelyClassSet == null)
return false;
for (Iterator iter = saveSeparatelyClassSet.iterator(); iter.hasNext();) {
EClass eCls = (EClass) iter.next();
if (eCls.isInstance(obj))
return true;
}
return false;
}
static URI createFileURI(MethodElement e) {
if (e.eContainer() == null)
return ((MultiFileXMIResourceImpl) e.eResource()).getFinalURI();
// Handle ProcessComponent specially. ProcessComponent objects are
// stored as following in the method library:
// <Method Library>
// |_ <Method Plugin>
// |_processes
// |_capability_patterns
// |_delivery_processes
// |_process_contributions
//
if (e instanceof ProcessComponent) {
MethodPlugin plugin = UmaUtil.getMethodPlugin(e);
if(plugin == null) {
return null;
}
Resource resource = plugin.eResource();
if (resource == null) {
}
String pluginDir = null;
if (! UmaUtil.hasDirectResource(plugin)) {
resource = null;
}
if(resource != null) {
pluginDir = new File(getFinalURI(resource).toFileString()).getParent();
}
else {
MethodLibrary lib = (MethodLibrary) plugin.eContainer();
if (lib != null) {
String libDir = new File(((MultiFileXMIResourceImpl) lib
.eResource()).getFinalURI().toFileString()).getParent();
pluginDir = libDir + File.separator + plugin.getName();
}
}
if(pluginDir == null) {
// plugin is already deleted
//
return null;
}
String relativeDir;
org.eclipse.epf.uma.Process proc = ((ProcessComponent) e)
.getProcess();
if (proc instanceof CapabilityPattern) {
relativeDir = CAPABILITY_PATTERN_PATH;
} else if (proc instanceof DeliveryProcess) {
relativeDir = DELIVERY_PROCESS_PATH;
} else {
relativeDir = ""; //$NON-NLS-1$
}
String path = pluginDir + File.separator + relativeDir
+ File.separator + e.getName() + File.separator
+ DEFAULT_MODEL_FILENAME;
return URI.createFileURI(path);
} else if (e instanceof BreakdownElementDescription) {
String dir = null;
try {
dir = new File(((MultiFileXMIResourceImpl) UmaUtil
.getProcessComponent(e).eResource()).getFinalURI()
.toFileString()).getParent();
} catch (RuntimeException ex) {
throw ex;
}
return URI.createFileURI(dir + File.separator
+ DEFAULT_CONTENT_FILENAME);
} else if (e instanceof ContentDescription) {
URI uri;
ContentDescription content = (ContentDescription) e;
String path = MethodLibraryPersister.getCorrectPath(content);
if (path == null) {
String dir = ((MultiFileXMIResourceImpl) e.eResource())
.getFinalURI().trimSegments(1).toFileString()
+ File.separator;
path = MethodLibraryPersister.getNextAvailableFileName(dir,
content);
}
uri = URI.createFileURI(path);
return uri;
} else if (e instanceof MethodConfiguration) {
String dir = new StringBuffer(((MultiFileXMIResourceImpl) e
.eContainer().eResource()).getFinalURI().trimSegments(1)
.toFileString()).append(File.separator).append(
METHOD_CONFIGURATION_FOLDER_NAME).append(File.separator)
.toString();
String path = MethodLibraryPersister.getNextAvailableFileName(dir,
StrUtil.makeValidFileName(e.getName()),
(MultiResourceEObject) e);
return URI.createFileURI(path);
}
StringBuffer path = new StringBuffer();
EObject lastContainer = null;
for (MethodElement obj = (MethodElement) e.eContainer(); obj != null; obj = (MethodElement) obj
.eContainer()) {
lastContainer = obj;
if (obj instanceof MethodLibrary) {
path.insert(0, new File(((MultiFileXMIResourceImpl) obj
.eResource()).getFinalURI().toFileString())
.getParentFile().getAbsolutePath());
break;
} else {
path.insert(0, obj.getName()).insert(0, File.separatorChar);
}
}
if (lastContainer == null) {
return e.eResource() != null ? ((MultiFileXMIResourceImpl) e
.eResource()).getFinalURI() : null;
}
if (!(lastContainer instanceof MethodLibrary)) {
path.insert(0, new File(toFileString(lastContainer))
.getParentFile().getParentFile().getAbsolutePath());
}
String modelFileName;
if (e instanceof MethodPlugin) {
modelFileName = DEFAULT_PLUGIN_MODEL_FILENAME;
} else {
modelFileName = MultiFileSaveUtil.DEFAULT_MODEL_FILENAME;
}
URI uri = URI.createFileURI(path.toString() + File.separator
+ MultiFileSaveUtil.createDirName(e) + File.separator
+ modelFileName);
return uri;
}
public static void delete(File file) {
File[] files = file.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
delete(files[i]);
}
}
file.delete();
}
/**
*
* @param e
* @param uri
* @param modifiedResources
* output of resources that have been changed after this call.
*/
static void setURIMapping(EObject e, URI uri, Set modifiedResources) {
MultiFileURIConverter uriConverter = (MultiFileURIConverter) e
.eResource().getResourceSet().getURIConverter();
uriConverter.setURIMapping(e, uri, modifiedResources);
}
/**
*
* @param resource
* @param modifiedResources
* output of resources that have been changed after this call
*/
static void updateURIMappings(MultiFileXMIResourceImpl resource,
Set modifiedResources) {
updateURIMappings(resource, modifiedResources, true);
}
/**
* Checks if the given resourceSet has the loaded resource with the given
* uri
*
* @param resourceSet
* @param uri
* @return
*/
static boolean hasLoadedResource(ResourceSet resourceSet, URI uri) {
for (Iterator iter = resourceSet.getResources().iterator(); iter
.hasNext();) {
Resource resource = (Resource) iter.next();
if (resource.isLoaded() && resource.getURI().equals(uri)) {
return true;
}
}
return false;
}
/**
* Update the URIMappings with the final URI of the given resource
*
* @param resource
*/
static void updateURIMappings(MultiFileXMIResourceImpl resource,
Set modifiedResources, boolean afterMove) {
updateURIMappings(resource, resource.getFinalURI(), modifiedResources,
afterMove);
}
static void updateURIMappings(MultiFileXMIResourceImpl resource, URI uri,
Set modifiedResources, boolean afterMove) {
// the resource URI has been changed, reset all the cached resolved URI
// in all offstring resource descriptors
// of its manager, if it has one.
//
HashMap oldURIToResourceDescriptorMap = null;
ResourceManager resMgr = getResourceManager(resource);
if (resMgr != null) {
oldURIToResourceDescriptorMap = new HashMap();
for (Iterator iter = resMgr.eAllContents(); iter.hasNext();) {
Object obj = iter.next();
if (obj instanceof ResourceDescriptor) {
ResourceDescriptor desc = ((ResourceDescriptor) obj);
oldURIToResourceDescriptorMap.put(desc.getResolvedURI(),
desc);
if (afterMove) {
desc.clearResolvedURI();
}
}
}
}
if (!resource.getContents().isEmpty()) {
EObject element = PersistenceUtil.getMethodElement(resource);
// setURIMapping(element, resource.getFinalURI(),
// modifiedResources);
MultiFileURIConverter uriConverter = (MultiFileURIConverter) resource
.getResourceSet().getURIConverter();
uriConverter.setURIMapping(element, uri, modifiedResources,
afterMove);
}
// for (Iterator iter = resource.getContents().iterator();
// iter.hasNext();) {
// EObject element = (EObject) iter.next();
// setURIMapping(element, resource.getURI(), modifiedResources);
// }
if (oldURIToResourceDescriptorMap != null) {
// go thru the list of loaded resources in resource set to update
// the URI
//
for (Iterator iter = resource.getResourceSet().getResources()
.iterator(); iter.hasNext();) {
Resource res = (Resource) iter.next();
ResourceDescriptor desc = (ResourceDescriptor) oldURIToResourceDescriptorMap
.get(res.getURI());
if (desc != null) {
if (afterMove) {
res.setURI(desc.getResolvedURI());
} else if (res.isLoaded()) {
desc.clearResolvedURI();
res.setURI(desc.getResolvedURI());
}
}
}
}
}
/**
* @param resMgr
* @param o
* @param uri
*/
// private static void setUri(ResourceManager resMgr, MethodElement e, URI
// uri) {
// for (Iterator iter = resMgr.getResourceDescriptors().iterator();
// iter.hasNext();) {
// ResourceDescriptor resDesc = (ResourceDescriptor) iter.next();
// if(resDesc.getId().equals(e.getGuid())) {
// // change other URIs that are changed as result of this URI change
// //
// if(uri.fragment() == null) {
// URI oldDir = URI.createFileURI(new
// File(resDesc.getResolvedURI().toFileString()).getParent() +
// File.separator);
// URI newDir = URI.createFileURI(new File(uri.toFileString()).getParent() +
// File.separator);
// for (Iterator iterator = resMgr.getResourceDescriptors().iterator();
// iterator
// .hasNext();) {
// ResourceDescriptor element = (ResourceDescriptor) iterator.next();
// URI currentUri = element.getResolvedURI();
// URI newUri = currentUri.replacePrefix(oldDir, newDir);
// if(newUri != null) {
// element.setResolvedURI(newUri);
// }
// }
// }
// resDesc.setResolvedURI(uri);
// return;
// }
// }
// ResourceDescriptor resDesc =
// ResourcemanagerFactory.eINSTANCE.createResourceDescriptor();
// resDesc.setId(e.getGuid());
// resDesc.setResolvedURI(uri);
// resMgr.getResourceDescriptors().add(resDesc);
// }
/**
* Gets the right ResourceManager for the given EObject, creates new
* ResourceManager if it does not exist yet.
*
* @param modifiedResources
* output of resources that have been changed after this call.
*/
static ResourceManager getResourceManagerFor(EObject eObj,
Set modifiedResources) {
Resource resource = eObj.eContainer() != null ? eObj.eContainer()
.eResource() : eObj.eResource();
ResourceManager resMgr = getResourceManager(resource);
if (resMgr == null) {
resMgr = ResourcemanagerFactory.eINSTANCE.createResourceManager();
// add to beginning of the resource's contents
//
resource.getContents().add(0, resMgr);
if (modifiedResources != null) {
modifiedResources.add(resource);
}
EObject container = getContainerWithDirectResource((InternalEObject) eObj);
if (container != null && container.eResource() != resource) {
ResourceManager parentResMgr = getResourceManagerFor(container,
modifiedResources);
if (parentResMgr != null) {
parentResMgr.getSubManagers().add(resMgr);
if (modifiedResources != null) {
modifiedResources.add(parentResMgr.eResource());
}
}
}
}
return resMgr;
}
static List registerWithResourceManager(MultiFileXMIResourceImpl resource,
Set modifiedResources) {
ResourceManager resMgr = getResourceManagerFor(
PersistenceUtil.getMethodElement(resource), modifiedResources);
List resourceDescriptors = new ArrayList();
for (Iterator iter = resource.getContents().iterator(); iter.hasNext();) {
Object element = iter.next();
if(element instanceof MethodElement) {
ResourceDescriptor resDesc = registerWithResourceManager(resMgr,
element, resource.getFinalURI());
if (resDesc != null) {
resourceDescriptors.add(resDesc);
}
}
}
if (!resourceDescriptors.isEmpty() && modifiedResources != null) {
modifiedResources.add(resMgr.eResource());
}
return resourceDescriptors;
}
public static ResourceDescriptor registerWithResourceManager(
ResourceManager resMgr, Object element, URI uri) {
String guid = getGuid(element);
if (resMgr.getResourceDescriptor(guid) == null) {
return createResourceDescriptor(resMgr, guid, uri);
} else {
return null;
}
}
// /**
// * Creates a new ResourceDescriptor for the given MethodElement and add it
// to the given ResourceManager
// *
// * @param e
// * @return newly added ResourceDescriptor
// */
// private static ResourceDescriptor
// createResourceDescriptor(ResourceManager resMgr, MethodElement e) {
// return createResourceDescriptor(resMgr, e.getGuid(), createFileURI(e));
// }
/**
* Creates a new ResourceDescriptor with the given id and resolvedURI, then
* adds it to the given resMgr
*
* @param resMgr
* @param id
* @param resolvedURI
* @return
*/
private static ResourceDescriptor createResourceDescriptor(
ResourceManager resMgr, String id, URI resolvedURI) {
ResourceDescriptor resDesc = ResourcemanagerFactory.eINSTANCE
.createResourceDescriptor();
resDesc.setId(id);
resMgr.getResourceDescriptors().add(resDesc);
resDesc.setResolvedURI(resolvedURI);
return resDesc;
}
// static void setUri(MultiFileURIConverter uriConverter, MethodElement e,
// URI uri) {
// setUri(uriConverter, e, uri, false);
// }
// static void setUri(MultiFileURIConverter uriConverter, MethodElement e,
// URI uri, boolean saveNow) {
// ResourceManager resMgr = uriConverter.getResourceManager();
// if(resMgr == null) {
// resMgr = ResourcemanagerFactory.eINSTANCE.createResourceManager();
// uriConverter.setResourceManager(resMgr);
// }
// setUri(resMgr, e, uri);
// resMgr.eResource();
// }
/**
* @param element
*/
public static void setGuid(MethodElement e) {
if (e.getGuid() == null || e.getGuid().trim().length() == 0) {
e.setGuid(EcoreUtil.generateUUID());
}
}
/**
* Saves the given MethodElement in its own file while still preserving the
* existing containment association if there is any
*
* @param e
* @throws LibraryResourceException
*/
public static void save(MethodElement e, Map options) throws LibraryResourceException {
MultiFileXMIResourceImpl resource = (MultiFileXMIResourceImpl) e
.eResource();
MultiFileResourceSetImpl resourceSet = (MultiFileResourceSetImpl) resource
.getResourceSet();
if (options == null) {
options = resourceSet.getDefaultSaveOptions();
}
EObject container = e.eContainer();
Set modifiedResources = new HashSet();
options.put(MultiFileXMISaveImpl.MODIFIED_RESOURCE_SET,
modifiedResources);
try {
URI uri = MultiFileSaveUtil.createURI(e, resourceSet);
boolean createResource = resource == null
|| (container != null && resource == container.eResource());
if (createResource) {
MultiFileSaveUtil.save(e, uri, options);
} else {
URI oldUri = resource.getURI();
if (!oldUri.equals(uri)) {
// resource's location is changed.
// move the resource, then change its URI if the resource
// move is successful.
//
if (FileManager.getInstance().move(oldUri.toFileString(),
uri.toFileString())) {
// MultiFileURIConverter uriConverter =
// (MultiFileURIConverter)
// resource.getResourceSet().getURIConverter();
// MultiFileSaveUtil.setUri(uriConverter, e, uri);
resource.setURI(uri);
updateURIMappings(resource, modifiedResources);
}
}
if (resource.isModified()) {
MultiFileSaveUtil.save(resource, options);
}
}
resourceSet.saveModifiedResources(options);
} finally {
}
}
public static URI createURI(MethodElement e, ResourceSet resourceSet) {
URI uri = null;
if(resourceSet instanceof MultiFileResourceSetImpl) {
IURIProvider uriProvider = ((MultiFileResourceSetImpl)resourceSet).getURIProvider();
if(uriProvider != null) {
uri = uriProvider.getURI(e);
}
}
if(uri == null) {
uri = createFileURI(e);
}
return uri;
}
public static void save(ResourceSet resourceSet, MethodElement e,
Map options) {
URI uri = createURI(e, resourceSet);
save(resourceSet, e, uri, options);
}
static void adjustLocation(Resource resource, Set modifiedResources) {
MethodElement e = PersistenceUtil.getMethodElement(resource);
if (e == null)
return;
URI newFile = createURI(e, resource.getResourceSet());
if (newFile != null && adjustLocation(resource, newFile)) {
resource.setURI(newFile);
updateURIMappings((MultiFileXMIResourceImpl) resource,
modifiedResources);
}
}
static URI getNewURI(MultiFileXMIResourceImpl resource) {
MethodElement e = PersistenceUtil.getMethodElement(resource);
if (e == null) {
return null;
}
URI newFile = createURI(e, resource.getResourceSet());
if (newFile != null && adjustLocationRequired(resource, newFile)) {
return newFile;
}
return null;
}
static boolean prepareAdjustLocation(MultiFileXMIResourceImpl resource,
Set modifiedResources) {
URI newFile = getNewURI(resource);
if (newFile != null) {
resource.backUpURI();
resource.setFinalURI(newFile);
updateURIMappings((MultiFileXMIResourceImpl) resource,
modifiedResources, false);
return true;
}
return false;
}
public static String getGuid(Object e) {
if(e instanceof InternalEObject) {
InternalEObject o = (InternalEObject) e;
if(o.eIsProxy()) {
URI uri = o.eProxyURI();
if(uri != null && MultiFileURIConverter.SCHEME.equals(uri.scheme())) {
String guid = uri.fragment();
if(guid != null) {
return guid;
}
}
}
}
if (e instanceof MethodElement) {
return ((MethodElement) e).getGuid();
} else if (e instanceof ResourceManager) {
return ((ResourceManager) e).getGuid();
}
return null;
}
static boolean adjustLocationRequired(MultiFileXMIResourceImpl resource,
URI newURI) {
File oldFile = new File(resource.getFinalURI().toFileString());
File newFile = new File(newURI.toFileString());
return !oldFile.equals(newFile);
}
/**
* Checks if the resource's URI has been changed and adjust the resource's
* location.
*
* @param oldUri
* @param newUri
*/
static boolean adjustLocation(Resource resource, URI newUri) {
File oldFile = new File(resource.getURI().toFileString());
File newFile = new File(newUri.toFileString());
if (oldFile.equals(newFile)) {
return false;
}
return move(resource, oldFile, newFile);
}
static boolean move(Resource resource, File oldFile, File newFile) {
boolean ret = true;
if (oldFile.equals(newFile)) {
return false;
}
Object obj = PersistenceUtil.getMethodElement(resource);
if (hasOwnFolder(obj)) {
String oldDir = oldFile.getParentFile().toString();
if (!oldFile.getParentFile().equals(newFile.getParentFile())) {
if (FileManager.getInstance().rename(oldFile.getParentFile(),
newFile.getParentFile())) {
if (DEBUG) {
System.out
.println("Directory '" + oldDir + "' is successfully moved to '" + newFile.getParentFile() + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
} else {
ret = false;
if (DEBUG) {
System.out
.println("Could not move directory '" + oldDir + "' to '" + newFile.getParentFile() + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
}
}
if (!oldFile.getName().equals(newFile.getName())) {
oldFile = new File(newFile.getParentFile(), oldFile.getName());
if (FileManager.getInstance().rename(oldFile, newFile)) {
if (DEBUG) {
System.out
.println("File '" + oldFile + "' is successfully moved to '" + newFile + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
} else {
ret = false;
if (DEBUG) {
System.out
.println("Could not move file '" + oldFile + "' to '" + newFile + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
}
}
return ret;
} else if (oldFile.exists()) /* if(oldFile.getParentFile().equals(newFile.getParentFile())) */{
String oldFileStr = oldFile.toString();
if (FileManager.getInstance().rename(oldFile, newFile)) {
if (DEBUG) {
System.out
.println("File '" + oldFileStr + "' is successfully moved to '" + newFile + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
return true;
} else {
if (DEBUG) {
System.out
.println("Could not move file '" + oldFileStr + "' to '" + newFile + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
}
}
return false;
}
/**
*
* @param resMgr
* @param guid
* @param excludedResManagers
* ResourceManager that are excluded from this search
* @return
*/
public static ResourceDescriptor findResourceDescriptor(
ResourceManager resMgr, String guid,
Collection excludedResManagers, boolean resolveProxy) {
try {
ResourceDescriptor desc = resMgr.getResourceDescriptor(guid);
if (desc != null)
return desc;
// TODO: (Phong) performance improvement needed to avoid loading
// resources excessively
//
Iterator iter;
if (resolveProxy) {
iter = new ArrayList(resMgr.getSubManagers()).iterator();
} else {
iter = ((InternalEList) resMgr.getSubManagers())
.basicIterator();
}
while (iter.hasNext()) {
ResourceManager mgr = (ResourceManager) iter.next();
if (mgr != null
&& !mgr.eIsProxy()
&& (excludedResManagers == null || !excludedResManagers
.contains(mgr))) {
desc = findResourceDescriptor(mgr, guid,
excludedResManagers, resolveProxy);
if (desc != null)
return desc;
}
}
return null;
} catch (RuntimeException e) {
throw e;
}
}
/**
*
* @param resMgr
* @return how many ResourceDescriptors are in the resMgr and its
* SubManagers
*/
public static int getCountResourceDescriptors(ResourceManager resMgr) {
int count = resMgr.getResourceDescriptors().size();
for (Iterator iter = resMgr.getSubManagers().iterator(); iter.hasNext();) {
ResourceManager mgr = (ResourceManager) iter.next();
count += getCountResourceDescriptors(mgr);
}
return count;
}
/**
* Gets the resource descriptor for the given resource
*
* @param resource
* @return
*/
public static ResourceDescriptor getResourceDescriptor(Resource resource) {
ResourceManager containerResMgr = null;
MethodElement me = null;
for (Iterator iter = resource.getContents().iterator(); iter.hasNext();) {
Object element = iter.next();
if (element instanceof MethodLibrary) {
ResourceManager resMgr = getResourceManager(resource);
if (resMgr != null) {
ResourceDescriptor desc = resMgr
.getResourceDescriptor(((MethodElement) element)
.getGuid());
// hack to add missing ResourceDescriptor for library's
// resource
//
if (desc == null) {
desc = registerWithResourceManager(resMgr, element,
((MultiFileXMIResourceImpl) resource)
.getFinalURI());
}
return desc;
}
}
if (me == null && element instanceof MethodElement) {
me = (MethodElement) element;
}
if (containerResMgr == null && element instanceof InternalEObject) {
EObject container = getContainerWithDirectResource((InternalEObject) element);
if (container != null) {
containerResMgr = getResourceManager(container.eResource());
}
}
if (me != null && containerResMgr != null) {
break;
}
}
if(me != null) {
if (containerResMgr != null) {
return containerResMgr.getResourceDescriptor(((MethodElement) me)
.getGuid());
}
else if(me.eContainer() == null) {
// this element has been loaded before its container accessed it
// try to find its resource descriptor using root resource manager
//
ResourceSet resourceSet = resource.getResourceSet();
if(resourceSet instanceof MultiFileResourceSetImpl) {
ResourceManager rootResMgr = ((MultiFileResourceSetImpl)resourceSet).getRootResourceManager();
Iterator iter = new AbstractTreeIterator(rootResMgr) {
/**
* Comment for <code>serialVersionUID</code>
*/
private static final long serialVersionUID = 1L;
protected Iterator getChildren(Object object) {
if(object instanceof ResourceManager) {
ArrayList children = new ArrayList();
ResourceManager resMgr = (ResourceManager)object;
children.addAll(resMgr.getResourceDescriptors());
children.addAll(resMgr.getSubManagers());
return children.iterator();
}
return Collections.EMPTY_LIST.iterator();
}
};
URI uri = getFinalURI(resource);
while(iter.hasNext()) {
Object o = iter.next();
if(o instanceof ResourceDescriptor) {
ResourceDescriptor resDesc = (ResourceDescriptor) o;
if(uri.equals(resDesc.getResolvedURI())) {
return resDesc;
}
}
}
}
}
}
return null;
}
// public static ResourceDescriptor findResourceDescriptor(MethodElement e)
// {
// ResourceManager resMgr = null;
// if(e.eResource() != null) {
// resMgr = getResourceManager(e.eResource());
// }
// ResourceDescriptor desc = null;
// Collection excludedResMgrs = null;
// if(resMgr != null) {
// desc = findResourceDescriptor(resMgr, e.getGuid());
// if(desc != null) return desc;
// excludedResMgrs = Collections.singletonList(resMgr);
// }
//
// MethodLibrary lib = UmaUtil.getMethodLibrary(e);
// resMgr = getResourceManager(lib.eResource());
//
// return findResourceDescriptor(resMgr, e.getGuid(), excludedResMgrs);
// }
/**
* Gets the ResourceManager in the contents of the given resource
*
* @param resource
* @return
*/
public static ResourceManager getResourceManager(Resource resource) {
ResourceManager resMgr = null;
for (Iterator iter = resource.getContents().iterator(); iter.hasNext();) {
Object element = (Object) iter.next();
if (element instanceof ResourceManager) {
resMgr = (ResourceManager) element;
break;
}
}
return resMgr;
}
static InternalEObject getContainerWithDirectResource(InternalEObject obj) {
if (obj.eContainer() == null)
return null;
InternalEObject container = (InternalEObject) ((InternalEObject) obj
.eContainer());
if (container.eDirectResource() != null) {
return container;
}
return getContainerWithDirectResource(container);
}
static String getHREF(Resource resource, Object obj) {
MethodElement owner = PersistenceUtil.getMethodElement(resource);
return MultiFileURIConverter.createURI(owner.getGuid()).appendFragment(
getGuid(obj)).toString();
}
public static String getBackupFileSuffix() {
return "_" + dateFormatter.format(Calendar.getInstance().getTime()); //$NON-NLS-1$
}
/**
* Resolve the proxy identified by the given <code>guid</code> without
* loading all other proxies in <code>parent</code>
*
* @param guid
* @param parent
* @return
*/
public static void resolveProxies(Collection GUIDs, EObject parent) {
for (Iterator iterator = parent.eClass().getEAllContainments()
.iterator(); !GUIDs.isEmpty() && iterator.hasNext();) {
EStructuralFeature feature = (EStructuralFeature) iterator.next();
if (feature.isMany()) {
InternalEList list = (InternalEList) parent.eGet(feature);
int index = 0;
for (Iterator iter1 = list.basicIterator(); !GUIDs.isEmpty()
&& iter1.hasNext(); index++) {
InternalEObject child = (InternalEObject) iter1.next();
if (child.eIsProxy()) {
String guid = child.eProxyURI().fragment();
if (GUIDs.contains(guid)) {
// this will resolve the object with guid
//
list.get(index);
GUIDs.remove(guid);
}
} else {
resolveProxies(GUIDs, child);
}
}
} else {
InternalEObject child = (InternalEObject) parent.eGet(feature,
false);
if (child != null) {
if (child.eIsProxy()) {
String guid = child.eProxyURI().fragment();
if (GUIDs.contains(guid)) {
// this will resolve the object with guid
//
parent.eGet(feature);
GUIDs.remove(guid);
}
} else {
resolveProxies(GUIDs, child);
}
}
}
}
}
public static URI getFinalURI(Resource resource) {
return resource instanceof MultiFileXMIResourceImpl ? ((MultiFileXMIResourceImpl) resource)
.getFinalURI()
: resource.getURI();
}
/**
* @param impl
* @return
*/
static boolean adjustLocationRequired(MultiFileXMIResourceImpl resource) {
MethodElement e = PersistenceUtil.getMethodElement(resource);
if(e != null && hasOwnFolder(e)) {
URI newURI = createURI(e, resource.getResourceSet());
if(adjustLocationRequired(resource, newURI) && !new File(newURI.toFileString()).exists()) {
return true;
}
}
return false;
}
/**
* Checks if the specified resource is currently synchronized with its data store
*
* @return <li> -1 don't know
* <li> 0 no
* <li> 1 yes
*/
public static int checkSynchronized(Resource resource) {
if(resource instanceof MultiFileXMIResourceImpl) {
return ((MultiFileXMIResourceImpl)resource).checkSynchronized();
}
return -1;
}
/**
* Some team providers changed the timestamp of last file modification by removing second fraction
* even the file was not changed. This method check the current and old time stamps for this.
*
* @param currentTimeStamp
* @param lastTimeStamp
* @return
*/
public static boolean same(long currentTimeStamp, long lastTimeStamp) {
return currentTimeStamp < lastTimeStamp && (currentTimeStamp & 7) == 0 && (lastTimeStamp - currentTimeStamp) < 1000;
}
/**
* Adds an empty resource manager for the given resource if it does not have one.
*
* @param resource
* @return true if a new resource manager is added, false otherwise
*/
static ResourceManager addResourceManager(Resource resource) {
ResourceManager resMgr = getResourceManager(resource);
if (resMgr == null) {
resMgr = ResourcemanagerFactory.eINSTANCE.createResourceManager();
resource.getContents().add(0, resMgr);
return resMgr;
}
return null;
}
static void checkFilePathLength(Collection resources) {
List<String> pathList = new ArrayList<String>();
for (Iterator iter = resources.iterator(); iter.hasNext();) {
Resource resource = (Resource) iter.next();
if(resource instanceof MultiFileXMIResourceImpl && ((MultiFileXMIResourceImpl)resource).hasTempURI()) {
continue;
}
pathList.add(resource.getURI().toFileString());
}
if(!pathList.isEmpty()) {
String[] paths = new String[pathList.size()];
pathList.toArray(paths);
for (int i=0; i < paths.length; i++) {
String path = paths[i];
if (paths[i].length() > 255) {
String msg = NLS.bind(PersistenceResources.filePathNameTooLong_msg, Arrays
.asList(paths));
throw new MultiFileIOException(msg);
}
}
}
}
/**
* Lists all possible configuration files in the specified directory <code>configDir</code> and its sub directories.
*
* @param configDir
* @return
*/
public static Iterator listConfigFiles(File configDir) {
return listLibraryFiles(configDir);
}
public static Iterator<File> listLibraryFiles(File dir) {
return new AbstractTreeIterator<File>(dir, false) {
/**
* Comment for <code>serialVersionUID</code>
*/
private static final long serialVersionUID = 2758436193000640907L;
FileFilter filter = new FileFilter() {
public boolean accept(File pathname) {
return !FileManager.getInstance().isTeamPrivate(pathname.getAbsolutePath()) &&
(pathname.isDirectory()
|| pathname.getName().endsWith(
MultiFileSaveUtil.DEFAULT_FILE_EXTENSION));
}
};
protected Iterator<File> getChildren(Object object) {
File[] files = ((File) object).listFiles(filter);
if (files != null && files.length > 0) {
return Arrays.asList(files).iterator();
}
return Collections.EMPTY_LIST.iterator();
}
};
}
}