| /* |
| * Copyright (c) 2007-2015 Eike Stepper (Berlin, Germany) 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: |
| * Eike Stepper - initial API and implementation |
| * Simon McDuff - maintenance |
| * Christian W. Damus (CEA) - isLoading() support for CDOResource |
| */ |
| package org.eclipse.emf.cdo.eresource.impl; |
| |
| import org.eclipse.emf.cdo.CDOObject; |
| import org.eclipse.emf.cdo.CDOState; |
| import org.eclipse.emf.cdo.common.id.CDOID; |
| import org.eclipse.emf.cdo.common.id.CDOIDUtil; |
| import org.eclipse.emf.cdo.common.revision.CDORevision; |
| import org.eclipse.emf.cdo.eresource.CDOResource; |
| import org.eclipse.emf.cdo.eresource.CDOResourceFolder; |
| import org.eclipse.emf.cdo.eresource.CDOResourceNode; |
| import org.eclipse.emf.cdo.eresource.EresourcePackage; |
| import org.eclipse.emf.cdo.transaction.CDOTransaction; |
| import org.eclipse.emf.cdo.util.CDOModificationTrackingAdapter; |
| import org.eclipse.emf.cdo.util.CDOURIUtil; |
| import org.eclipse.emf.cdo.util.CDOUtil; |
| import org.eclipse.emf.cdo.util.CommitException; |
| import org.eclipse.emf.cdo.view.CDOView; |
| import org.eclipse.emf.cdo.view.CDOViewProvider; |
| |
| import org.eclipse.emf.internal.cdo.view.CDOStateMachine; |
| |
| import org.eclipse.net4j.util.WrappedException; |
| import org.eclipse.net4j.util.transaction.TransactionException; |
| |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.NotificationChain; |
| import org.eclipse.emf.common.notify.impl.NotificationChainImpl; |
| import org.eclipse.emf.common.notify.impl.NotificationImpl; |
| import org.eclipse.emf.common.notify.impl.NotifyingListImpl; |
| import org.eclipse.emf.common.util.AbstractTreeIterator; |
| import org.eclipse.emf.common.util.EList; |
| 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.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.InternalEObject; |
| import org.eclipse.emf.ecore.impl.EStoreEObjectImpl; |
| 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.ExtensibleURIConverterImpl; |
| import org.eclipse.emf.ecore.resource.impl.ResourceImpl; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecore.util.EcoreUtil.ContentTreeIterator; |
| import org.eclipse.emf.ecore.util.EcoreUtil.ProperContentIterator; |
| import org.eclipse.emf.ecore.util.InternalEList; |
| import org.eclipse.emf.ecore.xmi.DOMHandler; |
| import org.eclipse.emf.ecore.xmi.DOMHelper; |
| import org.eclipse.emf.ecore.xmi.XMIResource; |
| import org.eclipse.emf.ecore.xmi.XMLHelper; |
| import org.eclipse.emf.ecore.xmi.impl.XMIHelperImpl; |
| import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl; |
| import org.eclipse.emf.ecore.xml.type.AnyType; |
| import org.eclipse.emf.spi.cdo.FSMUtil; |
| import org.eclipse.emf.spi.cdo.InternalCDOObject; |
| import org.eclipse.emf.spi.cdo.InternalCDOResource; |
| import org.eclipse.emf.spi.cdo.InternalCDOTransaction; |
| import org.eclipse.emf.spi.cdo.InternalCDOView; |
| import org.eclipse.emf.spi.cdo.InternalCDOViewSet; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Node; |
| import org.xml.sax.InputSource; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.Writer; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| /** |
| * <!-- begin-user-doc --> An implementation of the model object '<em><b>CDO Resource</b></em>'. |
| * |
| * @extends InternalCDOResource |
| * @noextend This interface is not intended to be extended by clients. <!-- end-user-doc --> |
| * <p> |
| * The following features are implemented: |
| * <ul> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getResourceSet <em>Resource Set</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getURI <em>URI</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getContents <em>Contents</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#isModified <em>Modified</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#isLoaded <em>Loaded</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#isTrackingModification <em>Tracking Modification</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getErrors <em>Errors</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getWarnings <em>Warnings</em>}</li> |
| * <li>{@link org.eclipse.emf.cdo.eresource.impl.CDOResourceImpl#getTimeStamp <em>Time Stamp</em>}</li> |
| * </ul> |
| * </p> |
| * |
| * @generated |
| */ |
| @SuppressWarnings("unused") |
| public class CDOResourceImpl extends CDOResourceLeafImpl implements CDOResource, InternalCDOResource |
| { |
| private static final EReference CDO_RESOURCE_CONTENTS = EresourcePackage.eINSTANCE.getCDOResource_Contents(); |
| |
| /** |
| * The default URI converter when there is no resource set. |
| * |
| * @ADDED |
| */ |
| private static URIConverter defaultURIConverter; |
| |
| /** |
| * @ADDED |
| */ |
| private boolean root; |
| |
| /** |
| * @ADDED |
| */ |
| private URI initialURI; |
| |
| /** |
| * @ADDED |
| */ |
| private URI uri; |
| |
| /** |
| * TODO Set to true in commit()? |
| * |
| * @ADDED |
| */ |
| private boolean existing; |
| |
| /** |
| * @ADDED |
| */ |
| private boolean loading; |
| |
| /** |
| * @ADDED |
| */ |
| private boolean loaded; |
| |
| /** |
| * @ADDED |
| */ |
| private boolean modified; |
| |
| /** |
| * @ADDED |
| */ |
| private EList<Diagnostic> errors; |
| |
| /** |
| * @ADDED |
| */ |
| private EList<Diagnostic> warnings; |
| |
| /** |
| * @ADDED |
| */ |
| private transient CDOViewProvider viewProvider; |
| |
| /** |
| * A map to retrieve the EObject based on the value of its ID feature. |
| * @see #setIntrinsicIDToEObjectMap(Map) |
| * @ADDED |
| */ |
| private transient Map<String, EObject> intrinsicIDToEObjectMap; |
| |
| /** |
| * @ADDED |
| */ |
| private transient AtomicInteger loadingCounter = new AtomicInteger(); |
| |
| /** |
| * @ADDED |
| * @since 2.0 |
| */ |
| public CDOResourceImpl(URI initialURI) |
| { |
| this.initialURI = initialURI; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| protected CDOResourceImpl() |
| { |
| super(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| protected EClass eStaticClass() |
| { |
| return EresourcePackage.Literals.CDO_RESOURCE; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| * @since 2.0 |
| */ |
| @Override |
| public Resource.Internal eDirectResource() |
| { |
| if (isRoot()) |
| { |
| return this; |
| } |
| |
| return super.eDirectResource(); |
| } |
| |
| @Override |
| public int eDerivedStructuralFeatureID(int baseFeatureID, Class<?> baseClass) |
| { |
| if (baseClass == CDOResource.class) |
| { |
| return baseFeatureID; |
| } |
| |
| if (baseClass == Resource.class) |
| { |
| return baseFeatureID + EresourcePackage.CDO_RESOURCE_NODE_FEATURE_COUNT; |
| } |
| |
| return super.eBaseStructuralFeatureID(baseFeatureID, baseClass); |
| } |
| |
| @Override |
| public int eBaseStructuralFeatureID(int derivedFeatureID, Class<?> baseClass) |
| { |
| if (baseClass == CDOResource.class) |
| { |
| return derivedFeatureID; |
| } |
| |
| if (baseClass == Resource.class) |
| { |
| return derivedFeatureID - EresourcePackage.CDO_RESOURCE_NODE_FEATURE_COUNT; |
| } |
| |
| return super.eBaseStructuralFeatureID(derivedFeatureID, baseClass); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public boolean isRoot() |
| { |
| return root; |
| } |
| |
| /** |
| * @since 3.0 |
| */ |
| public void setRoot(boolean root) |
| { |
| this.root = root; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| public ResourceSet getResourceSet() |
| { |
| return (ResourceSet)eGet(EresourcePackage.Literals.CDO_RESOURCE__RESOURCE_SET, true); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setResourceSet(ResourceSet newResourceSet) |
| { |
| eSet(EresourcePackage.Literals.CDO_RESOURCE__RESOURCE_SET, newResourceSet); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * |
| * @since 2.0 <!-- end-user-doc --> |
| * @generated |
| */ |
| public URI getURIGen() |
| { |
| return (URI)eGet(EresourcePackage.Literals.CDO_RESOURCE__URI, true); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @Override |
| public URI getURI() |
| { |
| if (uri != null) |
| { |
| return uri; |
| } |
| |
| URI uri = doGetURI(); |
| uri = normalizeURI(uri); |
| return uri; |
| } |
| |
| private URI doGetURI() |
| { |
| InternalCDOView view = cdoView(); |
| if (initialURI != null && (cdoID() == null || view == null || view.isClosed())) |
| { |
| return initialURI; |
| } |
| |
| if (viewProvider != null) |
| { |
| URI uri = viewProvider.getResourceURI(view, getPath()); |
| if (uri != null) |
| { |
| return uri; |
| } |
| } |
| |
| return super.getURI(); |
| } |
| |
| private URI normalizeURI(URI uri) |
| { |
| ResourceSet resourceSet = getResourceSet(); |
| if (resourceSet == null) |
| { |
| InternalCDOView view = cdoView(); |
| if (view != null) |
| { |
| resourceSet = view.getResourceSet(); |
| } |
| } |
| |
| if (resourceSet != null) |
| { |
| if (isRoot()) |
| { |
| uri = URI.createURI(uri.toString() + "/"); |
| uri = resourceSet.getURIConverter().normalize(uri); |
| |
| String string = uri.toString(); |
| if (string.endsWith("/")) |
| { |
| uri = URI.createURI(string.substring(0, string.length() - 1)); |
| } |
| } |
| else |
| { |
| uri = resourceSet.getURIConverter().normalize(uri); |
| } |
| } |
| |
| return uri; |
| } |
| |
| private void cacheURI(URI uri) |
| { |
| this.uri = normalizeURI(uri); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * |
| * @since 2.0 <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setURIGen(URI newURI) |
| { |
| eSet(EresourcePackage.Literals.CDO_RESOURCE__URI, newURI); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void setURI(URI newURI) |
| { |
| boolean notificationRequired = eNotificationRequired(); |
| URI oldURI = notificationRequired ? getURI() : null; |
| |
| String newPath = CDOURIUtil.extractResourcePath(newURI); |
| setPath(newPath); |
| |
| if (notificationRequired) |
| { |
| Notification notification = new NotificationImpl(Notification.SET, oldURI, newURI) |
| { |
| @Override |
| public Object getNotifier() |
| { |
| return CDOResourceImpl.this; |
| } |
| |
| @Override |
| public int getFeatureID(Class<?> expectedClass) |
| { |
| return RESOURCE__URI; |
| } |
| }; |
| |
| eNotify(notification); |
| } |
| } |
| |
| /** |
| * @ADDED |
| */ |
| @Override |
| public void setPath(String newPath) |
| { |
| super.setPath(newPath); |
| cacheURI(CDOURIUtil.createResourceURI(cdoView(), newPath)); |
| } |
| |
| /** |
| * @ADDED |
| */ |
| @Override |
| public void setFolder(CDOResourceFolder newFolder) |
| { |
| super.setFolder(newFolder); |
| cacheURI(CDOURIUtil.createResourceURI(cdoView(), getPath())); |
| } |
| |
| /** |
| * @ADDED |
| */ |
| @Override |
| public void setName(String newName) |
| { |
| super.setName(newName); |
| cacheURI(CDOURIUtil.createResourceURI(cdoView(), getPath())); |
| } |
| |
| @Override |
| public Object eGet(int featureID, boolean resolve, boolean coreType) |
| { |
| switch (featureID) |
| { |
| case EresourcePackage.CDO_RESOURCE__URI: |
| return getURI(); |
| |
| default: |
| return super.eGet(featureID, resolve, coreType); |
| } |
| } |
| |
| @Override |
| public void eSet(int featureID, Object newValue) |
| { |
| switch (featureID) |
| { |
| case EresourcePackage.CDO_RESOURCE__URI: |
| setURI((URI)newValue); |
| break; |
| |
| default: |
| super.eSet(featureID, newValue); |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| @SuppressWarnings("unchecked") |
| public EList<EObject> getContents() |
| { |
| return (EList<EObject>)eGet(EresourcePackage.Literals.CDO_RESOURCE__CONTENTS, true); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| @Override |
| public void cdoInternalPostDetach(boolean remote) |
| { |
| super.cdoInternalPostDetach(remote); |
| if (remote) |
| { |
| existing = false; |
| } |
| |
| removeFromResourceSet(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean isModified() |
| { |
| return modified; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void setModified(boolean newModified) |
| { |
| boolean oldModified = modified; |
| modified = newModified; |
| if (oldModified != newModified && eNotificationRequired()) |
| { |
| Notification notification = new NotificationImpl(Notification.SET, oldModified, newModified) |
| { |
| @Override |
| public Object getNotifier() |
| { |
| return CDOResourceImpl.this; |
| } |
| |
| @Override |
| public int getFeatureID(Class<?> expectedClass) |
| { |
| return RESOURCE__IS_MODIFIED; |
| } |
| }; |
| |
| eNotify(notification); |
| } |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public boolean isLoaded() |
| { |
| return loaded; |
| } |
| |
| /** |
| * @see ResourceImpl#setLoaded(boolean) |
| * @ADDED |
| */ |
| private Notification setLoaded(boolean isLoaded) |
| { |
| boolean oldIsLoaded = loaded; |
| loaded = isLoaded; |
| |
| if (eNotificationRequired()) |
| { |
| Notification notification = new NotificationImpl(Notification.SET, oldIsLoaded, isLoaded) |
| { |
| @Override |
| public Object getNotifier() |
| { |
| return CDOResourceImpl.this; |
| } |
| |
| @Override |
| public int getFeatureID(Class<?> expectedClass) |
| { |
| // TODO FIX bug 265136 |
| return Resource.RESOURCE__IS_LOADED; |
| } |
| }; |
| |
| return notification; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| public boolean isTrackingModification() |
| { |
| return (Boolean)eGet(EresourcePackage.Literals.CDO_RESOURCE__TRACKING_MODIFICATION, true); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * |
| * @since 4.0 <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setTrackingModificationGen(boolean newTrackingModification) |
| { |
| eSet(EresourcePackage.Literals.CDO_RESOURCE__TRACKING_MODIFICATION, newTrackingModification); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public void setTrackingModification(boolean newTrackingModification) |
| { |
| if (cdoView().isReadOnly()) |
| { |
| return; |
| } |
| |
| if (newTrackingModification == isTrackingModification()) |
| { |
| return; |
| } |
| |
| EList<Adapter> adapters = eAdapters(); |
| if (newTrackingModification) |
| { |
| adapters.add(new CDOModificationTrackingAdapter(this)); |
| } |
| else |
| { |
| for (Adapter adapter : adapters) |
| { |
| if (adapter instanceof CDOModificationTrackingAdapter) |
| { |
| adapters.remove(adapter); |
| break; |
| } |
| } |
| } |
| |
| setTrackingModificationGen(newTrackingModification); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public EList<Diagnostic> getErrors() |
| { |
| if (errors == null) |
| { |
| errors = new NotifyingListImpl<Diagnostic>() |
| { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| protected boolean isNotificationRequired() |
| { |
| return CDOResourceImpl.this.eNotificationRequired(); |
| } |
| |
| @Override |
| public Object getNotifier() |
| { |
| return CDOResourceImpl.this; |
| } |
| |
| @Override |
| public int getFeatureID() |
| { |
| return EresourcePackage.CDO_RESOURCE__ERRORS; |
| } |
| }; |
| } |
| |
| return errors; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * |
| * @generated NOT |
| */ |
| public EList<Diagnostic> getWarnings() |
| { |
| if (warnings == null) |
| { |
| warnings = new NotifyingListImpl<Diagnostic>() |
| { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| protected boolean isNotificationRequired() |
| { |
| return CDOResourceImpl.this.eNotificationRequired(); |
| } |
| |
| @Override |
| public Object getNotifier() |
| { |
| return CDOResourceImpl.this; |
| } |
| |
| @Override |
| public int getFeatureID() |
| { |
| return EresourcePackage.CDO_RESOURCE__WARNINGS; |
| } |
| }; |
| } |
| |
| return warnings; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| public long getTimeStamp() |
| { |
| return (Long)eGet(EresourcePackage.Literals.CDO_RESOURCE__TIME_STAMP, true); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setTimeStamp(long newTimeStamp) |
| { |
| eSet(EresourcePackage.Literals.CDO_RESOURCE__TIME_STAMP, newTimeStamp); |
| } |
| |
| /** |
| * @ADDED |
| * @see ResourceImpl#getAllContents() |
| */ |
| public TreeIterator<EObject> getAllContents() |
| { |
| return new AbstractTreeIterator<EObject>(this, false) |
| { |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| public Iterator<EObject> getChildren(Object object) |
| { |
| return object == CDOResourceImpl.this ? CDOResourceImpl.this.getContents().iterator() |
| : ((EObject)object).eContents().iterator(); |
| } |
| }; |
| } |
| |
| /** |
| * <b>Note:</b> URI from temporary objects are going to changed when we commit the CDOTransaction. Objects will not be |
| * accessible from their temporary URI once CDOTransaction is committed. |
| * <p> |
| * <b>Note:</b> This resource is not actually used to lookup the resulting object in CDO. Only the CDOView is used for |
| * this lookup! This means that this resource can be used to resolve <em>any</em> fragment with a CDOID of the |
| * associated CDOView. |
| * |
| * @ADDED |
| */ |
| public EObject getEObject(String uriFragment) |
| { |
| try |
| { |
| if (uriFragment != null) |
| { |
| int length = uriFragment.length(); |
| if (length > 0) |
| { |
| if (uriFragment.charAt(0) == '/') |
| { |
| List<String> uriFragmentPath = getURIFragmentPath(uriFragment, length); |
| |
| EObject eObjectByFragment = getEObject(uriFragmentPath); |
| if (eObjectByFragment != null) |
| { |
| return eObjectByFragment; |
| } |
| } |
| else if (uriFragment.charAt(length - 1) == '?') |
| { |
| int index = uriFragment.lastIndexOf('?', length - 2); |
| if (index > 0) |
| { |
| uriFragment = uriFragment.substring(0, index); |
| } |
| } |
| |
| EObject eObjectFromView = getEObjectFromView(uriFragment); |
| if (eObjectFromView != null) |
| { |
| return eObjectFromView; |
| } |
| |
| return getEObjectByID(uriFragment); |
| } |
| } |
| } |
| catch (Exception ex) |
| { |
| // Do nothing |
| // Return null if the object cannot be resolved. |
| } |
| |
| // If it doesn't match to anything we return null like ResourceImpl.getEObject |
| return null; |
| } |
| |
| private EObject getEObjectFromView(String uriFragment) |
| { |
| try |
| { |
| CDOID id = CDOIDUtil.read(uriFragment); |
| InternalCDOView view = cdoView(); |
| if (CDOIDUtil.isNull(id) || view.isObjectNew(id) && !view.isObjectRegistered(id) || !id.isObject()) |
| { |
| return null; |
| } |
| |
| CDOObject object = view.getObject(id, true); |
| return CDOUtil.getEObject(object); |
| } |
| catch (Exception ex) |
| { |
| return null; |
| } |
| } |
| |
| private List<String> getURIFragmentPath(String uriFragment, int length) |
| { |
| List<String> uriFragmentPath = new ArrayList<String>(4); |
| int start = 1; |
| for (int i = 1; i < length; ++i) |
| { |
| if (uriFragment.charAt(i) == '/') |
| { |
| uriFragmentPath.add(start == i ? "" : uriFragment.substring(start, i)); |
| start = i + 1; |
| } |
| } |
| |
| uriFragmentPath.add(uriFragment.substring(start)); |
| return uriFragmentPath; |
| } |
| |
| private EObject getEObject(List<String> uriFragmentPath) |
| { |
| int size = uriFragmentPath.size(); |
| EObject eObject = getEObjectForURIFragmentRootSegment(size == 0 ? "" : uriFragmentPath.get(0)); |
| for (int i = 1; i < size && eObject != null; ++i) |
| { |
| eObject = ((InternalEObject)eObject).eObjectForURIFragmentSegment(uriFragmentPath.get(i)); |
| } |
| |
| return eObject; |
| } |
| |
| /** |
| * @since 4.2 |
| */ |
| private EObject getEObjectForURIFragmentRootSegment(String uriFragmentRootSegment) |
| { |
| int position = 0; |
| if (uriFragmentRootSegment.length() > 0) |
| { |
| try |
| { |
| position = Integer.parseInt(uriFragmentRootSegment); |
| } |
| catch (NumberFormatException exception) |
| { |
| throw new RuntimeException(exception); |
| } |
| } |
| |
| List<EObject> contents = getContents(); |
| if (position < contents.size() && position >= 0) |
| { |
| return contents.get(position); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the map used to cache the EObject that is identified by the {@link #getEObjectByID(String) value} |
| * of its ID feature. |
| * @return the map used to cache the EObject that is identified by the value of its ID feature. |
| * @see #setIntrinsicIDToEObjectMap |
| * @since 4.2 |
| * @ADDED |
| */ |
| public Map<String, EObject> getIntrinsicIDToEObjectMap() |
| { |
| return intrinsicIDToEObjectMap; |
| } |
| |
| /** |
| * Sets the map used to cache the EObject identified by the value of its ID feature. |
| * This cache is only activated if the map is not <code>null</code>. |
| * The map will be lazily loaded by the {@link #getEObjectByID(String) getEObjectByID} method. |
| * It is up to the client to clear the cache when it becomes invalid, |
| * e.g., when the ID of a previously mapped EObject is changed. |
| * @param intrinsicIDToEObjectMap the new map or <code>null</code>. |
| * @see #getIntrinsicIDToEObjectMap |
| * @since 4.2 |
| * @ADDED |
| */ |
| public void setIntrinsicIDToEObjectMap(Map<String, EObject> intrinsicIDToEObjectMap) |
| { |
| this.intrinsicIDToEObjectMap = intrinsicIDToEObjectMap; |
| } |
| |
| /** |
| * Returns the object based on the fragment as an ID. |
| * @since 4.2 |
| * @ADDED |
| */ |
| protected EObject getEObjectByID(String id) |
| { |
| Map<String, EObject> map = getIntrinsicIDToEObjectMap(); |
| if (map != null) |
| { |
| EObject eObject = map.get(id); |
| if (eObject != null) |
| { |
| return eObject; |
| } |
| } |
| |
| EObject result = null; |
| for (TreeIterator<EObject> i = getAllProperContents(getContents()); i.hasNext();) |
| { |
| EObject eObject = i.next(); |
| String eObjectId = EcoreUtil.getID(eObject); |
| if (eObjectId != null) |
| { |
| if (map != null) |
| { |
| map.put(eObjectId, eObject); |
| } |
| |
| if (eObjectId.equals(id)) |
| { |
| result = eObject; |
| if (map == null) |
| { |
| break; |
| } |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| * @since 4.2 |
| * @ADDED |
| */ |
| protected TreeIterator<EObject> getAllProperContents(List<EObject> contents) |
| { |
| return new ContentTreeIterator<EObject>(contents, false) |
| { |
| private static final long serialVersionUID = 1L; |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public Iterator<EObject> getChildren(Object object) |
| { |
| return object == this.object ? ((List<EObject>)object).iterator() |
| : new ProperContentIterator<EObject>((EObject)object); |
| } |
| }; |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public String getURIFragment(EObject object) |
| { |
| // TODO if object == this ??? what we do. Is it wanted ? How we handle them ? |
| InternalCDOObject internalCDOObject = FSMUtil.adapt(object, cdoView()); |
| StringBuilder builder = new StringBuilder(); |
| CDOIDUtil.write(builder, internalCDOObject.cdoID()); |
| return builder.toString(); |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public boolean isLoading() |
| { |
| return loading; |
| } |
| |
| /** |
| * @ADDED |
| * @since 4.2 |
| */ |
| public void cdoInternalLoading(EObject object) |
| { |
| if (loadingCounter.incrementAndGet() == 1) |
| { |
| loading = true; |
| } |
| } |
| |
| /** |
| * @ADDED |
| * @since 4.2 |
| */ |
| public void cdoInternalLoadingDone(EObject object) |
| { |
| if (loadingCounter.decrementAndGet() == 0) |
| { |
| loading = false; |
| } |
| } |
| |
| /** |
| * @ADDED |
| * @since 2.0 |
| */ |
| @Override |
| public void cdoInternalPreLoad() |
| { |
| try |
| { |
| load(null); |
| } |
| catch (IOException ex) |
| { |
| throw WrappedException.wrap(ex); |
| } |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void load(InputStream inputStream, Map<?, ?> options) throws IOException |
| { |
| // final String baseURI = getBaseURIOption(options); |
| // final Map<Resource, CDOResource> resourceMappings = new HashMap<Resource, CDOResource>(); |
| // |
| // class ImportResource extends XMIResourceImpl |
| // { |
| // private CDOResource delegate; |
| // |
| // public ImportResource(CDOResource delegate) |
| // { |
| // super(URI.createURI(baseURI + delegate.getPath())); |
| // this.delegate = delegate; |
| // } |
| // |
| // @Override |
| // public EList<EObject> getContents() |
| // { |
| // return delegate.getContents(); |
| // } |
| // |
| // @Override |
| // public String getURIFragment(EObject eObject) |
| // { |
| // String id = EcoreUtil.getID(eObject); |
| // if (id != null) |
| // { |
| // return id; |
| // } |
| // |
| // InternalEObject internalEObject = (InternalEObject)eObject; |
| // if (getMappedResource(internalEObject.eDirectResource()) == this) |
| // { |
| // return "/" + getURIFragmentRootSegment(eObject); |
| // } |
| // |
| // List<String> uriFragmentPath = new ArrayList<String>(); |
| // boolean isContained = false; |
| // for (InternalEObject container = internalEObject.eInternalContainer(); container != null; container = |
| // internalEObject |
| // .eInternalContainer()) |
| // { |
| // uriFragmentPath.add(container.eURIFragmentSegment(internalEObject.eContainingFeature(), internalEObject)); |
| // internalEObject = container; |
| // if (getMappedResource(container.eDirectResource()) == this) |
| // { |
| // isContained = true; |
| // break; |
| // } |
| // } |
| // |
| // if (!isContained) |
| // { |
| // return "/-1"; |
| // } |
| // |
| // StringBuilder result = new StringBuilder("/"); |
| // result.append(getURIFragmentRootSegment(internalEObject)); |
| // |
| // for (int i = uriFragmentPath.size() - 1; i >= 0; --i) |
| // { |
| // result.append('/'); |
| // result.append(uriFragmentPath.get(i)); |
| // } |
| // |
| // return result.toString(); |
| // } |
| // |
| // @Override |
| // protected XMLHelper createXMLHelper() |
| // { |
| // return new XMIHelperImpl(this) |
| // { |
| // @Override |
| // public String getHREF(EObject obj) |
| // { |
| // InternalEObject o = (InternalEObject)obj; |
| // |
| // URI objectURI = o.eProxyURI(); |
| // if (objectURI == null) |
| // { |
| // Resource otherResource = obj.eResource(); |
| // otherResource = getMappedResource(otherResource); |
| // objectURI = getHREF(otherResource, obj); |
| // } |
| // |
| // objectURI = deresolve(objectURI); |
| // return objectURI.toString(); |
| // } |
| // |
| // @Override |
| // protected URI getHREF(Resource otherResource, EObject obj) |
| // { |
| // String uriFragment = getURIFragment(otherResource, obj); |
| // if (otherResource == ImportResource.this) |
| // { |
| // return URI.createURI(uriFragment); |
| // } |
| // |
| // return otherResource.getURI().appendFragment(uriFragment); |
| // } |
| // }; |
| // } |
| // |
| // private Resource getMappedResource(Resource otherResource) |
| // { |
| // Resource resource = resourceMappings.get(otherResource); |
| // if (resource != null) |
| // { |
| // return resource; |
| // } |
| // |
| // if (otherResource instanceof CDOResource) |
| // { |
| // CDOResource cdoResource = (CDOResource)otherResource; |
| // otherResource = new ImportResource(cdoResource); |
| // resourceMappings.put(cdoResource, otherResource); |
| // } |
| // |
| // return otherResource; |
| // } |
| // } |
| // |
| // XMIResource xmiResource = new ImportResource(this); |
| // resourceMappings.put(this, xmiResource); |
| // xmiResource.save(outputStream, options); |
| |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void load(Map<?, ?> options) throws IOException |
| { |
| if (!isLoaded()) |
| { |
| if (initialURI != null) |
| { |
| String query = initialURI.query(); |
| if (query != null && query.length() != 0) |
| { |
| Map<String, String> parameters = CDOURIUtil.getParameters(query); |
| String value = parameters.get(CDOResource.PREFETCH_PARAMETER); |
| if (value != null) |
| { |
| boolean prefetch = Boolean.parseBoolean(value); |
| if (prefetch) |
| { |
| cdoPrefetch(CDORevision.DEPTH_INFINITE); |
| } |
| } |
| } |
| } |
| |
| Notification notification = setLoaded(true); |
| if (notification != null) |
| { |
| eNotify(notification); |
| } |
| |
| // URIConverter uriConverter = getURIConverter(); |
| // |
| // // If an input stream can't be created, ensure that the resource is still considered loaded after the failure, |
| // // and do all the same processing we'd do if we actually were able to create a valid input stream. |
| // // |
| // InputStream inputStream = null; |
| // |
| // try |
| // { |
| // inputStream = uriConverter.createInputStream(getURI(), options); |
| // } |
| // catch (IOException exception) |
| // { |
| // Notification notification = setLoaded(true); |
| // loading = true; |
| // if (errors != null) |
| // { |
| // errors.clear(); |
| // } |
| // |
| // if (warnings != null) |
| // { |
| // warnings.clear(); |
| // } |
| // |
| // loading = false; |
| // if (notification != null) |
| // { |
| // eNotify(notification); |
| // } |
| // |
| // setModified(false); |
| // throw exception; |
| // } |
| // |
| // try |
| // { |
| // load(inputStream, options); |
| // } |
| // finally |
| // { |
| // inputStream.close(); |
| // // TODO Handle timeStamp |
| // // Long timeStamp = (Long)response.get(URIConverter.RESPONSE_TIME_STAMP_PROPERTY); |
| // // if (timeStamp != null) |
| // // { |
| // // setTimeStamp(timeStamp); |
| // // } |
| // } |
| } |
| } |
| |
| /** |
| * Returns the URI converter. This typically gets the {@link ResourceSet#getURIConverter converter} from the |
| * {@link #getResourceSet containing} resource set, but it calls {@link #getDefaultURIConverter} when there is no |
| * containing resource set. |
| * |
| * @return the URI converter. |
| * @ADDED |
| */ |
| private URIConverter getURIConverter() |
| { |
| return getResourceSet() == null ? getDefaultURIConverter() : getResourceSet().getURIConverter(); |
| } |
| |
| /** |
| * Returns the default URI converter that's used when there is no resource set. |
| * |
| * @return the default URI converter. |
| * @see #getURIConverter |
| * @ADDED |
| */ |
| private static synchronized URIConverter getDefaultURIConverter() |
| { |
| if (defaultURIConverter == null) |
| { |
| defaultURIConverter = new ExtensibleURIConverterImpl(); |
| } |
| |
| return defaultURIConverter; |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void save(Map<?, ?> options) throws IOException |
| { |
| CDOTransaction transaction = getTransaction(options); |
| IProgressMonitor progressMonitor = options != null |
| ? (IProgressMonitor)options.get(CDOResource.OPTION_SAVE_PROGRESS_MONITOR) : null; |
| |
| try |
| { |
| transaction.commit(progressMonitor); |
| } |
| catch (CommitException ex) |
| { |
| throw new TransactionException(ex); |
| } |
| |
| setModified(false); |
| } |
| |
| /** |
| * @ADDED |
| */ |
| private CDOTransaction getTransaction(Map<?, ?> options) |
| { |
| CDOTransaction transaction = options != null |
| ? (CDOTransaction)options.get(CDOResource.OPTION_SAVE_OVERRIDE_TRANSACTION) : null; |
| |
| if (transaction == null) |
| { |
| CDOView view = cdoView(); |
| if (view instanceof CDOTransaction) |
| { |
| transaction = (CDOTransaction)view; |
| } |
| else |
| { |
| throw new IllegalStateException("No transaction available"); |
| } |
| } |
| |
| return transaction; |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void save(OutputStream outputStream, Map<?, ?> options) throws IOException |
| { |
| final String baseURI = getBaseURIOption(options); |
| final Map<CDOResource, Resource> resourceMappings = new HashMap<CDOResource, Resource>(); |
| |
| class ExportResource extends XMIResourceImpl |
| { |
| private CDOResource delegate; |
| |
| public ExportResource(CDOResource delegate) |
| { |
| super(URI.createURI(baseURI + delegate.getPath())); |
| this.delegate = delegate; |
| } |
| |
| @Override |
| public EList<EObject> getContents() |
| { |
| return delegate.getContents(); |
| } |
| |
| // @Override |
| // public String getURIFragment(EObject eObject) |
| // { |
| // String id = EcoreUtil.getID(eObject); |
| // if (id != null) |
| // { |
| // return id; |
| // } |
| // |
| // InternalEObject internalEObject = (InternalEObject)eObject; |
| // if (getMappedResource(internalEObject.eDirectResource()) == this) |
| // { |
| // return "/" + getURIFragmentRootSegment(eObject); |
| // } |
| // |
| // List<String> uriFragmentPath = new ArrayList<String>(); |
| // boolean isContained = false; |
| // for (InternalEObject container = internalEObject.eInternalContainer(); container != null; container = |
| // internalEObject |
| // .eInternalContainer()) |
| // { |
| // uriFragmentPath.add(container.eURIFragmentSegment(internalEObject.eContainingFeature(), internalEObject)); |
| // internalEObject = container; |
| // if (getMappedResource(container.eDirectResource()) == this) |
| // { |
| // isContained = true; |
| // break; |
| // } |
| // } |
| // |
| // if (!isContained) |
| // { |
| // return "/-1"; |
| // } |
| // |
| // StringBuilder result = new StringBuilder("/"); |
| // result.append(getURIFragmentRootSegment(internalEObject)); |
| // |
| // for (int i = uriFragmentPath.size() - 1; i >= 0; --i) |
| // { |
| // result.append('/'); |
| // result.append(uriFragmentPath.get(i)); |
| // } |
| // |
| // return result.toString(); |
| // } |
| |
| @Override |
| protected boolean useUUIDs() |
| { |
| return true; |
| } |
| |
| @Override |
| protected boolean useIDAttributes() |
| { |
| return false; |
| } |
| |
| @Override |
| public String getID(EObject eObject) |
| { |
| CDOObject cdoObject = CDOUtil.getCDOObject(eObject); |
| StringBuilder builder = new StringBuilder(); |
| CDOIDUtil.write(builder, cdoObject.cdoID()); |
| return builder.toString(); |
| } |
| |
| @Override |
| protected XMLHelper createXMLHelper() |
| { |
| return new XMIHelperImpl(this) |
| { |
| @Override |
| public String getHREF(EObject obj) |
| { |
| InternalEObject o = (InternalEObject)obj; |
| |
| URI objectURI = o.eProxyURI(); |
| if (objectURI == null) |
| { |
| Resource otherResource = obj.eResource(); |
| otherResource = getMappedResource(otherResource); |
| objectURI = getHREF(otherResource, obj); |
| } |
| |
| objectURI = deresolve(objectURI); |
| return objectURI.toString(); |
| } |
| |
| @Override |
| protected URI getHREF(Resource otherResource, EObject obj) |
| { |
| String uriFragment = getURIFragment(otherResource, obj); |
| if (otherResource == ExportResource.this) |
| { |
| return URI.createURI(uriFragment); |
| } |
| |
| return otherResource.getURI().appendFragment(uriFragment); |
| } |
| }; |
| } |
| |
| private Resource getMappedResource(Resource otherResource) |
| { |
| Resource resource = resourceMappings.get(otherResource); |
| if (resource != null) |
| { |
| return resource; |
| } |
| |
| if (otherResource instanceof CDOResource) |
| { |
| CDOResource cdoResource = (CDOResource)otherResource; |
| otherResource = new ExportResource(cdoResource); |
| resourceMappings.put(cdoResource, otherResource); |
| } |
| |
| return otherResource; |
| } |
| } |
| |
| XMIResource xmiResource = new ExportResource(this); |
| resourceMappings.put(this, xmiResource); |
| xmiResource.save(outputStream, options); |
| } |
| |
| private String getBaseURIOption(Map<?, ?> options) |
| { |
| if (options != null) |
| { |
| String uri = (String)options.get(OPTION_SAVE_BASE_URI); |
| if (uri != null) |
| { |
| return uri; |
| } |
| } |
| |
| return "cdo://"; |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void unload() |
| { |
| // Do nothing |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void delete(Map<?, ?> options) throws IOException |
| { |
| if (FSMUtil.isTransient(this)) |
| { |
| removeFromResourceSet(); |
| } |
| else |
| { |
| if (isRoot()) |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| if (getFolder() == null) |
| { |
| InternalCDOView view = cdoView(); |
| view.getRootResource().getContents().remove(this); |
| } |
| else |
| { |
| basicSetFolder(null, false); |
| } |
| } |
| } |
| |
| private void removeFromResourceSet() |
| { |
| final ResourceSet resourceSet = getResourceSet(); |
| if (resourceSet != null) |
| { |
| InternalCDOViewSet viewSet = (InternalCDOViewSet)CDOUtil.getViewSet(resourceSet); |
| viewSet.executeWithoutNotificationHandling(new Callable<Boolean>() |
| { |
| public Boolean call() throws Exception |
| { |
| resourceSet.getResources().remove(CDOResourceImpl.this); |
| return true; |
| } |
| }); |
| } |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void attached(EObject object) |
| { |
| if (!FSMUtil.isTransient(this)) |
| { |
| InternalCDOView view = cdoView(); |
| if (view instanceof InternalCDOTransaction) // Bug 376075 |
| { |
| InternalCDOTransaction transaction = (InternalCDOTransaction)view; |
| InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction); |
| |
| if (CDOUtil.isLegacyObject(cdoObject)) |
| { |
| if (FSMUtil.isClean(cdoObject)) |
| { |
| // Bug 352204 |
| return; |
| } |
| |
| int xxx; |
| // EReference containmentFeature = object.eContainmentFeature(); |
| // if (!EMFUtil.isPersistent(containmentFeature)) |
| // { |
| // return; |
| // } |
| } |
| |
| attached(cdoObject, transaction); |
| } |
| } |
| } |
| |
| /** |
| * @ADDED |
| */ |
| private void attached(InternalCDOObject cdoObject, InternalCDOTransaction transaction) |
| { |
| CDOStateMachine.INSTANCE.attach(cdoObject, transaction); |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public void detached(EObject object) |
| { |
| if (!FSMUtil.isTransient(this)) |
| { |
| InternalCDOView view = cdoView(); |
| if (view instanceof InternalCDOTransaction) // Bug 376075 |
| { |
| InternalCDOObject cdoObject = FSMUtil.adapt(object, view); |
| CDOStateMachine.INSTANCE.detach(cdoObject); |
| } |
| } |
| } |
| |
| /** |
| * @ADDED |
| * @see ResourceImpl#basicSetResourceSet(ResourceSet, NotificationChain) |
| */ |
| public NotificationChain basicSetResourceSet(ResourceSet resourceSet, NotificationChain notifications) |
| { |
| final ResourceSet oldResourceSet = getResourceSet(); |
| if (oldResourceSet != null) |
| { |
| final NotificationChain finalNotifications = notifications; |
| |
| InternalCDOViewSet viewSet = (InternalCDOViewSet)CDOUtil.getViewSet(oldResourceSet); |
| notifications = viewSet.executeWithoutNotificationHandling(new Callable<NotificationChain>() |
| { |
| public NotificationChain call() throws Exception |
| { |
| return ((InternalEList<Resource>)oldResourceSet.getResources()).basicRemove(this, finalNotifications); |
| } |
| }); |
| } |
| |
| setResourceSet(resourceSet); |
| |
| if (resourceSet != null) |
| { |
| InternalCDOView view = cdoView(); |
| if (view == null) |
| { |
| URI uri = getURI(); |
| |
| view = (InternalCDOView)CDOUtil.getView(resourceSet, uri); |
| if (view != null) |
| { |
| try |
| { |
| view.attachResource(this); |
| } |
| catch (RuntimeException ex) |
| { |
| resourceSet.getResources().remove(this); |
| setExisting(false); |
| cdoInternalSetState(CDOState.TRANSIENT); |
| throw ex; |
| } |
| catch (Error ex) |
| { |
| resourceSet.getResources().remove(this); |
| setExisting(false); |
| cdoInternalSetState(CDOState.TRANSIENT); |
| throw ex; |
| } |
| |
| viewProvider = view.getProvider(); |
| cacheURI(uri); |
| } |
| } |
| } |
| |
| if (eNotificationRequired()) |
| { |
| if (notifications == null) |
| { |
| notifications = new NotificationChainImpl(2); |
| } |
| |
| notifications.add(new NotificationImpl(Notification.SET, oldResourceSet, resourceSet) |
| { |
| @Override |
| public Object getNotifier() |
| { |
| return CDOResourceImpl.this; |
| } |
| |
| @Override |
| public int getFeatureID(Class<?> expectedClass) |
| { |
| return RESOURCE__RESOURCE_SET; |
| } |
| }); |
| } |
| |
| return notifications; |
| } |
| |
| /** |
| * @ADDED |
| */ |
| public boolean isExisting() |
| { |
| return existing; |
| } |
| |
| /** |
| * @ADDED |
| * @since 3.0 |
| */ |
| protected void setExisting(boolean existing) |
| { |
| this.existing = existing; |
| } |
| |
| /** |
| * @ADDED |
| */ |
| @Override |
| protected EList<?> createList(EStructuralFeature eStructuralFeature) |
| { |
| if (eStructuralFeature == CDO_RESOURCE_CONTENTS) |
| { |
| return new ContentsCDOList(CDO_RESOURCE_CONTENTS); |
| } |
| |
| return super.createList(eStructuralFeature); |
| } |
| |
| @Override |
| public String toString(String string) |
| { |
| if (uri != null) |
| { |
| return string + "(\"" + uri + "\")"; |
| } |
| |
| if (initialURI != null) |
| { |
| return string + "(\"" + initialURI + "\")"; |
| } |
| |
| return super.toString(string); |
| } |
| |
| /* XML STUFF BEGIN */ |
| |
| /** |
| * @since 4.4 |
| */ |
| public String getID(EObject eObject) |
| { |
| return getURIFragment(eObject); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void setID(EObject eObject, String id) |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public boolean useZip() |
| { |
| return false; |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void setUseZip(boolean useZip) |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public String getPublicId() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public String getSystemId() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public DOMHelper getDOMHelper() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public Map<Object, Object> getDefaultLoadOptions() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public Map<Object, Object> getDefaultSaveOptions() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public Map<EObject, AnyType> getEObjectToExtensionMap() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public String getEncoding() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void setEncoding(String encoding) |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public String getXMLVersion() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void setXMLVersion(String version) |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void setDoctypeInfo(String publicId, String systemId) |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void load(Node node, Map<?, ?> options) throws IOException |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void load(InputSource inputSource, Map<?, ?> options) throws IOException |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public void save(Writer writer, Map<?, ?> options) throws IOException |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| public Document save(Document document, Map<?, ?> options, DOMHandler handler) |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| @Deprecated |
| public Map<String, EObject> getIDToEObjectMap() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * @since 4.4 |
| */ |
| @Deprecated |
| public Map<EObject, String> getEObjectToIDMap() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * An implementation of a CDO specific '<em><b>contents</b></em>' list. |
| * |
| * @ADDED |
| * @author Eike Stepper |
| * @since 2.0 |
| */ |
| protected class ContentsCDOList extends EStoreEObjectImpl.BasicEStoreEList<Object> |
| { |
| private static final long serialVersionUID = 1L; |
| |
| public ContentsCDOList(EStructuralFeature eStructuralFeature) |
| { |
| super(CDOResourceImpl.this, eStructuralFeature); |
| } |
| |
| /** |
| * Optimization taken from ResourceImpl.EContentList.contains. |
| * |
| * @since 2.0 |
| */ |
| @Override |
| public boolean contains(Object object) |
| { |
| if (size() <= 4) |
| { |
| return super.contains(object); |
| } |
| |
| return object instanceof InternalEObject && ((InternalEObject)object).eDirectResource() == CDOResourceImpl.this; |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| @Override |
| public NotificationChain inverseAdd(Object object, NotificationChain notifications) |
| { |
| if (FSMUtil.isTransient(CDOResourceImpl.this)) |
| { |
| InternalEObject eObject = (InternalEObject)object; |
| notifications = eObject.eSetResource(CDOResourceImpl.this, notifications); |
| } |
| else |
| { |
| InternalCDOTransaction transaction = cdoView().toTransaction(); |
| InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction); |
| notifications = cdoObject.eSetResource(CDOResourceImpl.this, notifications); |
| |
| if (isRoot()) |
| { |
| // The root resource must not create containment proxies for its CDOResourceNodes. |
| ((CDOResourceNodeImpl)cdoObject).basicSetFolder(null, false); |
| } |
| |
| // Attach here instead of in CDOObjectImpl.eSetResource because EMF does it also here. |
| if (FSMUtil.isTransient(cdoObject)) |
| { |
| attached(cdoObject, transaction); |
| } |
| } |
| |
| return notifications; |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| @Override |
| public NotificationChain inverseRemove(Object object, NotificationChain notifications) |
| { |
| if (FSMUtil.isTransient(CDOResourceImpl.this)) |
| { |
| InternalEObject eObject = (InternalEObject)object; |
| notifications = eObject.eSetResource(null, notifications); |
| } |
| else |
| { |
| InternalEObject eObject = (InternalEObject)object; |
| detached(eObject); |
| notifications = eObject.eSetResource(null, notifications); |
| } |
| |
| return notifications; |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| protected void loaded() |
| { |
| Notification notification = setLoaded(true); |
| if (notification != null) |
| { |
| eNotify(notification); |
| } |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| protected void modified() |
| { |
| if (isTrackingModification()) |
| { |
| setModified(true); |
| } |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| @Override |
| protected boolean useEquals() |
| { |
| return false; |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| @Override |
| protected boolean hasInverse() |
| { |
| return true; |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| @Override |
| protected boolean isUnique() |
| { |
| return true; |
| } |
| |
| /** |
| * @since 4.2 |
| */ |
| @Override |
| protected Object validate(int index, Object object) |
| { |
| if (!root && object instanceof CDOResourceNode) |
| { |
| throw new IllegalArgumentException("CDOResource.contents must not contain other resource nodes"); |
| } |
| |
| return super.validate(index, object); |
| } |
| |
| /** |
| * @since 4.0 |
| */ |
| @Override |
| protected void didAdd(int index, Object newObject) |
| { |
| super.didAdd(index, newObject); |
| |
| if (!isExisting() && !isLoaded()) |
| { |
| loaded(); |
| } |
| } |
| |
| /** |
| * @since 4.0 |
| */ |
| @Override |
| protected void didClear(int size, Object[] oldObjects) |
| { |
| super.didClear(size, oldObjects); |
| |
| if (!isExisting() && !isLoaded()) |
| { |
| loaded(); |
| } |
| } |
| } |
| } // CDOResourceImpl |