Attachment #153394 for bug #283274

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/**
 * @author Eike Stepper
 */
public abstract class CDOSessionImpl extends Container<CDOView> implements
		InternalCDOSession {
	private static final ContextTracer TRACER = new ContextTracer(
			OM.DEBUG_SESSION, CDOSessionImpl.class);

	private static final long NO_TIMEOUT = -1;

	private InternalCDOSessionConfiguration configuration;

	private ExceptionHandler exceptionHandler;

	private CDOSessionProtocol sessionProtocol;

	@ExcludeFromDump
	private IListener sessionProtocolListener = new LifecycleEventAdapter() {
		@Override
		protected void onDeactivated(ILifecycle lifecycle) {
			CDOSessionImpl.this.deactivate();
		}
	};

	private int sessionID;

	private String userID;

	private long lastUpdateTime;

	@ExcludeFromDump
	private Object lastUpdateTimeLock = new Object();

	private CDOSession.Options options = createOptions();

	private CDORepositoryInfo repositoryInfo;

	private CDOFetchRuleManager ruleManager = CDOFetchRuleManager.NOOP;

	private IRWLockManager<CDOSessionImpl, Object> lockmanager = new RWLockManager<CDOSessionImpl, Object>();

	@ExcludeFromDump
	private Set<CDOSessionImpl> singletonCollection = Collections
			.singleton(this);

	private CDOAuthenticator authenticator;

	private InternalCDORemoteSessionManager remoteSessionManager;

	private Set<InternalCDOView> views = new HashSet<InternalCDOView>();

	/**
	 * Fixes a threading problem between a committing thread and the Net4j
	 * thread that delivers incoming commit notifications. TODO This is a
	 * workaround, see Bug 294700
	 */
	private Object commitLock = new Object();

	@ExcludeFromDump
	private QueueRunner invalidationRunner;

	@ExcludeFromDump
	private Object invalidationRunnerLock = new Object();

	@ExcludeFromDump
	private static ThreadLocal<Boolean> invalidationRunnerActive = new InheritableThreadLocal<Boolean>();

	@ExcludeFromDump
	private int lastViewID;

	private Set<InternalCDOView> registeredLockListeners = new HashSet<InternalCDOView>();

	private boolean hasRegisteredListeners;

	public CDOSessionImpl(InternalCDOSessionConfiguration configuration) {
		this.configuration = configuration;
	}

	public InternalCDOSessionConfiguration getConfiguration() {
		return configuration;
	}

	public CDORepositoryInfo getRepositoryInfo() {
		return repositoryInfo;
	}

	public void setRepositoryInfo(CDORepositoryInfo repositoryInfo) {
		this.repositoryInfo = repositoryInfo;
	}

	public int getSessionID() {
		return sessionID;
	}

	public void setSessionID(int sessionID) {
		this.sessionID = sessionID;
	}

	public String getUserID() {
		return userID;
	}

	public void setUserID(String userID) {
		this.userID = userID;
	}

	public ExceptionHandler getExceptionHandler() {
		return exceptionHandler;
	}

	public void setExceptionHandler(ExceptionHandler exceptionHandler) {
		checkInactive();
		this.exceptionHandler = exceptionHandler;
	}

	/**
	 * @since 2.0
	 */
	public CDOSession.Options options() {
		return options;
	}

	/**
	 * @since 2.0
	 */
	protected CDOSession.Options createOptions() {
		return new OptionsImpl();
	}

	public CDOSessionProtocol getSessionProtocol() {
		return sessionProtocol;
	}

	public void setSessionProtocol(CDOSessionProtocol sessionProtocol) {
		this.sessionProtocol = sessionProtocol;
	}

	public void close() {
		LifecycleUtil.deactivate(this, OMLogger.Level.DEBUG);
	}

	/**
	 * @since 2.0
	 */
	public boolean isClosed() {
		return !isActive();
	}

	public Object processPackage(Object value) {
		CDOFactoryImpl.prepareDynamicEPackage(value);
		return value;
	}

	public EPackage[] loadPackages(CDOPackageUnit packageUnit) {
		if (packageUnit.getOriginalType().isGenerated()) {
			if (!options().isGeneratedPackageEmulationEnabled()) {
				throw new CDOException(MessageFormat.format(Messages
						.getString("CDOSessionImpl.0"), packageUnit));
			}
		}

		return getSessionProtocol().loadPackages(packageUnit);
	}

	public void acquireAtomicRequestLock(Object key) {
		try {
			lockmanager.lock(LockType.WRITE, key, this, RWLockManager.WAIT);
		} catch (InterruptedException ex) {
			throw WrappedException.wrap(ex);
		}
	}

	public void releaseAtomicRequestLock(Object key) {
		lockmanager.unlock(LockType.WRITE, key, singletonCollection);
	}

	/**
	 * @since 3.0
	 */
	public CDOFetchRuleManager getFetchRuleManager() {
		return ruleManager;
	}

	/**
	 * @since 3.0
	 */
	public void setFetchRuleManager(CDOFetchRuleManager fetchRuleManager) {
		ruleManager = fetchRuleManager;
	}

	public CDOAuthenticator getAuthenticator() {
		return authenticator;
	}

	public void setAuthenticator(CDOAuthenticator authenticator) {
		this.authenticator = authenticator;
	}

	public InternalCDORemoteSessionManager getRemoteSessionManager() {
		return remoteSessionManager;
	}

	public void setRemoteSessionManager(
			InternalCDORemoteSessionManager remoteSessionManager) {
		this.remoteSessionManager = remoteSessionManager;
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOTransaction openTransaction(ResourceSet resourceSet) {
		checkActive();
		InternalCDOTransaction transaction = createTransaction();
		initView(transaction, resourceSet);
		return transaction;
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOTransaction openTransaction() {
		return openTransaction(createResourceSet());
	}

	/**
	 * @since 2.0
	 */
	protected InternalCDOTransaction createTransaction() {
		return new CDOTransactionImpl();
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOView openView(ResourceSet resourceSet) {
		checkActive();
		InternalCDOView view = createView();
		initView(view, resourceSet);
		return view;
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOView openView() {
		return openView(createResourceSet());
	}

	/**
	 * @since 2.0
	 */
	protected InternalCDOView createView() {
		return new CDOViewImpl();
	}

	public CDOAuditImpl openAudit(ResourceSet resourceSet, long timeStamp) {
		checkActive();
		CDOAuditImpl audit = createAudit(timeStamp);
		initView(audit, resourceSet);
		return audit;
	}

	public CDOAuditImpl openAudit(long timeStamp) {
		return openAudit(createResourceSet(), timeStamp);
	}

	/**
	 * @since 2.0
	 */
	protected CDOAuditImpl createAudit(long timeStamp) {
		return new CDOAuditImpl(timeStamp);
	}

	/**
	 * @since 2.0
	 */
	public void viewDetached(InternalCDOView view) {
		// Detach viewset from the view
		view.getViewSet().remove(view);
		synchronized (views) {
			if (!views.remove(view)) {
				return;
			}
		}

		if (isActive()) {
			try {
				LifecycleUtil.deactivate(view);
			} catch (Exception ex) {
				throw WrappedException.wrap(ex);
			}
		}

		fireElementRemovedEvent(view);
	}

	public CDOView getView(int viewID) {
		checkActive();
		for (InternalCDOView view : getViews()) {
			if (view.getViewID() == viewID) {
				return view;
			}
		}

		return null;
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOView[] getViews() {
		checkActive();
		synchronized (views) {
			return views.toArray(new InternalCDOView[views.size()]);
		}
	}

	public CDOView[] getElements() {
		return getViews();
	}

	@Override
	public boolean isEmpty() {
		checkActive();
		return views.isEmpty();
	}

	/**
	 * @since 2.0
	 */
	public Collection<CDOTimeStampContext> refresh() {
		// If passive update is turned on we don`t need to refresh.
		// We do not throw an exception since the client could turn
		// that feature on or off without affecting their code.
		checkActive();
		if (!options().isPassiveUpdateEnabled()) {
			Map<CDOID, CDOIDAndVersion> allRevisions = getAllCDOIDAndVersion();

			try {
				if (!allRevisions.isEmpty()) {
					int initialChunkSize = options()
							.getCollectionLoadingPolicy().getInitialChunkSize();
					return getSessionProtocol().syncRevisions(allRevisions,
							initialChunkSize);
				}
			} catch (Exception ex) {
				throw WrappedException.wrap(ex);
			}
		}

		return Collections.emptyList();
	}

	public long getLastUpdateTime() {
		synchronized (lastUpdateTimeLock) {
			return lastUpdateTime;
		}
	}

	public void setLastUpdateTime(long lastUpdateTime) {
		synchronized (lastUpdateTimeLock) {
			this.lastUpdateTime = lastUpdateTime;
			lastUpdateTimeLock.notifyAll();
		}
	}

	public void waitForUpdate(long updateTime) {
		waitForUpdate(updateTime, NO_TIMEOUT);
	}

	public boolean waitForUpdate(long updateTime, long timeoutMillis) {
		long end = timeoutMillis == NO_TIMEOUT ? Long.MAX_VALUE : System
				.currentTimeMillis()
				+ timeoutMillis;
		for (;;) {
			synchronized (lastUpdateTimeLock) {
				if (lastUpdateTime >= updateTime) {
					return true;
				}

				long now = System.currentTimeMillis();
				if (now >= end) {
					return false;
				}

				try {
					lastUpdateTimeLock.wait(end - now);
				} catch (InterruptedException ex) {
					throw WrappedException.wrap(ex);
				}
			}
		}
	}

	/**
	 * @since 3.0
	 */
	public Object resolveElementProxy(CDORevision revision,
			EStructuralFeature feature, int accessIndex, int serverIndex) {
		CDOCollectionLoadingPolicy policy = options()
				.getCollectionLoadingPolicy();
		return policy.resolveProxy(this, revision, feature, accessIndex,
				serverIndex);
	}

	/**
	 * @since 2.0
	 */
	public void handleSyncResponse(long timestamp,
			Collection<CDOPackageUnit> newPackageUnits,
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects) {
		handleCommitNotification(timestamp, newPackageUnits, dirtyOIDs,
				detachedObjects, null, null, true, false);
	}

	/**
	 * @since 2.0
	 */
	public void handleCommitNotification(final long timeStamp,
			final Collection<CDOPackageUnit> newPackageUnits,
			Set<CDOIDAndVersion> dirtyOIDs,
			final Collection<CDOID> detachedObjects,
			final Collection<CDORevisionDelta> deltas,
			InternalCDOView excludedView) {
		handleCommitNotification(timeStamp, newPackageUnits, dirtyOIDs,
				detachedObjects, deltas, excludedView, options()
						.isPassiveUpdateEnabled(), true);
	}

	private void handleCommitNotification(final long timeStamp,
			final Collection<CDOPackageUnit> newPackageUnits,
			Set<CDOIDAndVersion> dirtyOIDs,
			final Collection<CDOID> detachedObjects,
			final Collection<CDORevisionDelta> deltas,
			InternalCDOView excludedView, final boolean passiveUpdate,
			final boolean async) {
		try {
			synchronized (commitLock) {
				if (passiveUpdate) {
					reviseRevisions(timeStamp, dirtyOIDs, detachedObjects,
							excludedView);
				}

				final Set<CDOIDAndVersion> finalDirtyOIDs = Collections
						.unmodifiableSet(dirtyOIDs);
				final Collection<CDOID> finalDetachedObjects = Collections
						.unmodifiableCollection(detachedObjects);
				final boolean skipChangeSubscription = (deltas == null || deltas
						.size() <= 0)
						&& (detachedObjects == null || detachedObjects.size() <= 0);

				for (final InternalCDOView view : getViews()) {
					if (view != excludedView) {
						final Runnable runnable = new Runnable() {
							public void run() {
								try {
									Set<CDOObject> conflicts = null;
									if (passiveUpdate) {
										conflicts = view.handleInvalidation(
												timeStamp, finalDirtyOIDs,
												finalDetachedObjects);
									}

									if (!skipChangeSubscription) {
										view.handleChangeSubscription(deltas,
												detachedObjects);
									}

									if (conflicts != null) {
										((InternalCDOTransaction) view)
												.handleConflicts(conflicts);
									}

									view.fireAdaptersNotifiedEvent(timeStamp);
								} catch (RuntimeException ex) {
									if (!async) {
										throw ex;
									}

									if (view.isActive()) {
										OM.LOG.error(ex);
									} else {
										OM.LOG.info(Messages
												.getString("CDOSessionImpl.1"));
									}
								}
							}
						};

						if (async) {
							QueueRunner runner = getInvalidationRunner();
							runner.addWork(new Runnable() {
								public void run() {
									try {
										invalidationRunnerActive.set(true);
										runnable.run();
									} finally {
										invalidationRunnerActive.set(false);
									}
								}
							});
						} else {
							runnable.run();
						}
					}
				}
			}
		} catch (RuntimeException ex) {
			if (!async) {
				throw ex;
			}

			if (isActive()) {
				OM.LOG.error(ex);
			} else {
				OM.LOG.info(Messages.getString("CDOSessionImpl.2"));
			}
		}

		setLastUpdateTime(timeStamp);
		fireInvalidationEvent(timeStamp, newPackageUnits, dirtyOIDs,
				detachedObjects, excludedView);
	}

	public void reviseRevisions(final long timeStamp,
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects,
			InternalCDOView excludedView) {
		InternalCDORevisionManager revisionManager = getRevisionManager();
		if (excludedView == null || timeStamp == CDORevision.UNSPECIFIED_DATE) {
			for (CDOIDAndVersion dirtyOID : dirtyOIDs) {
				CDOID id = dirtyOID.getID();
				int version = dirtyOID.getVersion();
				revisionManager.reviseVersion(id, version, timeStamp);
			}
		}

		for (CDOID id : detachedObjects) {
			revisionManager.reviseLatest(id);
		}
	}

	public Object getCommitLock() {
		return commitLock;
	}

	private QueueRunner getInvalidationRunner() {
		synchronized (invalidationRunnerLock) {
			if (invalidationRunner == null) {
				invalidationRunner = createInvalidationRunner();
				invalidationRunner.activate();
			}
		}

		return invalidationRunner;
	}

	protected QueueRunner createInvalidationRunner() {
		return new QueueRunner() {
			@Override
			protected String getThreadName() {
				return "InvalidationRunner";
			}

			@Override
			public String toString() {
				return getThreadName();
			}
		};
	}

	/**
	 * @param packageUnits
	 * @since 2.0
	 */
	public void fireInvalidationEvent(long timeStamp,
			Collection<CDOPackageUnit> packageUnits,
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects,
			InternalCDOView excludedView) {
		fireEvent(new InvalidationEvent(excludedView, timeStamp, packageUnits,
				dirtyOIDs, detachedObjects));
	}

	@Override
	public String toString() {
		String name = repositoryInfo == null ? "?" : repositoryInfo.getName();
		return MessageFormat.format("CDOSession[{0}, {1}]", name, sessionID);
	}

	protected ResourceSet createResourceSet() {
		return new ResourceSetImpl();
	}

	/**
	 * @since 2.0
	 */
	protected void initView(InternalCDOView view, ResourceSet resourceSet) {
		if (TRACER.isEnabled()) {
			TRACER.format("Initializing new {0} view", view.getViewType());
		}

		InternalCDOViewSet viewSet = SessionUtil
				.prepareResourceSet(resourceSet);
		synchronized (views) {
			view.setSession(this);
			view.setViewID(++lastViewID);
			views.add(view);
		}

		// Link ViewSet with View
		view.setViewSet(viewSet);
		viewSet.add(view);

		try {
			view.activate();
			fireElementAddedEvent(view);
		} catch (RuntimeException ex) {
			synchronized (views) {
				views.remove(view);
			}

			viewSet.remove(view);
			throw ex;
		}
	}

	@Override
	protected void doActivate() throws Exception {
		super.doActivate();
		getConfiguration().activateSession(this);
		checkState(sessionProtocol, "sessionProtocol");
		checkState(remoteSessionManager, "remoteSessionManager");
		if (exceptionHandler != null) {
			sessionProtocol = new DelegatingSessionProtocol(sessionProtocol);
		}

		EventUtil.addListener(sessionProtocol, sessionProtocolListener);
	}

	@Override
	protected void doDeactivate() throws Exception {
		for (InternalCDOView view : views.toArray(new InternalCDOView[views
				.size()])) {
			try {
				view.close();
			} catch (RuntimeException ignore) {
			}
		}

		views.clear();

		if (invalidationRunner != null) {
			LifecycleUtil.deactivate(invalidationRunner, OMLogger.Level.WARN);
			invalidationRunner = null;
		}

		EventUtil.removeListener(sessionProtocol, sessionProtocolListener);
		getConfiguration().deactivateSession(this);
		super.doDeactivate();
	}

	private Map<CDOID, CDOIDAndVersion> getAllCDOIDAndVersion() {
		Map<CDOID, CDOIDAndVersion> uniqueObjects = new HashMap<CDOID, CDOIDAndVersion>();
		for (InternalCDOView view : getViews()) {
			view.getCDOIDAndVersion(uniqueObjects, Arrays.asList(view
					.getObjectsArray()));
		}

		// Need to add Revision from revisionManager since we do not have all
		// objects in view.
		for (CDORevision revision : getRevisionManager().getCache()
				.getRevisions()) {
			if (!uniqueObjects.containsKey(revision.getID())) {
				uniqueObjects.put(revision.getID(), CDOIDUtil
						.createIDAndVersion(revision.getID(), revision
								.getVersion()));
			}
		}

		return uniqueObjects;
	}

	public static boolean isInvalidationRunnerActive() {
		return invalidationRunnerActive.get();
	}

	/**
	 * @author Eike Stepper
	 * @since 2.0
	 */
	protected class OptionsImpl extends Notifier implements Options {
		private boolean generatedPackageEmulationEnabled = false;

		private boolean passiveUpdateEnabled = true;

		private CDOCollectionLoadingPolicy collectionLoadingPolicy;

		public OptionsImpl() {
			// TODO Remove preferences from core
			int value = OM.PREF_COLLECTION_LOADING_CHUNK_SIZE.getValue();
			collectionLoadingPolicy = CDOUtil.createCollectionLoadingPolicy(
					value, value);
		}

		public IOptionsContainer getContainer() {
			return CDOSessionImpl.this;
		}

		public boolean isGeneratedPackageEmulationEnabled() {
			return generatedPackageEmulationEnabled;
		}

		public synchronized void setGeneratedPackageEmulationEnabled(
				boolean generatedPackageEmulationEnabled) {
			this.generatedPackageEmulationEnabled = generatedPackageEmulationEnabled;
			if (this.generatedPackageEmulationEnabled != generatedPackageEmulationEnabled) {
				this.generatedPackageEmulationEnabled = generatedPackageEmulationEnabled;
				// TODO Check inconsistent state if switching off?

				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new GeneratedPackageEmulationEventImpl(),
							listeners);
				}
			}
		}

		public boolean isPassiveUpdateEnabled() {
			return passiveUpdateEnabled;
		}

		public synchronized void setPassiveUpdateEnabled(
				boolean passiveUpdateEnabled) {
			if (this.passiveUpdateEnabled != passiveUpdateEnabled) {
				this.passiveUpdateEnabled = passiveUpdateEnabled;

				// Need to refresh if we change state
				Map<CDOID, CDOIDAndVersion> allRevisions = getAllCDOIDAndVersion();
				if (!allRevisions.isEmpty()) {
					int initialChunkSize = collectionLoadingPolicy
							.getInitialChunkSize();
					getSessionProtocol().setPassiveUpdate(allRevisions,
							initialChunkSize, passiveUpdateEnabled);
				}

				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new PassiveUpdateEventImpl(), listeners);
				}
			}
		}

		public CDOCollectionLoadingPolicy getCollectionLoadingPolicy() {
			return collectionLoadingPolicy;
		}

		public synchronized void setCollectionLoadingPolicy(
				CDOCollectionLoadingPolicy policy) {
			if (policy == null) {
				policy = CDOCollectionLoadingPolicy.DEFAULT;
			}

			if (collectionLoadingPolicy != policy) {
				collectionLoadingPolicy = policy;
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new CollectionLoadingPolicyEventImpl(), listeners);
				}
			}
		}

		/**
		 * @author Eike Stepper
		 */
		private final class GeneratedPackageEmulationEventImpl extends
				OptionsEvent implements GeneratedPackageEmulationEvent {
			private static final long serialVersionUID = 1L;

			public GeneratedPackageEmulationEventImpl() {
				super(OptionsImpl.this);
			}
		}

		/**
		 * @author Eike Stepper
		 */
		private final class PassiveUpdateEventImpl extends OptionsEvent
				implements PassiveUpdateEvent {
			private static final long serialVersionUID = 1L;

			public PassiveUpdateEventImpl() {
				super(OptionsImpl.this);
			}
		}

		/**
		 * @author Eike Stepper
		 */
		private final class CollectionLoadingPolicyEventImpl extends
				OptionsEvent implements CollectionLoadingPolicyEvent {
			private static final long serialVersionUID = 1L;

			public CollectionLoadingPolicyEventImpl() {
				super(OptionsImpl.this);
			}
		}
	}

	/**
	 * @author Eike Stepper
	 */
	private final class InvalidationEvent extends Event implements
			CDOSessionInvalidationEvent {
		private static final long serialVersionUID = 1L;

		private InternalCDOView view;

		private long timeStamp;

		private Set<CDOIDAndVersion> dirtyOIDs;

		private Collection<CDOID> detachedObjects;

		private Collection<CDOPackageUnit> newPackageUnits;

		public InvalidationEvent(InternalCDOView view, long timeStamp,
				Collection<CDOPackageUnit> packageUnits,
				Set<CDOIDAndVersion> dirtyOIDs,
				Collection<CDOID> detachedObjects) {
			super(CDOSessionImpl.this);
			this.view = view;
			this.timeStamp = timeStamp;
			newPackageUnits = packageUnits;
			this.dirtyOIDs = dirtyOIDs;
			this.detachedObjects = detachedObjects;
		}

		@Override
		public CDOSession getSource() {
			return (CDOSession) super.getSource();
		}

		public InternalCDOView getView() {
			return view;
		}

		public boolean isRemote() {
			return view == null;
		}

		public long getTimeStamp() {
			return timeStamp;
		}

		public Set<CDOIDAndVersion> getDirtyOIDs() {
			return dirtyOIDs;
		}

		public Collection<CDOID> getDetachedObjects() {
			return detachedObjects;
		}

		public Collection<CDOPackageUnit> getNewPackageUnits() {
			return newPackageUnits;
		}

		@Override
		public String toString() {
			return "CDOSessionInvalidationEvent: " + dirtyOIDs;
		}
	}

	/**
	 * @author Eike Stepper
	 */
	public class DelegatingSessionProtocol extends Lifecycle implements
			CDOSessionProtocol {
		private CDOSessionProtocol delegate;

		@ExcludeFromDump
		private IListener delegateListener = new LifecycleEventAdapter() {
			@Override
			protected void onDeactivated(ILifecycle lifecycle) {
				DelegatingSessionProtocol.this.deactivate();
			}
		};

		public DelegatingSessionProtocol(CDOSessionProtocol delegate) {
			this.delegate = delegate;
			activate();
		}

		public CDOSessionProtocol getDelegate() {
			return delegate;
		}

		public CDOSession getSession() {
			return (CDOSession) delegate.getSession();
		}

		public boolean cancelQuery(int queryId) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.cancelQuery(queryId);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public void changeSubscription(int viewId, List<CDOID> cdoIDs,
				boolean subscribeMode, boolean clear) {
			int attempt = 0;
			for (;;) {
				try {
					delegate.changeSubscription(viewId, cdoIDs, subscribeMode,
							clear);
					return;
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public void closeView(int viewId) {
			int attempt = 0;
			for (;;) {
				try {
					delegate.closeView(viewId);
					return;
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public CommitTransactionResult commitTransaction(
				InternalCDOCommitContext commitContext, OMMonitor monitor) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.commitTransaction(commitContext, monitor);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public CommitTransactionResult commitTransactionCancel(
				InternalCDOXACommitContext xaContext, OMMonitor monitor) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.commitTransactionCancel(xaContext, monitor);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public CommitTransactionResult commitTransactionPhase1(
				InternalCDOXACommitContext xaContext, OMMonitor monitor) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.commitTransactionPhase1(xaContext, monitor);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public CommitTransactionResult commitTransactionPhase2(
				InternalCDOXACommitContext xaContext, OMMonitor monitor) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.commitTransactionPhase2(xaContext, monitor);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public CommitTransactionResult commitTransactionPhase3(
				InternalCDOXACommitContext xaContext, OMMonitor monitor) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.commitTransactionPhase3(xaContext, monitor);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public RepositoryTimeResult getRepositoryTime() {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.getRepositoryTime();
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public boolean isObjectLocked(CDOView view, CDOObject object,
				LockType lockType, boolean byOthers) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.isObjectLocked(view, object, lockType,
							byOthers);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public EPackage[] loadPackages(CDOPackageUnit packageUnit) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.loadPackages(packageUnit);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public Object loadChunk(InternalCDORevision revision,
				EStructuralFeature feature, int accessIndex, int fetchIndex,
				int fromIndex, int toIndex) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.loadChunk(revision, feature, accessIndex,
							fetchIndex, fromIndex, toIndex);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public InternalCDORevision loadRevision(CDOID id, int referenceChunk,
				int prefetchDepth) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.loadRevision(id, referenceChunk,
							prefetchDepth);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public InternalCDORevision loadRevisionByTime(CDOID id,
				int referenceChunk, int prefetchDepth, long timeStamp) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.loadRevisionByTime(id, referenceChunk,
							prefetchDepth, timeStamp);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public InternalCDORevision loadRevisionByVersion(CDOID id,
				int referenceChunk, int prefetchDepth, int version) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.loadRevisionByVersion(id, referenceChunk,
							prefetchDepth, version);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public List<InternalCDORevision> loadRevisions(Collection<CDOID> ids,
				int referenceChunk, int prefetchDepth) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.loadRevisions(ids, referenceChunk,
							prefetchDepth);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public List<InternalCDORevision> loadRevisionsByTime(
				Collection<CDOID> ids, int referenceChunk, int prefetchDepth,
				long timeStamp) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.loadRevisionsByTime(ids, referenceChunk,
							prefetchDepth, timeStamp);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public InternalCDORevision verifyRevision(InternalCDORevision revision,
				int referenceChunk) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.verifyRevision(revision, referenceChunk);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public void lockObjects(CDOView view,
				Map<CDOID, CDOIDAndVersion> objects, long timeout,
				LockType lockType) throws InterruptedException {
			int attempt = 0;
			for (;;) {
				try {
					delegate.lockObjects(view, objects, timeout, lockType);
					return;
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public void openView(int viewId, CDOCommonView.Type viewType,
				long timeStamp) {
			int attempt = 0;
			for (;;) {
				try {
					delegate.openView(viewId, viewType, timeStamp);
					return;
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public void query(int viewID, AbstractQueryIterator<?> queryResult) {
			int attempt = 0;
			for (;;) {
				try {
					delegate.query(viewID, queryResult);
					return;
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public boolean[] setAudit(int viewId, long timeStamp,
				List<InternalCDOObject> invalidObjects) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.setAudit(viewId, timeStamp, invalidObjects);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public void setPassiveUpdate(Map<CDOID, CDOIDAndVersion> idAndVersions,
				int initialChunkSize, boolean passiveUpdateEnabled) {
			int attempt = 0;
			for (;;) {
				try {
					delegate.setPassiveUpdate(idAndVersions, initialChunkSize,
							passiveUpdateEnabled);
					return;
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public Collection<CDOTimeStampContext> syncRevisions(
				Map<CDOID, CDOIDAndVersion> allRevisions, int initialChunkSize) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.syncRevisions(allRevisions,
							initialChunkSize);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public void unlockObjects(CDOView view,
				Collection<? extends CDOObject> objects, LockType lockType) {
			int attempt = 0;
			for (;;) {
				try {
					delegate.unlockObjects(view, objects, lockType);
					return;
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public List<CDORemoteSession> getRemoteSessions(
				InternalCDORemoteSessionManager manager, boolean subscribe) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.getRemoteSessions(manager, subscribe);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public Set<Integer> sendRemoteMessage(CDORemoteSessionMessage message,
				List<CDORemoteSession> recipients) {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.sendRemoteMessage(message, recipients);
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		public boolean unsubscribeRemoteSessions() {
			int attempt = 0;
			for (;;) {
				try {
					return delegate.unsubscribeRemoteSessions();
				} catch (Exception ex) {
					handleException(++attempt, ex);
				}
			}
		}

		@Override
		protected void doActivate() throws Exception {
			super.doActivate();
			EventUtil.addListener(delegate, delegateListener);
		}

		@Override
		protected void doDeactivate() throws Exception {
			EventUtil.removeListener(delegate, delegateListener);
			LifecycleUtil.deactivate(delegate);
			delegate = null;
			super.doDeactivate();
		}

		private void handleException(int attempt, Exception exception) {
			try {
				getExceptionHandler().handleException(CDOSessionImpl.this,
						attempt, exception);
			} catch (Exception ex) {
				throw WrappedException.wrap(ex);
			}
		}

		/**
		 * @author Juan Pedro Silva
		 */
		public void subscribeRemoteLocks() {
			getDelegate().subscribeRemoteLocks();
		}

		/**
		 * @author Juan Pedro Silva
		 */
		public void unsubscribeRemoteLocks() {
			getDelegate().unsubscribeRemoteLocks();
		}
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void registerLockListeners(InternalCDOView cdoView) {
		if (!hasRegisteredListeners) {
			hasRegisteredListeners = true;
			getSessionProtocol().subscribeRemoteLocks();
		}
		registeredLockListeners.add(cdoView);
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void unregisterLockListeners(InternalCDOView cdoView) {
		registeredLockListeners.remove(cdoView);
		if (registeredLockListeners.isEmpty()) {
			hasRegisteredListeners = false;
			getSessionProtocol().unsubscribeRemoteLocks();
		}
	}
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public void lockObjects(CDOView view, Map<CDOID, CDOIDAndVersion> objects, long timeout, LockType lockType)
        throws InterruptedException
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          delegate.lockObjects(view, objects, timeout, lockType);
          return;
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public void openView(int viewId, CDOCommonView.Type viewType, long timeStamp)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          delegate.openView(viewId, viewType, timeStamp);
          return;
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public void query(int viewID, AbstractQueryIterator<?> queryResult)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          delegate.query(viewID, queryResult);
          return;
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public boolean[] setAudit(int viewId, long timeStamp, List<InternalCDOObject> invalidObjects)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          return delegate.setAudit(viewId, timeStamp, invalidObjects);
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public void setPassiveUpdate(Map<CDOID, CDOIDAndVersion> idAndVersions, int initialChunkSize,
        boolean passiveUpdateEnabled)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          delegate.setPassiveUpdate(idAndVersions, initialChunkSize, passiveUpdateEnabled);
          return;
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public Collection<CDOTimeStampContext> syncRevisions(Map<CDOID, CDOIDAndVersion> allRevisions, int initialChunkSize)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          return delegate.syncRevisions(allRevisions, initialChunkSize);
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public void unlockObjects(CDOView view, Collection<? extends CDOObject> objects, LockType lockType)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          delegate.unlockObjects(view, objects, lockType);
          return;
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public List<CDORemoteSession> getRemoteSessions(InternalCDORemoteSessionManager manager, boolean subscribe)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          return delegate.getRemoteSessions(manager, subscribe);
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public Set<Integer> sendRemoteMessage(CDORemoteSessionMessage message, List<CDORemoteSession> recipients)
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          return delegate.sendRemoteMessage(message, recipients);
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    public boolean unsubscribeRemoteSessions()
    {
      int attempt = 0;
      for (;;)
      {
        try
        {
          return delegate.unsubscribeRemoteSessions();
        }
        catch (Exception ex)
        {
          handleException(++attempt, ex);
        }
      }
    }

    @Override
    protected void doActivate() throws Exception
    {
      super.doActivate();
      EventUtil.addListener(delegate, delegateListener);
    }

    @Override
    protected void doDeactivate() throws Exception
    {
      EventUtil.removeListener(delegate, delegateListener);
      LifecycleUtil.deactivate(delegate);
      delegate = null;
      super.doDeactivate();
    }

    private void handleException(int attempt, Exception exception)
    {
      try
      {
        getExceptionHandler().handleException(CDOSessionImpl.this, attempt, exception);
      }
      catch (Exception ex)
      {
        throw WrappedException.wrap(ex);
      }
    }
  }
}




 * @author Eike Stepper
 * @since 2.0
 */
public interface CDOSessionProtocol extends CDOProtocol, PackageLoader,
		RevisionLoader {
	public void setPassiveUpdate(Map<CDOID, CDOIDAndVersion> idAndVersions,
			int initialChunkSize, boolean passiveUpdateEnabled);

	public RepositoryTimeResult getRepositoryTime();

	/**
	 * @param revision
	 * @param feature
	 * @param accessIndex
	 *            Index of the item access at the client (with modifications)
	 * @param fetchIndex
	 *            Index of the item access at the server (without any
	 *            modifications)
	 * @param fromIndex
	 *            Load objects at the client from fromIndex (inclusive)
	 * @param toIndex
	 *            Load objects at the client to toIndex (inclusive)
	 */
	public Object loadChunk(InternalCDORevision revision,
			EStructuralFeature feature, int accessIndex, int fetchIndex,
			int fromIndex, int toIndex);

	public Collection<CDOTimeStampContext> syncRevisions(
			Map<CDOID, CDOIDAndVersion> allRevisions, int initialChunkSize);

	/**
	 * @since 3.0
	 */
	public void openView(int viewId, CDOCommonView.Type type, long timeStamp);

	public void closeView(int viewId);

	public boolean[] setAudit(int viewId, long timeStamp,
			List<InternalCDOObject> invalidObjects);

	public void changeSubscription(int viewId, List<CDOID> cdoIDs,
			boolean subscribeMode, boolean clear);

	/**
	 * @since 3.0
	 */
	public void query(int viewID, AbstractQueryIterator<?> queryResult);

	public boolean cancelQuery(int queryId);

	/**
	 * @since 3.0
	 */
	public void lockObjects(CDOView view, Map<CDOID, CDOIDAndVersion> objects,
			long timeout, LockType lockType) throws InterruptedException;

	/**
	 * @since 3.0
	 */
	public void unlockObjects(CDOView view,
			Collection<? extends CDOObject> objects, LockType lockType);

	/**
	 * @since 3.0
	 */
	public boolean isObjectLocked(CDOView view, CDOObject object,
			LockType lockType, boolean byOthers);

	public CommitTransactionResult commitTransaction(
			InternalCDOCommitContext commitContext, OMMonitor monitor);

	public CommitTransactionResult commitTransactionPhase1(
			InternalCDOXACommitContext xaContext, OMMonitor monitor);

	public CommitTransactionResult commitTransactionPhase2(
			InternalCDOXACommitContext xaContext, OMMonitor monitor);

	public CommitTransactionResult commitTransactionPhase3(
			InternalCDOXACommitContext xaContext, OMMonitor monitor);

	public CommitTransactionResult commitTransactionCancel(
			InternalCDOXACommitContext xaContext, OMMonitor monitor);

	public List<CDORemoteSession> getRemoteSessions(
			InternalCDORemoteSessionManager manager, boolean subscribe);

	/**
	 * @since 3.0
	 */
	public Set<Integer> sendRemoteMessage(CDORemoteSessionMessage message,
			List<CDORemoteSession> recipients);

	/**
	 * @since 3.0
	 */
	public boolean unsubscribeRemoteSessions();

	/**
	 * @author Eike Stepper
	 */
	public final class OpenSessionResult {
		private int sessionID;

		private String repositoryUUID;

		private long repositoryCreationTime;

		private long lastUpdateTime;

		private RepositoryTimeResult repositoryTimeResult;

		private boolean repositorySupportingAudits;

		private List<InternalCDOPackageUnit> packageUnits = new ArrayList<InternalCDOPackageUnit>();

		/**
		 * @since 3.0
		 */
		public OpenSessionResult(int sessionID, String repositoryUUID,
				long repositoryCreationTime, long lastUpdateTime,
				boolean repositorySupportingAudits) {
			this.sessionID = sessionID;
			this.repositoryUUID = repositoryUUID;
			this.repositoryCreationTime = repositoryCreationTime;
			this.lastUpdateTime = lastUpdateTime;
			this.repositorySupportingAudits = repositorySupportingAudits;
		}

		public int getSessionID() {
			return sessionID;
		}

		public String getRepositoryUUID() {
			return repositoryUUID;
		}

		public long getRepositoryCreationTime() {
			return repositoryCreationTime;
		}

		public boolean isRepositorySupportingAudits() {
			return repositorySupportingAudits;
		}

		public RepositoryTimeResult getRepositoryTimeResult() {
			return repositoryTimeResult;
		}

		public void setRepositoryTimeResult(
				RepositoryTimeResult repositoryTimeResult) {
			this.repositoryTimeResult = repositoryTimeResult;
		}

		/**
		 * @since 3.0
		 */
		public long getLastUpdateTime() {
			return lastUpdateTime;
		}

		public List<InternalCDOPackageUnit> getPackageUnits() {
			return packageUnits;
		}
	}

	/**
	 * @author Eike Stepper
	 */
	public final class RepositoryTimeResult {
		private long requested;

		private long indicated;

		private long responded;

		private long confirmed;

		public RepositoryTimeResult() {
		}

		public long getRequested() {
			return requested;
		}

		public void setRequested(long requested) {
			this.requested = requested;
		}

		public long getIndicated() {
			return indicated;
		}

		public void setIndicated(long indicated) {
			this.indicated = indicated;
		}

		public long getResponded() {
			return responded;
		}

		public void setResponded(long responded) {
			this.responded = responded;
		}

		public long getConfirmed() {
			return confirmed;
		}

		public void setConfirmed(long confirmed) {
			this.confirmed = confirmed;
		}

		public long getAproximateRepositoryOffset() {
			long latency = confirmed - requested >> 1;
			long shift = confirmed - responded;
			return shift - latency;
		}

		public long getAproximateRepositoryTime() {
			long offset = getAproximateRepositoryOffset();
			return System.currentTimeMillis() + offset;
		}

		@Override
		public String toString() {
			return MessageFormat
					.format(
							"RepositoryTime[requested={0,date} {0,time}, indicated={1,date} {1,time}, responded={2,date} {2,time}, confirmed={3,date} {3,time}]",
							requested, indicated, responded, confirmed);
		}
	}

	/**
	 * @author Eike Stepper
	 */
	public final class CommitTransactionResult {
		private String rollbackMessage;

		private long timeStamp;

		// private List<CDOIDMetaRange> metaIDRanges = new
		// ArrayList<CDOIDMetaRange>();

		private Map<CDOIDTemp, CDOID> idMappings = new HashMap<CDOIDTemp, CDOID>();

		private CDOReferenceAdjuster referenceAdjuster;

		private InternalCDOCommitContext commitContext;

		public CommitTransactionResult(InternalCDOCommitContext commitContext,
				String rollbackMessage) {
			this.rollbackMessage = rollbackMessage;
			this.commitContext = commitContext;
		}

		public CommitTransactionResult(InternalCDOCommitContext commitContext,
				long timeStamp) {
			this.timeStamp = timeStamp;
			this.commitContext = commitContext;
		}

		public CDOReferenceAdjuster getReferenceAdjuster() {
			if (referenceAdjuster == null) {
				referenceAdjuster = createReferenceAdjuster();
			}

			return referenceAdjuster;
		}

		public void setReferenceAdjuster(CDOReferenceAdjuster referenceAdjuster) {
			this.referenceAdjuster = referenceAdjuster;
		}

		public InternalCDOCommitContext getCommitContext() {
			return commitContext;
		}

		public String getRollbackMessage() {
			return rollbackMessage;
		}

		public long getTimeStamp() {
			return timeStamp;
		}

		public Map<CDOIDTemp, CDOID> getIDMappings() {
			return idMappings;
		}

		public void addIDMapping(CDOIDTemp oldID, CDOID newID) {
			idMappings.put(oldID, newID);
		}

		// /**
		// * @since 3.0
		// */
		// public List<CDOIDMetaRange> getMetaIDRanges()
		// {
		// return metaIDRanges;
		// }
		//
		// /**
		// * @since 3.0
		// */
		// public void addMetaIDRange(CDOIDMetaRange metaIDRange)
		// {
		// metaIDRanges.add(metaIDRange);
		// }

		protected PostCommitReferenceAdjuster createReferenceAdjuster() {
			return new PostCommitReferenceAdjuster(commitContext
					.getTransaction(), new CDOIDMapper(idMappings));
		}

		/**
		 * @author Simon McDuff
		 */
		protected static class PostCommitReferenceAdjuster implements
				CDOReferenceAdjuster {
			private CDOIDProvider idProvider;

			private CDOIDMapper idMapper;

			public PostCommitReferenceAdjuster(CDOIDProvider idProvider,
					CDOIDMapper idMapper) {
				this.idProvider = idProvider;
				this.idMapper = idMapper;
			}

			public CDOIDProvider getIdProvider() {
				return idProvider;
			}

			public CDOIDMapper getIdMapper() {
				return idMapper;
			}

			public Object adjustReference(Object id) {
				if (id == null || id == CDOID.NULL) {
					return id;
				}

				if (idProvider != null
						&& (id instanceof CDOID || id instanceof InternalEObject)) {
					id = idProvider.provideCDOID(id);
				}

				return idMapper.adjustReference(id);
			}
		}
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void subscribeRemoteLocks();

	/**
	 * @author Juan Pedro Silva
	 */
	public void unsubscribeRemoteLocks();
        if (idProvider != null && (id instanceof CDOID || id instanceof InternalEObject))
        {
          id = idProvider.provideCDOID(id);
        }

        return idMapper.adjustReference(id);
      }
    }
  }
}




 * @author Eike Stepper
 * @since 2.0
 */
public interface InternalCDOSession extends CDOSession, PackageProcessor,
		PackageLoader, RevisionLocker, ILifecycle {
	/**
	 * @since 3.0
	 */
	public InternalCDOSessionConfiguration getConfiguration();

	public CDOSessionProtocol getSessionProtocol();

	/**
	 * @since 3.0
	 */
	public void setSessionProtocol(CDOSessionProtocol sessionProtocol);

	public InternalCDOPackageRegistry getPackageRegistry();

	/**
	 * @since 3.0
	 */
	public InternalCDORevisionManager getRevisionManager();

	public void setExceptionHandler(CDOSession.ExceptionHandler exceptionHandler);

	/**
	 * @since 3.0
	 */
	public void setFetchRuleManager(CDOFetchRuleManager fetchRuleManager);

	/**
	 * @since 3.0
	 */
	public void setRepositoryInfo(CDORepositoryInfo repositoryInfo);

	/**
	 * @since 3.0
	 */
	public InternalCDORemoteSessionManager getRemoteSessionManager();

	/**
	 * @since 3.0
	 */
	public void setRemoteSessionManager(
			InternalCDORemoteSessionManager remoteSessionManager);

	/**
	 * @since 3.0
	 */
	public void setSessionID(int sessionID);

	public void setUserID(String userID);

	/**
	 * @since 3.0
	 */
	public void setLastUpdateTime(long lastUpdateTime);

	public void viewDetached(InternalCDOView view);

	/**
	 * @since 3.0
	 */
	public Object resolveElementProxy(CDORevision revision,
			EStructuralFeature feature, int accessIndex, int serverIndex);

	/**
	 * @since 3.0
	 */
	public Object getCommitLock();

	public void handleCommitNotification(long timeStamp,
			Collection<CDOPackageUnit> newPackageUnits,
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects,
			Collection<CDORevisionDelta> deltas, InternalCDOView excludedView);

	public void handleSyncResponse(long timestamp,
			Collection<CDOPackageUnit> newPackageUnits,
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects);

	/**
	 * In some cases we need to sync without propagating event. Lock is a good
	 * example.
	 * 
	 * @since 3.0
	 */
	public void reviseRevisions(final long timeStamp,
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects,
			InternalCDOView excludedView);

	/**
	 * @author Juan Pedro Silva
	 */
	public void registerLockListeners(InternalCDOView cdoView);

	/**
	 * @author Juan Pedro Silva
	 */
	public void unregisterLockListeners(InternalCDOView cdoView);
}





import org.eclipse.net4j.util.collection.CloseableIterator;
import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
import org.eclipse.net4j.util.event.IListener;
import org.eclipse.net4j.util.event.INotifier;
import org.eclipse.net4j.util.options.IOptions;
import org.eclipse.net4j.util.options.IOptionsContainer;

import java.util.concurrent.locks.ReentrantLock;

/**
 * A read-only view to the <em>current</em> (i.e. latest) state of the object
 * graph in the repository of the underlying {@link CDOSession session}.
 * <p>
 * Objects that are accessed through this view are unchangeable for the client.
 * Each attempt to call a mutator on one of these objects or one of their
 * reference collections will result in a {@link ReadOnlyException} being thrown
 * immediately.
 * <p>
 * A view is opened through API of the underlying session like this:

 *   ...
 * </pre>
 * 
 * CDOView instances <b>must not</b> be accessed through concurrent client
 * threads.
 * <p>
 * Since a CDOObject, in a {@link CDOState#TRANSIENT non-TRANSIENT} state, is
 * only meaningful in combination with its dedicated view they must also not be
 * accessed through concurrent client threads. Please note that at arbitrary
 * times an arbitrary number of framework background threads are allowed to use
 * and modify a CDOview and its CDOObjects. Whenever you are iterating over a
 * number of CDOObjects and need to ensure that they are not modified by the
 * framework at the same time it is strongly recommended to acquire the
 * {@link #getLock() view lock} and protect your code appropriately.
 * 
 * @author Eike Stepper
 * @noimplement This interface is not intended to be implemented by clients.
 * @since 2.0
 */
public interface CDOView extends CDOCommonView, INotifier, IOptionsContainer {
	/**
	 * Returns the {@link CDOSession session} this view was opened by.
	 * 
	 * @return The session this view was opened by, or <code>null</code> if this
	 *         view is closed.
	 * @see #close()
	 * @see #isClosed()
	 * @see CDOSession#openView()
	 * @see CDOSession#openView(ResourceSet)
	 * @see CDOSession#openAudit(long)
	 * @see CDOSession#openAudit(ResourceSet, long)
	 * @see CDOSession#openTransaction()
	 * @see CDOSession#openTransaction(ResourceSet)
	 */
	public CDOSession getSession();

	/**
	 * Returns the {@link CDOViewSet view set} this view is associated with.
	 * 
	 * @return The view set this view is associated with, never
	 *         <code>null</code>.
	 * @see CDOViewSet#getViews()
	 */
	public CDOViewSet getViewSet();

	/**
	 * Returns the {@link ResourceSet resource set} this view is associated
	 * with.
	 * <p>
	 * Same as calling <tt>getViewSet().getResourceSet()</tt>.
	 * 
	 * @see CDOViewSet#getResourceSet()
	 */
	public ResourceSet getResourceSet();

	/**
	 * @deprecated This API is provisional and subject to change or removal.
	 */
	@Deprecated
	public URIHandler getURIHandler();

	/**
	 * Returns a reentrant lock that can be used to prevent the framework from
	 * writing to any object in this view (as it is caused, for example, by
	 * passive updates).
	 * <p>
	 * Acquiring this lock provides a means to safely iterate over multiple
	 * model elements without being affected by unanticipated remote updates,
	 * like in the following example:
	 * 
	 * <pre>
	 *    CDOResource resource = view.getResource(&quot;/orders/order-4711&quot;);
	 *    PurchaseOrder order = (PurchaseOrder)resource.getContents().get(0);
	 *    ReentrantLock lock = view.getLock();
	 *    if (!lock.tryLock(5L, TimeUnit.SECONDS))
	 *    {
	 *      throw new TimeoutException();
	 *    }
	 *    try
	 *    {
	 *      float sum = 0;
	 *      for (OrderDetail detail : order.getOrderDetails())
	 *      {
	 *        sum += detail.getPrice();
	 *      }
	 *      System.out.println(&quot;Sum: &quot; + sum);
	 *    }
	 *    finally
	 *    {
	 *      lock.unlock();
	 *    }
	 *  }
	 * </pre>
	 * 
	 * Note that this method really just returns the lock instance but does
	 * <b>not</b> acquire the lock! The above example acquires the lock with a
	 * timeout that expires after five seconds.
	 */
	public ReentrantLock getLock();

	/**
	 * Returns always <code>false</code>.
	 * <p>
	 * This method has a special implementation in {@link CDOTransaction} as
	 * well.
	 * 
	 * @see CDOTransaction#isDirty()
	 */
	public boolean isDirty();

	/**
	 * Returns always <code>false</code>.
	 * <p>
	 * This method has a special implementation in {@link CDOTransaction} as
	 * well.
	 * 
	 * @see CDOTransaction#hasConflict()
	 */
	public boolean hasConflict();

	/**
	 * Returns <code>true</code> if a resource with the given path exists in the
	 * repository, <code>false</code>.
	 * 
	 * @see #getResource(String, boolean)
	 */
	public boolean hasResource(String path);

	/**
	 * @see ResourceSet#getResource(URI, boolean)
	 */
	public CDOResource getResource(String path, boolean loadOnDemand);

	/**
	 * Same as {@link #getResource(String, boolean) getResource(String, true)}.
	 * 
	 * @see ResourceSet#getResource(URI, boolean)
	 */
	public CDOResource getResource(String path);

	/**
	 * Returns the resource node with the given path, or <code>null</code> if no
	 * such resource node exists.
	 */
	public CDOResourceNode getResourceNode(String path);

	/**
	 * Returns the root resource of the repository.
	 * <p>
	 * The root resource is a special resource with only {@link CDOResourceNode
	 * CDOResourceNodes} in its contents list. You can use it as the main entry
	 * into the new resource and folder structure.
	 */
	public CDOResource getRootResource();

	/**
	 * Returns a list of the resources in the given folder with a name equal to
	 * or starting with the value of the name parameter.
	 * 
	 * @param folder
	 *            The folder to search in, or <code>null</code> for top level
	 *            resource nodes.
	 * @param name
	 *            the name or prefix of the resource nodes to return.
	 * @param exactMatch
	 *            <code>true</code> if the complete name of the resource must
	 *            match, <code>false</code> if only a common prefix of the name
	 *            must match.
	 */
	public List<CDOResourceNode> queryResources(CDOResourceFolder folder,
			String name, boolean exactMatch);

	/**
	 * Returns an iterator over the resources in the given folder with a name
	 * equal to or starting with the value of the name parameter. The underlying
	 * query will be executed asynchronously.
	 * 
	 * @param folder
	 *            The folder to search in, or <code>null</code> for top level
	 *            resource nodes.
	 * @param name
	 *            the name or prefix of the resource nodes to return.
	 * @param exactMatch
	 *            <code>true</code> if the complete name of the resource must
	 *            match, <code>false</code> if only a common prefix of the name
	 *            must match.
	 */
	public CloseableIterator<CDOResourceNode> queryResourcesAsync(
			CDOResourceFolder folder, String name, boolean exactMatch);

	/**
	 * Returns the object for the given CDOID.
	 * 
	 * @param loadOnDemand
	 *            whether to create and load the object, if it doesn't already
	 *            exist.
	 * @return the object resolved by the CDOID if the id is not
	 *         <code>null</code>, or <code>null</code> if there isn't one and
	 *         loadOnDemand is <code>false</code>.
	 */
	public CDOObject getObject(CDOID id, boolean loadOnDemand);

	/**
	 * Returns the object for the given CDOID.
	 * <p>
	 * Same as <code>getObject(id, true)</code>.
	 * 
	 * @see getObject(CDOID, boolean)
	 */
	public CDOObject getObject(CDOID id);

	/**
	 * Takes an object from a (possibly) different view and
	 * <em>contextifies</em> it for the usage with this view.
	 * <ul>
	 * <li>If the given object is contained in this view it is returned
	 * unmodified.
	 * <li>If the given object can not be cast to {@link CDOObject} it is
	 * returned unmodified.
	 * <li>If the view of the given object is contained in a different session
	 * an <code>IllegalArgumentException</code> is thrown.
	 * <li>If <code>null</code> is passed <code>null</code> is returned.
	 * </ul>
	 */
	public <T extends EObject> T getObject(T objectFromDifferentView);

	/**
	 * Returns <code>true</code> if an {@link CDOObject object} with the given
	 * {@link CDOID id} is currently registered in this view, <code>false</code>
	 * otherwise.
	 */
	public boolean isObjectRegistered(CDOID id);

	/**
	 * Reloads the given {@link CDOObject objects} from the repository.
	 */
	public int reload(CDOObject... objects);

	/**
	 * Locks the given objects. Once the objects are locked, they will not be
	 * changed remotely or go in conflict state.
	 * 
	 * @since 3.0
	 */
	public void lockObjects(Collection<? extends CDOObject> objects,
			LockType lockType, long timeout) throws InterruptedException;

	/**
	 * Unlocks the given locked objects of this view.
	 */
	public void unlockObjects(Collection<? extends CDOObject> objects,
			LockType lockType);

	/**
	 * Unlocks all locked objects of this view.
	 * 
	 * @since 2.0
	 */
	public void unlockObjects();

	/**
	 * @since 3.0
	 */
	public void addObjectHandler(CDOObjectHandler handler);

	/**
	 * @since 3.0
	 */
	public void removeObjectHandler(CDOObjectHandler handler);

	/**
	 * @since 3.0
	 */
	public CDOObjectHandler[] getObjectHandlers();

	/**
	 * @since 2.0
	 */
	public CDOQuery createQuery(String language, String queryString);

	/**
	 * @since 2.0
	 */
	public Options options();

	/**
	 * @author Juan Pedro Silva
	 */
	public void registerLockListeners(Collection<IListener> collToRegister);

	/**
	 * @author Juan Pedro Silva
	 */
	public void registerLockListener(IListener listenerToRegister);

	/**
	 * @author Juan Pedro Silva
	 */
	public void unRegisterLockListener(IListener listenerToRegister);

	/**
	 * @author Juan Pedro Silva
	 */
	public void unRegisterLockListeners(Collection<IListener> collToUnregister);

	/**
	 * @author Juan Pedro Silva
	 */
	public void notifyRemoteLock(boolean b, String user,
			Collection<CDOID> cdoids, LockType lockType);

	/**
	 * @author Simon McDuff
	 */
	public interface Options extends IOptions {
		/**
     */
		public static final int NO_REVISION_PREFETCHING = 1;

		/**
		 * Returns the reference type to be used in the internal object cache.
		 * 
		 * @return Either {@link ReferenceType#STRONG STRONG},
		 *         {@link ReferenceType#SOFT SOFT} or {@link ReferenceType#WEAK
		 *         WEAK}.
		 */
		public ReferenceType getCacheReferenceType();

		/**
		 * Sets the reference type to be used in the internal object cache to
		 * either {@link ReferenceType#STRONG STRONG},
		 * {@link ReferenceType#SOFT SOFT} or {@link ReferenceType#WEAK WEAK}.
		 * If <code>null</code> is passed the default reference type
		 * {@link ReferenceType#SOFT SOFT} is set. If the given reference type
		 * does not differ from the one being currently set the new value is
		 * ignored and <code>false</code> is returned. Otherwise existing object
		 * references are converted to the new type and <code>true</code> is
		 * returned.
		 */
		public boolean setCacheReferenceType(ReferenceType referenceType);

		/**
		 * Returns <code>true</code> if the {@link CDOObject objects} in this
		 * view will notify their {@link org.eclipse.emf.common.notify.Adapter
		 * adapters} about the fact that they are <em>invalidated</em> (due to
		 * remote changes), <code>false</code> otherwise.
		 * 
		 * @see CDOInvalidationNotification
		 */
		public boolean isInvalidationNotificationEnabled();

		/**
		 * Specifies whether the {@link CDOObject objects} in this view will
		 * notify their {@link org.eclipse.emf.common.notify.Adapter adapters}
		 * about the fact that they are <em>invalidated</em> (due to remote
		 * changes) or not.
		 * 
		 * @see CDOInvalidationNotification
		 */
		public void setInvalidationNotificationEnabled(boolean enabled);

		/**
		 * Returns the current set of {@link CDOAdapterPolicy change
		 * subscription policies}.
		 * 
		 * @return The current set of change subscription policies, never
		 *         <code>null</code>.
		 * @see #setChangeSubscriptionPolicy(CDOAdapterPolicy)
		 */
		public CDOAdapterPolicy[] getChangeSubscriptionPolicies();

		/**
		 * Adds a change subscription policy to this view.
		 * <p>
		 * To activate a policy, you must do the following: <br>
		 * <code>view.options().addChangeSubscriptionPolicy(CDOChangeSubscriptionPolicy.ALL);</code>
		 * <p>
		 * To register an object, you must add an adapter to the object in which
		 * you are interested:<br>
		 * <code>eObject.eAdapters().add(myAdapter);</code>
		 * <p>
		 * By activating this feature, each object having at least one adapter
		 * that matches the current policy will be registered with the server
		 * and will be notified for each change occurring in the scope of any
		 * other transaction.
		 * <p>
		 * {@link CDOAdapterPolicy#NONE} - Ignored. <br>
		 * {@link CDOAdapterPolicy#ALL} - Enabled for all adapters used.<br>
		 * {@link CDOAdapterPolicy#CDO} - Enabled only for adapters that
		 * implement {@link CDOAdapter}. <br>
		 * Any other class that implement {@link CDOAdapterPolicy} will enable
		 * for whatever rules defined in that class. <br>
		 * <p>
		 * If <code>myAdapter</code> in the above example matches the current
		 * policy, <code>eObject</code> will be registered with the server and
		 * you will receive all changes from other transaction.
		 * <p>
		 * When the policy is changed all objects in the cache will
		 * automatically be recalculated.
		 * <p>
		 * You can subscribe to temporary objects. Even if you cannot receive
		 * notifications from other {@link CDOTransaction} for these because
		 * they are only local to you, at commit time these objects will be
		 * registered automatically.
		 * <p>
		 * <b>Note:</b> It can be used with
		 * <code>CDOSession.options().setPassiveUpdate(false)</code>. In this
		 * case, it will receive changes without having the objects changed.
		 */
		public void addChangeSubscriptionPolicy(CDOAdapterPolicy policy);

		/**
		 * Removes a change subscription policy from this view.
		 */
		public void removeChangeSubscriptionPolicy(CDOAdapterPolicy policy);

		// TODO
		public CDOAdapterPolicy getStrongReferencePolicy();

		/**
		 * Sets the reference type to be used when an adapter is used to an
		 * object.
		 * <p>
		 * When <code>CDOView.setStrongReference(CDOAdapterPolicy.ALL)</code> is
		 * used, it is possible that the target object will be GC. In that case,
		 * the adapter will never received notifications. By Default the value
		 * is at <code>CDOAdapterPolicy.ALL</code>
		 */
		public void setStrongReferencePolicy(CDOAdapterPolicy policy);

		/**
		 * Returns the CDOStaleReferencePolicy in use.
		 * 
		 * @since 3.0
		 */
		public CDOStaleReferencePolicy getStaleReferenceBehaviour();

		/**
		 * Sets a policy on how to deal with stale references.
		 * 
		 * @since 3.0
		 */
		public void setStaleReferenceBehaviour(CDOStaleReferencePolicy policy);

		/**
		 * Returns the CDORevisionPrefetchingPolicy in use.
		 */
		public CDORevisionPrefetchingPolicy getRevisionPrefetchingPolicy();

		/**
		 * The CDORevisionPrefetchingPolicy feature of the CDOView allows CDO
		 * users to fetch many objects at a time.
		 * <p>
		 * The difference between the CDOCollectionLoadingPolicy feature and the
		 * CDORevisionPrefetchingPolicy feature is subtle. The
		 * CDOCollectionLoadingPolicy feature determines how and when to fetch
		 * CDOIDs, while the CDORevisionPrefetchingPolicy feature determines how
		 * and when to resolve CDOIDs (i.e. fetch the target objects).
		 * <p>
		 * <code>view.options().setRevisionPrefetchingPolicy (CDONet4jUtil.createRevisionPrefetchingPolicy(10));</code>
		 * <p>
		 * The end-user could provide its own implementation of the
		 * CDORevisionPrefetchingPolicy interface.
		 */
		public void setRevisionPrefetchingPolicy(
				CDORevisionPrefetchingPolicy prefetchingPolicy);

		public interface CacheReferenceTypeEvent extends IOptionsEvent {
		}

		public interface ReferencePolicyEvent extends IOptionsEvent {
		}

		/**
		 * @since 3.0
		 */
		public interface StaleReferencePolicyEvent extends IOptionsEvent {
		}

		public interface ChangeSubscriptionPoliciesEvent extends IOptionsEvent {
		}

		public interface InvalidationNotificationEvent extends IOptionsEvent {
		}

		public interface RevisionPrefetchingPolicyEvent extends IOptionsEvent {
		}
	}
}




import org.eclipse.emf.cdo.view.CDOViewAdaptersNotifiedEvent;
import org.eclipse.emf.cdo.view.CDOViewEvent;
import org.eclipse.emf.cdo.view.CDOViewInvalidationEvent;
import org.eclipse.emf.cdo.view.RemoteLockAcquiredEvent;
import org.eclipse.emf.cdo.view.RemoteLockReleasedEvent;

import org.eclipse.emf.internal.cdo.CDODeltaNotificationImpl;
import org.eclipse.emf.internal.cdo.CDOInvalidationNotificationImpl;

/**
 * @author Eike Stepper
 */
public class CDOViewImpl extends Lifecycle implements InternalCDOView {
	private static final ContextTracer TRACER = new ContextTracer(
			OM.DEBUG_VIEW, CDOViewImpl.class);

	private int viewID;

	private InternalCDOSession session;

	private InternalCDOViewSet viewSet;

	private CDOURIHandler uriHandler = new CDOURIHandler(this);

	private CDOFeatureAnalyzer featureAnalyzer = CDOFeatureAnalyzer.NOOP;

	private ConcurrentMap<CDOID, InternalCDOObject> objects;

	private CDOStore store = new CDOStore(this);

	private ReentrantLock lock = new ReentrantLock(true);

	private ReentrantLock stateLock = new ReentrantLock(true);

	private CDOResourceImpl rootResource;

	private ChangeSubscriptionManager changeSubscriptionManager = createChangeSubscriptionManager();

	private AdapterManager adapterPolicyManager = createAdapterManager();

	private FastList<CDOObjectHandler> objectHandlers = new FastList<CDOObjectHandler>() {
		@Override
		protected CDOObjectHandler[] newArray(int length) {
			return new CDOObjectHandler[length];
		}
	};

	private OptionsImpl options;

	@ExcludeFromDump
	private transient CDOID lastLookupID;

	@ExcludeFromDump
	private transient InternalCDOObject lastLookupObject;

	/**
	 * @since 2.0
	 */
	public CDOViewImpl() {
		options = createOptions();
	}

	/**
	 * @since 2.0
	 */
	public OptionsImpl options() {
		return options;
	}

	public int getViewID() {
		return viewID;
	}

	/**
	 * @since 2.0
	 */
	public void setViewID(int viewId) {
		viewID = viewId;
	}

	public Type getViewType() {
		return Type.READONLY;
	}

	public ResourceSet getResourceSet() {
		return viewSet.getResourceSet();
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOViewSet getViewSet() {
		return viewSet;
	}

	/**
	 * @since 2.0
	 */
	public void setViewSet(InternalCDOViewSet viewSet) {
		this.viewSet = viewSet;
		if (viewSet != null) {
			viewSet.getResourceSet().getURIConverter().getURIHandlers().add(0,
					getURIHandler());
		}
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOSession getSession() {
		return session;
	}

	/**
	 * @since 2.0
	 */
	public void setSession(InternalCDOSession session) {
		this.session = session;
	}

	public CDOStore getStore() {
		checkActive();
		return store;
	}

	/**
	 * @since 2.0
	 */
	public synchronized CDOResourceImpl getRootResource() {
		checkActive();
		if (rootResource == null) {
			rootResource = createRootResource();
		}

		return rootResource;
	}

	/**
	 * @return
	 * @since 2.0
	 */
	protected CDOResourceImpl createRootResource() {
		return (CDOResourceImpl) getResource(CDOResourceNode.ROOT_PATH);
	}

	/**
	 * @since 2.0
	 */
	public CDOURIHandler getURIHandler() {
		return uriHandler;
	}

	/**
	 * @since 2.0
	 */
	public ReentrantLock getLock() {
		return lock;
	}

	/**
	 * @since 2.0
	 */
	public ReentrantLock getStateLock() {
		return stateLock;
	}

	/**
	 * @throws InterruptedException
	 * @since 2.0
	 */
	public void lockObjects(Collection<? extends CDOObject> objects,
			LockType lockType, long timeout) throws InterruptedException {
		checkActive();
		Map<CDOID, CDOIDAndVersion> uniqueObjects = new HashMap<CDOID, CDOIDAndVersion>();
		getCDOIDAndVersion(uniqueObjects, objects);
		for (CDOObject object : objects) {
			CDOIDAndVersion idAndVersion = uniqueObjects.get(object.cdoID());
			if (idAndVersion == null) {
				uniqueObjects.put(object.cdoID(), CDOIDUtil.createIDAndVersion(
						object.cdoID(), CDORevision.UNSPECIFIED_VERSION));
			}
		}

		session.getSessionProtocol().lockObjects(this, uniqueObjects, timeout,
				lockType);
	}

	/**
	 * @since 2.0
	 */
	public void unlockObjects(Collection<? extends CDOObject> objects,
			LockType lockType) {
		checkActive();
		session.getSessionProtocol().unlockObjects(this, objects, lockType);
	}

	/**
	 * @since 2.0
	 */
	public void unlockObjects() {
		unlockObjects(null, null);
	}

	/**
	 * @since 2.0
	 */
	public boolean isObjectLocked(CDOObject object, LockType lockType,
			boolean byOthers) {
		checkActive();
		return session.getSessionProtocol().isObjectLocked(this, object,
				lockType, byOthers);
	}

	/**
	 * @since 2.0
	 */
	public long getTimeStamp() {
		return UNSPECIFIED_DATE;
	}

	public boolean isDirty() {
		return false;
	}

	public boolean hasConflict() {
		return false;
	}

	/**
	 * @since 2.0
	 */
	public CDOFeatureAnalyzer getFeatureAnalyzer() {
		return featureAnalyzer;
	}

	/**
	 * @since 2.0
	 */
	public void setFeatureAnalyzer(CDOFeatureAnalyzer featureAnalyzer) {
		this.featureAnalyzer = featureAnalyzer == null ? CDOFeatureAnalyzer.NOOP
				: featureAnalyzer;
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOTransaction toTransaction() {
		checkActive();
		if (this instanceof InternalCDOTransaction) {
			return (InternalCDOTransaction) this;
		}

		throw new ReadOnlyException(MessageFormat.format(Messages
				.getString("CDOViewImpl.0"), this)); //$NON-NLS-1$
	}

	public boolean hasResource(String path) {
		checkActive();

		try {
			getResourceNodeID(path);
			return true;
		} catch (Exception ex) {
			return false;
		}
	}

	/**
	 * @since 2.0
	 */
	public CDOQuery createQuery(String language, String queryString) {
		checkActive();
		return new CDOQueryImpl(this, language, queryString);
	}

	/**
	 * @since 2.0
	 */
	public CDOResourceNode getResourceNode(String path) {
		CDOID id = getResourceNodeID(path);
		if (id == null) {
			return null;
		}

		InternalCDOObject object = getObject(id);
		if (object instanceof CDOResourceNode) {
			return (CDOResourceNode) object;
		}

		return null;
	}

	/**
	 * @return never <code>null</code>
	 * @since 2.0
	 */
	public CDOID getResourceNodeID(String path) {
		if (StringUtil.isEmpty(path)) {
			throw new IllegalArgumentException(Messages
					.getString("CDOViewImpl.1")); //$NON-NLS-1$
		}

		CDOID folderID = null;
		if (CDOURIUtil.SEGMENT_SEPARATOR.equals(path)) {
			folderID = getResourceNodeIDChecked(null, null);
		} else {
			List<String> names = CDOURIUtil.analyzePath(path);
			for (String name : names) {
				folderID = getResourceNodeIDChecked(folderID, name);
			}
		}

		return folderID;
	}

	/**
	 * @return never <code>null</code>
	 */
	private CDOID getResourceNodeIDChecked(CDOID folderID, String name) {
		folderID = getResourceNodeID(folderID, name);
		if (folderID == null) {
			throw new CDOException(MessageFormat.format(Messages
					.getString("CDOViewImpl.2"), name)); //$NON-NLS-1$
		}

		return folderID;
	}

	/**
	 * @return never <code>null</code>
	 * @since 2.0
	 */
	protected CDOResourceNode getResourceNode(CDOID folderID, String name) {
		try {
			CDOID id = getResourceNodeID(folderID, name);
			return (CDOResourceNode) getObject(id);
		} catch (CDOException ex) {
			throw ex;
		} catch (Exception ex) {
			throw new CDOException(ex);
		}
	}

	/**
	 * @since 2.0
	 */
	protected CDOID getResourceNodeID(CDOID folderID, String name) {
		if (folderID == null) {
			return getRootOrTopLevelResourceNodeID(name);
		}

		if (name == null) {
			throw new IllegalArgumentException(Messages
					.getString("CDOViewImpl.3")); //$NON-NLS-1$
		}

		InternalCDORevision folderRevision = getLocalRevision(folderID);
		EClass resourceFolderClass = EresourcePackage.eINSTANCE
				.getCDOResourceFolder();
		if (folderRevision.getEClass() != resourceFolderClass) {
			throw new CDOException(MessageFormat.format(Messages
					.getString("CDOViewImpl.4"), folderID)); //$NON-NLS-1$
		}

		EReference nodesFeature = EresourcePackage.eINSTANCE
				.getCDOResourceFolder_Nodes();
		EAttribute nameFeature = EresourcePackage.eINSTANCE
				.getCDOResourceNode_Name();

		int size = folderRevision.data().size(nodesFeature);
		for (int i = 0; i < size; i++) {
			Object value = folderRevision.data().get(nodesFeature, i);
			value = getStore().resolveProxy(folderRevision, nodesFeature, i,
					value);

			CDORevision childRevision = getLocalRevision((CDOID) convertObjectToID(value));
			if (name.equals(childRevision.data().get(nameFeature, 0))) {
				return childRevision.getID();
			}
		}

		throw new CDOException(MessageFormat.format(Messages
				.getString("CDOViewImpl.5"), name)); //$NON-NLS-1$
	}

	/**
	 * @since 2.0
	 */
	protected CDOID getRootOrTopLevelResourceNodeID(String name) {
		CDOQuery resourceQuery = createResourcesQuery(null, name, true);
		resourceQuery.setMaxResults(1);
		List<CDOID> ids = resourceQuery.getResult(CDOID.class);
		if (ids.isEmpty()) {
			if (name == null) {
				throw new CDOException(Messages.getString("CDOViewImpl.6")); //$NON-NLS-1$
			} else {
				throw new CDOException(MessageFormat.format(Messages
						.getString("CDOViewImpl.7"), name)); //$NON-NLS-1$
			}
		}

		if (ids.size() > 1) {
			// TODO is this still needed since the is
			// resourceQuery.setMaxResults(1) ??
			throw new ImplementationError(Messages.getString("CDOViewImpl.8")); //$NON-NLS-1$
		}

		return ids.get(0);
	}

	/**
	 * @since 2.0
	 */
	protected InternalCDORevision getLocalRevision(CDOID id) {
		InternalCDORevision revision = null;
		InternalCDOObject object = getObject(id, false);
		if (object != null && object.cdoState() != CDOState.PROXY) {
			revision = object.cdoRevision();
		}

		if (revision == null) {
			revision = getRevision(id, true);
		}

		if (revision == null) {
			throw new CDOException(MessageFormat.format(Messages
					.getString("CDOViewImpl.9"), id)); //$NON-NLS-1$
		}

		return revision;
	}

	/**
	 * @since 2.0
	 */
	public InternalCDOObject[] getObjectsArray() {
		synchronized (objects) {
			return objects.values().toArray(
					new InternalCDOObject[objects.size()]);
		}
	}

	/**
	 * TODO Remove me
	 * 
	 * @since 2.0
	 */
	@Deprecated
	public CDOResourceFolder getResourceFolder(String path) {
		if (path == null) {
			return null;
		}

		CDOResourceFolder folder = null;
		StringTokenizer tokenizer = new StringTokenizer(path,
				CDOURIUtil.SEGMENT_SEPARATOR);
		while (tokenizer.hasMoreTokens()) {
			String segment = tokenizer.nextToken();
			if (segment != null) {
				if (folder == null) {
				} else {
				}
			}
		}

		return folder;
	}

	/**
	 * @since 2.0
	 */
	public CDOResource getResource(String path) {
		return getResource(path, true);
	}

	/**
	 * @since 2.0
	 */
	public CDOResource getResource(String path, boolean loadInDemand) {
		checkActive();
		URI uri = CDOURIUtil.createResourceURI(this, path);
		return (CDOResource) getResourceSet().getResource(uri, loadInDemand);
	}

	/**
	 * @since 2.0
	 */
	public List<CDOResourceNode> queryResources(CDOResourceFolder folder,
			String name, boolean exactMatch) {
		checkActive();
		CDOQuery resourceQuery = createResourcesQuery(folder, name, exactMatch);
		return resourceQuery.getResult(CDOResourceNode.class);
	}

	/**
	 * @since 2.0
	 */
	public CloseableIterator<CDOResourceNode> queryResourcesAsync(
			CDOResourceFolder folder, String name, boolean exactMatch) {
		checkActive();
		CDOQuery resourceQuery = createResourcesQuery(folder, name, exactMatch);
		return resourceQuery.getResultAsync(CDOResourceNode.class);
	}

	private CDOQuery createResourcesQuery(CDOResourceFolder folder,
			String name, boolean exactMatch) {
		CDOQuery query = createQuery(
				CDOProtocolConstants.QUERY_LANGUAGE_RESOURCES, name);
		query.setParameter(
				CDOProtocolConstants.QUERY_LANGUAGE_RESOURCES_FOLDER_ID,
				folder == null ? null : folder.cdoID());
		query.setParameter(
				CDOProtocolConstants.QUERY_LANGUAGE_RESOURCES_EXACT_MATCH,
				exactMatch);
		return query;
	}

	public CDOResourceImpl getResource(CDOID resourceID) {
		if (CDOIDUtil.isNull(resourceID)) {
			throw new IllegalArgumentException("resourceID: " + resourceID); //$NON-NLS-1$
		}

		return (CDOResourceImpl) getObject(resourceID);
	}

	public InternalCDOObject newInstance(EClass eClass) {
		EObject eObject = EcoreUtil.create(eClass);
		return FSMUtil.adapt(eObject, this);
	}

	public InternalCDORevision getRevision(CDOID id, boolean loadOnDemand) {
		CDORevisionManager revisionManager = session.getRevisionManager();
		int initialChunkSize = session.options().getCollectionLoadingPolicy()
				.getInitialChunkSize();
		return (InternalCDORevision) revisionManager.getRevision(id,
				initialChunkSize, CDORevision.DEPTH_NONE, loadOnDemand);
	}

	public void prefetchRevisions(CDOID id, int depth) {
		checkArg(depth != CDORevision.DEPTH_NONE,
				"Prefetch depth must not be zero");
		int initialChunkSize = session.options().getCollectionLoadingPolicy()
				.getInitialChunkSize();
		prefetchRevisions(id, depth, initialChunkSize);
	}

	protected void prefetchRevisions(CDOID id, int depth, int initialChunkSize) {
		session.getRevisionManager().getRevision(id, initialChunkSize, depth);
	}

	public InternalCDOObject getObject(CDOID id) {
		return getObject(id, true);
	}

	/**
	 * Support recursivity and concurrency.
	 */
	public InternalCDOObject getObject(CDOID id, boolean loadOnDemand) {
		checkActive();
		if (CDOIDUtil.isNull(id)) {
			return null;
		}

		// Since getObject could trigger a read (ONLY when we load a resource)
		// we NEED to make sure the state lock is
		// active.
		// Always use in the following order
		// 1- getStateLock().lock();
		// 2- synchronized(objects)
		// DO NOT inverse them otherwise deadlock could occured.

		ReentrantLock stateLock = getStateLock();
		stateLock.lock();
		try {
			synchronized (objects) {
				if (id.equals(lastLookupID)) {
					return lastLookupObject;
				}

				// Needed for recursive call to getObject. (from
				// createObject/cleanObject/getResource/getObject)
				InternalCDOObject localLookupObject = objects.get(id);
				if (localLookupObject == null) {
					if (id.isMeta()) {
						localLookupObject = createMetaObject((CDOIDMeta) id);
					} else {
						if (loadOnDemand) {
							if (id.isTemporary()) {
								throw new ObjectNotFoundException(id);
							}

							localLookupObject = createObject(id);
						} else {
							return null;
						}
					}

					// CDOResource have a special way to register to the view.
					if (!CDOModelUtil.isResource(localLookupObject.eClass())) {
						registerObject(localLookupObject);
					}
				}

				lastLookupID = id;
				lastLookupObject = localLookupObject;
				return lastLookupObject;
			}
		} finally {
			stateLock.unlock();
		}
	}

	/**
	 * @since 2.0
	 */
	@SuppressWarnings("unchecked")
	public <T extends EObject> T getObject(T objectFromDifferentView) {
		checkActive();
		if (objectFromDifferentView instanceof CDOObject) {
			CDOObject object = (CDOObject) objectFromDifferentView;
			CDOView view = object.cdoView();
			if (view != this) {
				if (view.getSession() != session) {
					throw new IllegalArgumentException(
							MessageFormat
									.format(
											Messages
													.getString("CDOViewImpl.11"), objectFromDifferentView)); //$NON-NLS-1$
				}

				CDOID id = object.cdoID();
				objectFromDifferentView = (T) getObject(id, true);
			}
		}

		return objectFromDifferentView;
	}

	public boolean isObjectRegistered(CDOID id) {
		checkActive();
		if (CDOIDUtil.isNull(id)) {
			return false;
		}

		synchronized (objects) {
			return objects.containsKey(id);
		}
	}

	public InternalCDOObject removeObject(CDOID id) {
		synchronized (objects) {
			if (id.equals(lastLookupID)) {
				lastLookupID = null;
				lastLookupObject = null;
			}

			return objects.remove(id);
		}
	}

	/**
	 * @return Never <code>null</code>
	 */
	private InternalCDOObject createMetaObject(CDOIDMeta id) {
		if (TRACER.isEnabled()) {
			TRACER.trace("Creating meta object for " + id); //$NON-NLS-1$
		}

		InternalCDOPackageRegistry packageRegistry = session
				.getPackageRegistry();
		InternalEObject metaInstance = packageRegistry.getMetaInstanceMapper()
				.lookupMetaInstance(id);
		return new CDOMetaWrapper(this, metaInstance, id);
	}

	/**
	 * @return Never <code>null</code>
	 */
	private InternalCDOObject createObject(CDOID id) {
		if (TRACER.isEnabled()) {
			TRACER.trace("Creating object for " + id); //$NON-NLS-1$
		}

		InternalCDORevision revision = getRevision(id, true);
		FSMUtil.validate(id, revision);

		EClass eClass = revision.getEClass();
		InternalCDOObject object;
		if (CDOModelUtil.isResource(eClass)) {
			object = (InternalCDOObject) newResourceInstance(revision);
			// object is PROXY
		} else {
			object = newInstance(eClass);
			// object is TRANSIENT
		}

		cleanObject(object, revision);
		return object;
	}

	private CDOResource newResourceInstance(InternalCDORevision revision) {
		String path = getResourcePath(revision);
		return getResource(path, true);
	}

	private String getResourcePath(InternalCDORevision revision) {
		EAttribute nameFeature = EresourcePackage.eINSTANCE
				.getCDOResourceNode_Name();

		CDOID folderID = (CDOID) revision.data().getContainerID();
		String name = (String) revision.data().get(nameFeature, 0);
		if (CDOIDUtil.isNull(folderID)) {
			if (name == null) {
				return CDOURIUtil.SEGMENT_SEPARATOR;
			}

			return name;
		}

		InternalCDOObject object = getObject(folderID, true);
		if (object instanceof CDOResourceFolder) {
			CDOResourceFolder folder = (CDOResourceFolder) object;
			String path = folder.getPath();
			return path + CDOURIUtil.SEGMENT_SEPARATOR + name;
		}

		throw new ImplementationError(MessageFormat.format(Messages
				.getString("CDOViewImpl.14"), object)); //$NON-NLS-1$
	}

	/**
	 * @since 2.0
	 */
	protected void cleanObject(InternalCDOObject object,
			InternalCDORevision revision) {
		object.cdoInternalCleanup();

		object.cdoInternalSetView(this);
		object.cdoInternalSetRevision(revision);
		object.cdoInternalSetID(revision.getID());
		object.cdoInternalSetState(CDOState.CLEAN);

		object.cdoInternalPostLoad();
	}

	public CDOID provideCDOID(Object idOrObject) {
		Object shouldBeCDOID = convertObjectToID(idOrObject);
		if (shouldBeCDOID instanceof CDOID) {
			CDOID id = (CDOID) shouldBeCDOID;
			if (TRACER.isEnabled() && id != idOrObject) {
				TRACER
						.format(
								"Converted object to CDOID: {0} --> {1}", idOrObject, id); //$NON-NLS-1$
			}

			return id;
		} else if (idOrObject instanceof InternalEObject) {
			InternalEObject eObject = (InternalEObject) idOrObject;
			String uri = EcoreUtil.getURI(eObject).toString();
			if (eObject instanceof InternalCDOObject) {
				InternalCDOObject object = (InternalCDOObject) idOrObject;
				if (object.cdoView() != null && FSMUtil.isNew(object)) {
					return CDOIDUtil.createTempObjectExternal(uri);
				}
			}

			if (eObject.eResource() != null) {
				return CDOIDUtil.createExternal(uri);
			}

			throw new DanglingReferenceException(eObject);
		}

		throw new IllegalStateException(MessageFormat.format(Messages
				.getString("CDOViewImpl.16"), idOrObject.getClass().getName())); //$NON-NLS-1$
	}

	public Object convertObjectToID(Object potentialObject) {
		return convertObjectToID(potentialObject, false);
	}

	/**
	 * @since 2.0
	 */
	public Object convertObjectToID(Object potentialObject,
			boolean onlyPersistedID) {
		if (potentialObject instanceof CDOID) {
			return potentialObject;
		}

		if (potentialObject instanceof InternalEObject) {
			if (potentialObject instanceof InternalCDOObject) {
				InternalCDOObject object = (InternalCDOObject) potentialObject;
				CDOID id = getID(object, onlyPersistedID);
				if (id != null) {
					return id;
				}
			} else {
				try {
					InternalCDOObject object = FSMUtil
							.getLegacyAdapter(((InternalEObject) potentialObject)
									.eAdapters());
					if (object != null) {
						CDOID id = getID(object, onlyPersistedID);
						if (id != null) {
							return id;
						}

						potentialObject = object;
					}
				} catch (Throwable ex) {
					OM.LOG.warn(ex);
				}
			}
		}

		return potentialObject;
	}

	// TTT public CDOIDDangling convertDanglingObjectToID(InternalCDOObject
	// source, EStructuralFeature feature,
	// InternalEObject target)
	// {
	// throw new
	// IllegalStateException("Dangling objects not possible outside of a transaction");
	// }

	protected CDOID getID(InternalCDOObject object, boolean onlyPersistedID) {
		if (onlyPersistedID) {
			if (FSMUtil.isTransient(object) || FSMUtil.isNew(object)) {
				return null;
			}
		}

		CDOView view = object.cdoView();
		if (view == this) {
			return object.cdoID();
		}

		if (view != null && view.getSession() == getSession()) {
			return object.cdoID();
		}

		return null;
	}

	public Object convertIDToObject(Object potentialID) {
		if (potentialID instanceof CDOID) {
			if (potentialID == CDOID.NULL) {
				return null;
			}

			CDOID id = (CDOID) potentialID;
			if (id.isExternal()) {
				return getResourceSet().getEObject(
						URI.createURI(id.toURIFragment()), true);
			}

			InternalCDOObject result = getObject(id, true);
			if (result == null) {
				throw new ImplementationError(MessageFormat.format(Messages
						.getString("CDOViewImpl.17"), id)); //$NON-NLS-1$
			}

			return result.cdoInternalInstance();
		}

		return potentialID;
	}

	/**
	 * @since 2.0
	 */
	public void attachResource(CDOResourceImpl resource) {
		if (!resource.isExisting()) {
			throw new ReadOnlyException(MessageFormat.format(Messages
					.getString("CDOViewImpl.18"), this)); //$NON-NLS-1$
		}

		// ResourceSet.getResource(uri, true) was called!!
		resource.cdoInternalSetView(this);
		resource.cdoInternalSetState(CDOState.PROXY);
	}

	/**
	 * @since 2.0
	 */
	public void registerProxyResource(CDOResourceImpl resource) {
		URI uri = resource.getURI();
		String path = CDOURIUtil.extractResourcePath(uri);

		try {
			CDOID id = getResourceNodeID(path);
			resource.cdoInternalSetID(id);
			registerObject(resource);
		} catch (Exception ex) {
			throw new InvalidURIException(uri, ex);
		}
	}

	public void registerObject(InternalCDOObject object) {
		if (TRACER.isEnabled()) {
			TRACER.format("Registering {0}", object); //$NON-NLS-1$
		}

		InternalCDOObject old;
		synchronized (objects) {
			old = objects.put(object.cdoID(), object);
		}

		if (old != null) {
			throw new IllegalStateException(MessageFormat.format(Messages
					.getString("CDOViewImpl.20"), object)); //$NON-NLS-1$
		}
	}

	public void deregisterObject(InternalCDOObject object) {
		if (TRACER.isEnabled()) {
			TRACER.format("Deregistering {0}", object); //$NON-NLS-1$
		}

		removeObject(object.cdoID());
	}

	public void remapObject(CDOID oldID) {
		CDOID newID;
		synchronized (objects) {
			InternalCDOObject object = objects.remove(oldID);
			newID = object.cdoID();
			objects.put(newID, object);
		}

		if (TRACER.isEnabled()) {
			TRACER.format("Remapping {0} --> {1}", oldID, newID); //$NON-NLS-1$
		}
	}

	public void addObjectHandler(CDOObjectHandler handler) {
		objectHandlers.add(handler);
	}

	public void removeObjectHandler(CDOObjectHandler handler) {
		objectHandlers.remove(handler);
	}

	public CDOObjectHandler[] getObjectHandlers() {
		return objectHandlers.get();
	}

	public void handleObjectStateChanged(InternalCDOObject object,
			CDOState oldState, CDOState newState) {
		CDOObjectHandler[] handlers = getObjectHandlers();
		if (handlers != null) {
			for (int i = 0; i < handlers.length; i++) {
				CDOObjectHandler handler = handlers[i];
				handler.objectStateChanged(this, object, oldState, newState);
			}
		}
	}

	/**
	 * Turns registered objects into proxies and synchronously delivers
	 * invalidation events to registered event listeners.
	 * <p>
	 * <b>Implementation note:</b> This implementation guarantees that
	 * exceptions from listener code don't propagate up to the caller of this
	 * method. Runtime exceptions from the implementation of the
	 * {@link CDOStateMachine} are propagated to the caller of this method but
	 * this should not happen in the absence of implementation errors.
	 * <p>
	 * Note that this method can block for an uncertain amount of time on the
	 * reentrant view lock!
	 * 
	 * @param timeStamp
	 *            The time stamp of the server transaction if this event was
	 *            sent as a result of a successfully committed transaction or
	 *            <code>LOCAL_ROLLBACK</code> if this event was sent due to a
	 *            local rollback.
	 * @param dirtyOIDs
	 *            A set of the object IDs to be invalidated. <b>Implementation
	 *            note:</b> This implementation expects the dirtyOIDs set to be
	 *            unmodifiable. It does not wrap the set (again).
	 * @since 2.0
	 */
	public Set<CDOObject> handleInvalidation(long timeStamp,
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedOIDs) {
		Set<CDOObject> conflicts = null;
		Set<InternalCDOObject> dirtyObjects = new HashSet<InternalCDOObject>();
		Set<InternalCDOObject> detachedObjects = new HashSet<InternalCDOObject>();
		lock.lock();

		try {
			conflicts = handleInvalidationWithoutNotification(dirtyOIDs,
					detachedOIDs, dirtyObjects, detachedObjects);
		} finally {
			lock.unlock();
		}

		if (options().isInvalidationNotificationEnabled()) {
			for (InternalCDOObject dirtyObject : dirtyObjects) {
				if (dirtyObject.eNotificationRequired()) {
					CDOInvalidationNotificationImpl notification = new CDOInvalidationNotificationImpl(
							dirtyObject);
					dirtyObject.eNotify(notification);
				}
			}

			for (InternalCDOObject detachedObject : detachedObjects) {
				if (detachedObject.eNotificationRequired()) {
					CDOInvalidationNotificationImpl notification = new CDOInvalidationNotificationImpl(
							detachedObject);
					detachedObject.eNotify(notification);
				}
			}
		}

		fireInvalidationEvent(timeStamp, Collections
				.unmodifiableSet(dirtyObjects), Collections
				.unmodifiableSet(detachedObjects));
		return conflicts;
	}

	public Set<CDOObject> handleInvalidationWithoutNotification(
			Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedOIDs,
			Set<InternalCDOObject> dirtyObjects,
			Set<InternalCDOObject> detachedObjects) {
		Set<CDOObject> conflicts = null;
		for (CDOIDAndVersion dirtyOID : dirtyOIDs) {
			InternalCDOObject dirtyObject = null;
			// 258831 - Causes deadlock when introduce thread safe mechanisms in
			// State machine.
			synchronized (objects) {
				dirtyObject = objects.get(dirtyOID.getID());
			}

			if (dirtyObject != null) {
				CDOStateMachine.INSTANCE.invalidate(dirtyObject, dirtyOID
						.getVersion());
				dirtyObjects.add(dirtyObject);
				if (dirtyObject.cdoConflict()) {
					if (conflicts == null) {
						conflicts = new HashSet<CDOObject>();
					}

					conflicts.add(dirtyObject);
				}
			}
		}

		for (CDOID id : detachedOIDs) {
			InternalCDOObject detachedObject = removeObject(id);
			if (detachedObject != null) {
				CDOStateMachine.INSTANCE.detachRemote(detachedObject);
				detachedObjects.add(detachedObject);
				if (detachedObject.cdoConflict()) {
					if (conflicts == null) {
						conflicts = new HashSet<CDOObject>();
					}

					conflicts.add(detachedObject);
				}
			}
		}

		return conflicts;
	}

	/**
	 * @since 2.0
	 */
	private void fireInvalidationEvent(long timeStamp,
			Set<? extends CDOObject> dirtyObjects,
			Set<? extends CDOObject> detachedObjects) {
		if (!dirtyObjects.isEmpty() || !detachedObjects.isEmpty()) {
			IListener[] listeners = getListeners();
			if (listeners != null) {
				fireEvent(new InvalidationEvent(timeStamp, dirtyObjects,
						detachedObjects), listeners);
			}
		}
	}

	public void fireAdaptersNotifiedEvent(long timeStamp) {
		fireEvent(new AdaptersNotifiedEvent(timeStamp));
	}

	/**
	 * @since 2.0
	 */
	public void handleChangeSubscription(Collection<CDORevisionDelta> deltas,
			Collection<CDOID> detachedObjects) {
		boolean policiesPresent = options().hasChangeSubscriptionPolicies();
		if (!policiesPresent) {
			return;
		}

		if (deltas != null) {
			CDONotificationBuilder builder = new CDONotificationBuilder();
			for (CDORevisionDelta delta : deltas) {
				InternalCDOObject object = changeSubscriptionManager
						.getSubcribeObject(delta.getID());
				if (object != null && object.eNotificationRequired()) {
					NotificationImpl notification = builder.buildNotification(
							object, delta);
					if (notification != null) {
						notification.dispatch();
					}
				}
			}
		}

		if (detachedObjects != null) {
			for (CDOID id : detachedObjects) {
				InternalCDOObject object = changeSubscriptionManager
						.getSubcribeObject(id);
				if (object != null && object.eNotificationRequired()) {
					NotificationImpl notification = new CDODeltaNotificationImpl(
							object, CDONotification.DETACH_OBJECT,
							Notification.NO_FEATURE_ID, null, null);
					notification.dispatch();
				}
			}

			getChangeSubscriptionManager().handleDetachedObjects(
					detachedObjects);
		}
	}

	/**
	 * @since 2.0
	 */
	protected ChangeSubscriptionManager createChangeSubscriptionManager() {
		return new ChangeSubscriptionManager(this);
	}

	/**
	 * @since 2.0
	 */
	public AdapterManager getAdapterManager() {
		return adapterPolicyManager;
	}

	/**
	 * @since 2.0
	 */
	protected AdapterManager createAdapterManager() {
		return new AdapterManager();
	}

	/**
	 * @since 2.0
	 */
	public void handleAddAdapter(InternalCDOObject eObject, Adapter adapter) {
		if (!FSMUtil.isNew(eObject)) {
			subscribe(eObject, adapter);
		}

		adapterPolicyManager.attachAdapter(eObject, adapter);
	}

	/**
	 * @since 2.0
	 */
	public void handleRemoveAdapter(InternalCDOObject eObject, Adapter adapter) {
		if (!FSMUtil.isNew(eObject)) {
			unsubscribe(eObject, adapter);
		}

		adapterPolicyManager.detachAdapter(eObject, adapter);
	}

	/**
	 * @since 2.0
	 */
	public void subscribe(EObject eObject, Adapter adapter) {
		changeSubscriptionManager.subscribe(eObject, adapter);
	}

	/**
	 * @since 2.0
	 */
	public void unsubscribe(EObject eObject, Adapter adapter) {
		changeSubscriptionManager.unsubscribe(eObject, adapter);
	}

	/**
	 * @since 2.0
	 */
	public boolean hasSubscription(CDOID id) {
		return changeSubscriptionManager.getSubcribeObject(id) != null;
	}

	/**
	 * @since 2.0
	 */
	protected ChangeSubscriptionManager getChangeSubscriptionManager() {
		return changeSubscriptionManager;
	}

	/**
	 * Needed for {@link CDOAuditImpl#setTimeStamp(long)}.
	 * 
	 * @since 2.0
	 */
	protected List<InternalCDOObject> getInvalidObjects(long timeStamp) {
		List<InternalCDOObject> result = new ArrayList<InternalCDOObject>();
		synchronized (objects) {
			for (InternalCDOObject object : objects.values()) {
				CDORevision revision = object.cdoRevision();
				if (revision == null) {
					revision = getRevision(object.cdoID(), false);
				}

				if (revision == null || !revision.isValid(timeStamp)) {
					result.add(object);
				}
			}
		}

		return result;
	}

	public int reload(CDOObject... objects) {
		Collection<InternalCDOObject> internalObjects;
		// TODO Should objects.length == 0 reload *all* objects, too?
		if (objects != null && objects.length != 0) {
			internalObjects = new ArrayList<InternalCDOObject>(objects.length);
			for (CDOObject object : objects) {
				if (object instanceof InternalCDOObject) {
					internalObjects.add((InternalCDOObject) object);
				}
			}
		} else {
			synchronized (this.objects) {
				internalObjects = new ArrayList<InternalCDOObject>(this.objects
						.values());
			}
		}

		int result = internalObjects.size();
		if (result != 0) {
			CDOStateMachine.INSTANCE.reload(internalObjects
					.toArray(new InternalCDOObject[result]));
		}

		return result;
	}

	public void close() {
		LifecycleUtil.deactivate(this, OMLogger.Level.DEBUG);
	}

	/**
	 * @since 2.0
	 */
	public boolean isClosed() {
		return !isActive();
	}

	@Override
	public String toString() {
		return MessageFormat.format("CDOView({0})", viewID); //$NON-NLS-1$
	}

	public boolean isAdapterForType(Object type) {
		return type instanceof ResourceSet;
	}

	public org.eclipse.emf.common.notify.Notifier getTarget() {
		return getResourceSet();
	}

	public void getCDOIDAndVersion(Map<CDOID, CDOIDAndVersion> uniqueObjects,
			Collection<? extends CDOObject> cdoObjects) {
		for (CDOObject internalCDOObject : cdoObjects) {
			CDORevision cdoRevision = CDOStateMachine.INSTANCE
					.readNoLoad((InternalCDOObject) internalCDOObject);
			CDOID cdoId = internalCDOObject.cdoID();
			if (cdoRevision != null && !uniqueObjects.containsKey(cdoId)) {
				int version = cdoRevision.getVersion();
				uniqueObjects.put(cdoId, CDOIDUtil.createIDAndVersion(cdoId,
						version));
			}
		}
	}

	/**
	 * @since 2.0
	 */
	protected OptionsImpl createOptions() {
		return new OptionsImpl();
	}

	/**
	 * @since 2.0
	 */
	@Override
	protected void doBeforeActivate() throws Exception {
		super.doBeforeActivate();
		checkState(session, "session"); //$NON-NLS-1$
		checkState(viewID > 0, "viewID"); //$NON-NLS-1$
	}

	/**
	 * @since 2.0
	 */
	@Override
	protected void doActivate() throws Exception {
		session.getSessionProtocol().openView(getViewID(), getViewType(),
				getTimeStamp());
	}

	/**
	 * @since 2.0
	 */
	@Override
	protected void doDeactivate() throws Exception {
		try {
			session.getSessionProtocol().closeView(getViewID());
		} catch (Exception ex) {
			OM.LOG.error(ex);
		}

		try {
			session.viewDetached(this);
		} catch (Exception ex) {
			OM.LOG.error(ex);
		}

		session = null;
		objects = null;
		store = null;
		viewSet = null;
		changeSubscriptionManager = null;
		featureAnalyzer = null;
		lastLookupID = null;
		lastLookupObject = null;
		options = null;
	}

	/**
	 * @author Eike Stepper
	 */
	protected abstract class Event extends org.eclipse.net4j.util.event.Event
			implements CDOViewEvent {
		private static final long serialVersionUID = 1L;

		public Event() {
			super(CDOViewImpl.this);
		}

		@Override
		public CDOViewImpl getSource() {
			return (CDOViewImpl) super.getSource();
		}
	}

	/**
	 * @author Simon McDuff
	 * @since 2.0
	 */
	protected class AdapterManager {
		private Set<CDOObject> objects = new HashBag<CDOObject>();

		public void committedTransaction(CDOTransaction transaction,
				CDOCommitContext commitContext) {
			if (options().getStrongReferencePolicy() != CDOAdapterPolicy.NONE) {
				for (CDOObject object : commitContext.getNewObjects().values()) {
					attachObject(object);
				}

				for (CDOObject object : commitContext.getNewResources()
						.values()) {
					attachObject(object);
				}

				for (CDOObject object : commitContext.getDetachedObjects()
						.values()) {
					detachObject(object);
				}
			}
		}

		protected synchronized void attachObject(CDOObject object) {
			if (((InternalEObject) object).eNotificationRequired()) {
				CDOAdapterPolicy strongReferencePolicy = options()
						.getStrongReferencePolicy();
				int count = 0;
				for (Adapter adapter : object.eAdapters()) {
					if (strongReferencePolicy.isValid(object, adapter)) {
						count++;
					}
				}

				for (int i = 0; i < count; i++) {
					objects.add(object);
				}
			}
		}

		protected synchronized void detachObject(CDOObject object) {
			while (objects.remove(object)) {
				// Do nothing
			}
		}

		protected synchronized void attachAdapter(CDOObject object,
				Adapter adapter) {
			if (options().getStrongReferencePolicy().isValid(object, adapter)) {
				objects.add(object);
			}
		}

		protected synchronized void detachAdapter(CDOObject object,
				Adapter adapter) {
			if (options().getStrongReferencePolicy().isValid(object, adapter)) {
				objects.add(object);
			}
		}

		public synchronized void reset() {
			// Keep the object in memory
			Set<CDOObject> oldObject = objects;
			objects = new HashBag<CDOObject>();
			if (options().getStrongReferencePolicy() != CDOAdapterPolicy.NONE) {
				InternalCDOObject objects[] = getObjectsArray();
				for (int i = 0; i < objects.length; i++) {
					InternalCDOObject object = objects[i];
					attachObject(object);
				}
			}

			oldObject.clear();
		}
	};

	/**
	 * @author Simon McDuff
	 * @since 2.0
	 */
	protected static class ChangeSubscriptionManager {
		private CDOViewImpl view;

		private Map<CDOID, SubscribeEntry> subscriptions = new HashMap<CDOID, SubscribeEntry>();

		public ChangeSubscriptionManager(CDOViewImpl view) {
			this.view = view;
		}

		public void committedTransaction(CDOTransaction transaction,
				CDOCommitContext commitContext) {
			handleNewObjects(commitContext.getNewResources().values());
			handleNewObjects(commitContext.getNewObjects().values());
			handleDetachedObjects(commitContext.getDetachedObjects().keySet());
		}

		public void subscribe(EObject eObject, Adapter adapter) {
			subscribe(eObject, adapter, 1);
		}

		public void unsubscribe(EObject eObject, Adapter adapter) {
			subscribe(eObject, adapter, -1);
		}

		/**
		 * Register to the server all objects from the active list
		 */
		protected void notifyChangeSubcriptionPolicy() {
			boolean policiesPresent = view.options()
					.hasChangeSubscriptionPolicies();
			synchronized (subscriptions) {
				subscriptions.clear();
				List<CDOID> cdoIDs = new ArrayList<CDOID>();
				if (policiesPresent) {
					for (InternalCDOObject cdoObject : view.getObjectsArray()) {
						int count = getNumberOfValidAdapter(cdoObject);
						if (count > 0) {
							cdoIDs.add(cdoObject.cdoID());
							addEntry(cdoObject.cdoID(), cdoObject, count);
						}
					}
				}

				request(cdoIDs, true, true);
			}
		}

		protected void handleDetachedObjects(Collection<CDOID> detachedObjects) {
			synchronized (subscriptions) {
				for (CDOID id : detachedObjects) {
					SubscribeEntry entry = subscriptions.get(id);
					if (entry != null) {
						detachObject(id);
					}
				}
			}
		}

		protected void handleNewObjects(
				Collection<? extends CDOObject> newObjects) {
			synchronized (subscriptions) {
				for (CDOObject object : newObjects) {
					InternalCDOObject cdoDetachedObject = (InternalCDOObject) object;
					if (cdoDetachedObject != null) {
						int count = getNumberOfValidAdapter(cdoDetachedObject);
						if (count > 0) {
							subscribe(cdoDetachedObject.cdoID(),
									cdoDetachedObject, count);
						}
					}
				}
			}
		}

		protected InternalCDOObject getSubcribeObject(CDOID id) {
			synchronized (subscriptions) {
				SubscribeEntry entry = subscriptions.get(id);
				if (entry != null) {
					return entry.getObject();
				}
			}

			return null;
		}

		protected void request(List<CDOID> ids, boolean clear,
				boolean subscribeMode) {
			view.session.getSessionProtocol().changeSubscription(
					view.getViewID(), ids, subscribeMode, clear);
		}

		protected int getNumberOfValidAdapter(InternalCDOObject object) {
			int count = 0;
			if (!FSMUtil.isTransient(object) && !FSMUtil.isNew(object)) {
				if (object.eNotificationRequired()) {
					for (Adapter adapter : object.eAdapters()) {
						if (shouldSubscribe(object, adapter)) {
							count++;
						}
					}
				}
			}

			return count;
		}

		private void subscribe(EObject eObject, Adapter adapter, int adjust) {
			synchronized (subscriptions) {
				if (shouldSubscribe(eObject, adapter)) {
					InternalCDOObject internalCDOObject = FSMUtil.adapt(
							eObject, view);
					if (internalCDOObject.cdoView() != view) {
						throw new CDOException(
								MessageFormat
										.format(
												Messages
														.getString("CDOViewImpl.27"), internalCDOObject)); //$NON-NLS-1$
					}

					subscribe(internalCDOObject.cdoID(), internalCDOObject,
							adjust);
				}
			}
		}

		private boolean shouldSubscribe(EObject eObject, Adapter adapter) {
			for (CDOAdapterPolicy policy : view.options()
					.getChangeSubscriptionPolicies()) {
				if (policy.isValid(eObject, adapter)) {
					return true;
				}
			}

			return false;
		}

		private void subscribe(CDOID id, InternalCDOObject cdoObject, int adjust) {
			boolean policiesPresent = view.options()
					.hasChangeSubscriptionPolicies();
			synchronized (subscriptions) {
				int count = 0;
				SubscribeEntry entry = subscriptions.get(id);
				if (entry == null) {
					// Cannot adjust negative value
					if (adjust < 0) {
						return;
					}

					// Notification need to be enable to send correct value to
					// the server
					if (policiesPresent) {
						request(Collections.singletonList(id), false, true);
					}
				} else {
					count = entry.getCount();
				}

				count += adjust;

				// Look if objects need to be unsubscribe
				if (count <= 0) {
					subscriptions.remove(id);

					// Notification need to be enable to send correct value to
					// the server
					if (policiesPresent) {
						request(Collections.singletonList(id), false, false);
					}
				} else {
					if (entry == null) {
						addEntry(id, cdoObject, count);
					} else {
						entry.setCount(count);
					}
				}
			}
		}

		private void detachObject(CDOID id) {
			subscribe(id, null, Integer.MIN_VALUE);
		}

		private void addEntry(CDOID key, InternalCDOObject object, int count) {
			subscriptions.put(key, new SubscribeEntry(object, count));
		}

		/**
		 * @author Eike Stepper
		 */
		protected static final class SubscribeEntry {
			private int count;

			private InternalCDOObject object;

			public SubscribeEntry(InternalCDOObject object, int count) {
				this.count = count;
				this.object = object;
			}

			public InternalCDOObject getObject() {
				return object;
			}

			public int getCount() {
				return count;
			}

			public void setCount(int count) {
				this.count = count;
			}
		}
	}

	/**
	 * @author Simon McDuff
	 */
	private final class InvalidationEvent extends Event implements
			CDOViewInvalidationEvent {
		private static final long serialVersionUID = 1L;

		private long timeStamp;

		private Set<? extends CDOObject> dirtyObjects;

		private Set<? extends CDOObject> detachedObjects;

		public InvalidationEvent(long timeStamp,
				Set<? extends CDOObject> dirtyOIDs,
				Set<? extends CDOObject> detachedObjects) {
			this.timeStamp = timeStamp;
			dirtyObjects = dirtyOIDs;
			this.detachedObjects = detachedObjects;
		}

		public long getTimeStamp() {
			return timeStamp;
		}

		public Set<? extends CDOObject> getDirtyObjects() {
			return dirtyObjects;
		}

		public Set<? extends CDOObject> getDetachedObjects() {
			return detachedObjects;
		}

		@Override
		public String toString() {
			return "CDOViewInvalidationEvent: " + dirtyObjects; //$NON-NLS-1$
		}
	}

	/**
	 * @author Eike Stepper
	 */
	private final class AdaptersNotifiedEvent extends Event implements
			CDOViewAdaptersNotifiedEvent {
		private static final long serialVersionUID = 1L;

		private long timeStamp;

		public AdaptersNotifiedEvent(long timeStamp) {
			this.timeStamp = timeStamp;
		}

		public long getTimeStamp() {
			return timeStamp;
		}

		@Override
		public String toString() {
			return "CDOViewAdaptersNotifiedEvent: " + timeStamp; //$NON-NLS-1$
		}
	}

	/**
	 * @author Eike Stepper
	 * @since 2.0
	 */
	protected class OptionsImpl extends Notifier implements Options {
		private boolean invalidationNotificationEnabled;

		private CDORevisionPrefetchingPolicy revisionPrefetchingPolicy;

		private CDOStaleReferencePolicy staleReferencePolicy = CDOStaleReferencePolicy.EXCEPTION;

		private HashBag<CDOAdapterPolicy> changeSubscriptionPolicies = new HashBag<CDOAdapterPolicy>();

		private CDOAdapterPolicy strongReferencePolicy = CDOAdapterPolicy.ALL;

		public OptionsImpl() {
			setCacheReferenceType(null);
			invalidationNotificationEnabled = OM.PREF_ENABLE_INVALIDATION_NOTIFICATION
					.getValue();
			revisionPrefetchingPolicy = CDOUtil
					.createRevisionPrefetchingPolicy(OM.PREF_REVISION_LOADING_CHUNK_SIZE
							.getValue());
		}

		public CDOViewImpl getContainer() {
			return CDOViewImpl.this;
		}

		public boolean isInvalidationNotificationEnabled() {
			return invalidationNotificationEnabled;
		}

		public void setInvalidationNotificationEnabled(boolean enabled) {
			if (invalidationNotificationEnabled != enabled) {
				invalidationNotificationEnabled = enabled;
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new InvalidationNotificationEventImpl(),
							listeners);
				}
			}
		}

		public boolean hasChangeSubscriptionPolicies() {
			synchronized (changeSubscriptionPolicies) {
				return !changeSubscriptionPolicies.isEmpty();
			}
		}

		public CDOAdapterPolicy[] getChangeSubscriptionPolicies() {
			synchronized (changeSubscriptionPolicies) {
				return changeSubscriptionPolicies
						.toArray(new CDOAdapterPolicy[changeSubscriptionPolicies
								.size()]);
			}
		}

		public void addChangeSubscriptionPolicy(CDOAdapterPolicy policy) {
			boolean changed = false;
			synchronized (changeSubscriptionPolicies) {
				if (changeSubscriptionPolicies.add(policy)) {
					changeSubscriptionManager.notifyChangeSubcriptionPolicy();
					changed = true;
				}
			}

			if (changed) {
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new ChangeSubscriptionPoliciesEventImpl(),
							listeners);
				}
			}
		}

		public void removeChangeSubscriptionPolicy(CDOAdapterPolicy policy) {
			boolean changed = false;
			synchronized (changeSubscriptionPolicies) {
				if (changeSubscriptionPolicies.remove(policy)
						&& !changeSubscriptionPolicies.contains(policy)) {
					changeSubscriptionManager.notifyChangeSubcriptionPolicy();
					changed = true;
				}
			}

			if (changed) {
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new ChangeSubscriptionPoliciesEventImpl(),
							listeners);
				}
			}
		}

		public CDOAdapterPolicy getStrongReferencePolicy() {
			return strongReferencePolicy;
		}

		public void setStrongReferencePolicy(CDOAdapterPolicy adapterPolicy) {
			if (adapterPolicy == null) {
				adapterPolicy = CDOAdapterPolicy.ALL;
			}

			if (strongReferencePolicy != adapterPolicy) {
				strongReferencePolicy = adapterPolicy;
				adapterPolicyManager.reset();
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new ReferencePolicyEventImpl(), listeners);
				}
			}
		}

		public CDORevisionPrefetchingPolicy getRevisionPrefetchingPolicy() {
			return revisionPrefetchingPolicy;
		}

		public void setRevisionPrefetchingPolicy(
				CDORevisionPrefetchingPolicy prefetchingPolicy) {
			if (prefetchingPolicy == null) {
				prefetchingPolicy = CDORevisionPrefetchingPolicy.NO_PREFETCHING;
			}

			if (revisionPrefetchingPolicy != prefetchingPolicy) {
				revisionPrefetchingPolicy = prefetchingPolicy;
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new RevisionPrefetchingPolicyEventImpl(),
							listeners);
				}
			}
		}

		public CDOStaleReferencePolicy getStaleReferenceBehaviour() {
			return staleReferencePolicy;
		}

		public void setStaleReferenceBehaviour(CDOStaleReferencePolicy policy) {
			if (policy == null) {
				policy = CDOStaleReferencePolicy.EXCEPTION;
			}

			if (staleReferencePolicy != policy) {
				staleReferencePolicy = policy;
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new StaleReferencePolicyEventImpl(), listeners);
				}
			}
		}

		public ReferenceType getCacheReferenceType() {
			if (objects instanceof ReferenceValueMap.Strong<?, ?>) {
				return ReferenceType.STRONG;
			}

			if (objects instanceof ReferenceValueMap.Soft<?, ?>) {
				return ReferenceType.SOFT;
			}

			if (objects instanceof ReferenceValueMap.Weak<?, ?>) {
				return ReferenceType.WEAK;
			}

			throw new IllegalStateException(Messages
					.getString("CDOViewImpl.29")); //$NON-NLS-1$
		}

		public boolean setCacheReferenceType(ReferenceType referenceType) {
			if (referenceType == null) {
				referenceType = ReferenceType.SOFT;
			}

			ReferenceValueMap<CDOID, InternalCDOObject> newObjects;
			switch (referenceType) {
			case STRONG:
				if (objects instanceof ReferenceValueMap.Strong<?, ?>) {
					return false;
				}

				newObjects = new ReferenceValueMap.Strong<CDOID, InternalCDOObject>();
				break;

			case SOFT:
				if (objects instanceof ReferenceValueMap.Soft<?, ?>) {
					return false;
				}

				newObjects = new ReferenceValueMap.Soft<CDOID, InternalCDOObject>();
				break;

			case WEAK:
				if (objects instanceof ReferenceValueMap.Weak<?, ?>) {
					return false;
				}

				newObjects = new ReferenceValueMap.Weak<CDOID, InternalCDOObject>();
				break;

			default:
				throw new IllegalArgumentException(Messages
						.getString("CDOViewImpl.29")); //$NON-NLS-1$
			}

			if (objects == null) {
				objects = newObjects;
				IListener[] listeners = getListeners();
				if (listeners != null) {
					fireEvent(new CacheReferenceTypeEventImpl(), listeners);
				}

				return true;
			}

			for (Entry<CDOID, InternalCDOObject> entry : objects.entrySet()) {
				InternalCDOObject object = entry.getValue();
				if (object != null) {
					newObjects.put(entry.getKey(), object);
				}
			}

			ConcurrentMap<CDOID, InternalCDOObject> oldObjects = objects;
			synchronized (objects) {
				objects = newObjects;
			}

			oldObjects.clear();
			IListener[] listeners = getListeners();
			if (listeners != null) {
				fireEvent(new CacheReferenceTypeEventImpl(), listeners);
			}

			return true;
		}

		/**
		 * @author Eike Stepper
		 */
		private final class CacheReferenceTypeEventImpl extends OptionsEvent
				implements CacheReferenceTypeEvent {
			private static final long serialVersionUID = 1L;

			public CacheReferenceTypeEventImpl() {
				super(OptionsImpl.this);
			}
		}

		/**
		 * @author Eike Stepper
		 */
		private final class ChangeSubscriptionPoliciesEventImpl extends
				OptionsEvent implements ChangeSubscriptionPoliciesEvent {
			private static final long serialVersionUID = 1L;

			public ChangeSubscriptionPoliciesEventImpl() {
				super(OptionsImpl.this);
			}
		}

		/**
		 * @author Eike Stepper
		 */
		private final class InvalidationNotificationEventImpl extends
				OptionsEvent implements InvalidationNotificationEvent {
			private static final long serialVersionUID = 1L;

			public InvalidationNotificationEventImpl() {
				super(OptionsImpl.this);
			}
		}

		/**
		 * @author Eike Stepper
		 */
		private final class RevisionPrefetchingPolicyEventImpl extends
				OptionsEvent implements RevisionPrefetchingPolicyEvent {
			private static final long serialVersionUID = 1L;

			public RevisionPrefetchingPolicyEventImpl() {
				super(OptionsImpl.this);
			}
		}

		/**
		 * @author Eike Stepper
		 */
		private final class ReferencePolicyEventImpl extends OptionsEvent
				implements ReferencePolicyEvent {
			private static final long serialVersionUID = 1L;

			public ReferencePolicyEventImpl() {
				super(OptionsImpl.this);
			}
		}

		/**
		 * @author Simon McDuff
		 */
		private final class StaleReferencePolicyEventImpl extends OptionsEvent
				implements StaleReferencePolicyEvent {
			private static final long serialVersionUID = 1L;

			public StaleReferencePolicyEventImpl() {
				super(OptionsImpl.this);
			}
		}
	}

	/**
	 * @author Juan Pedro Silva
	 */
	private boolean hasRegisteredListeners = false;

	/**
	 * @author Juan Pedro Silva
	 */
	protected FastList<IListener> registeredLockListeners = new FastList<IListener>() {
		@Override
		protected IListener[] newArray(int length) {
			return new IListener[length];
		}

		@Override
		protected void firstElementAdded() {
			firstListenerAdded();
		}

		@Override
		protected void lastElementRemoved() {
			lastListenerRemoved();
		}
	};

	/**
	 * @author Juan Pedro Silva
	 */
	public boolean hasRegisteredListeners() {
		return hasRegisteredListeners;
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void registerLockListeners(Collection<IListener> collToRegister) {
		for (IListener il : collToRegister) {
			registerListener(il);
		}
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void registerLockListener(IListener listenerToRegister) {
		registerListener(listenerToRegister);
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void unRegisterLockListener(IListener listenerToRegister) {
		unRegisterListener(listenerToRegister);
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void unRegisterLockListeners(Collection<IListener> collToUnregister) {
		for (IListener il : collToUnregister) {
			unRegisterListener(il);
		}
	}

	/**
	 * @author Juan Pedro Silva
	 */
	protected void registerListener(IListener listenerToRegister) {
		if (!hasRegisteredListeners) {
			hasRegisteredListeners = true;
			session.registerLockListeners(this);
		}
		registeredLockListeners.add(listenerToRegister);
	}

	/**
	 * @author Juan Pedro Silva
	 */
	protected void unRegisterListener(IListener listenerToUnRegister) {
		registeredLockListeners.remove(listenerToUnRegister);
		if (registeredLockListeners.isEmpty()) {
			hasRegisteredListeners = false;
			session.unregisterLockListeners(this);
		}
	}

	/**
	 * @author Juan Pedro Silva
	 */
	public void notifyRemoteLock(boolean b, String user,
			Collection<CDOID> cdoids, LockType lockType) {
		if (b) {
			fireEvent(new RemoteLockAcquiredEvent(user, cdoids, lockType),
					registeredLockListeners.get());
		} else {
			fireEvent(new RemoteLockReleasedEvent(user, cdoids, lockType),
					registeredLockListeners.get());
		}
	}
        if (listeners != null)
        {
          fireEvent(new StaleReferencePolicyEventImpl(), listeners);
        }
      }
    }

    public ReferenceType getCacheReferenceType()
    {
      if (objects instanceof ReferenceValueMap.Strong<?, ?>)
      {
        return ReferenceType.STRONG;
      }

      if (objects instanceof ReferenceValueMap.Soft<?, ?>)
      {
        return ReferenceType.SOFT;
      }

      if (objects instanceof ReferenceValueMap.Weak<?, ?>)
      {
        return ReferenceType.WEAK;
      }

      throw new IllegalStateException(Messages.getString("CDOViewImpl.29")); //$NON-NLS-1$
    }

    public boolean setCacheReferenceType(ReferenceType referenceType)
    {
      if (referenceType == null)
      {
        referenceType = ReferenceType.SOFT;
      }

      ReferenceValueMap<CDOID, InternalCDOObject> newObjects;
      switch (referenceType)
      {
      case STRONG:
        if (objects instanceof ReferenceValueMap.Strong<?, ?>)
        {
          return false;
        }

        newObjects = new ReferenceValueMap.Strong<CDOID, InternalCDOObject>();
        break;

      case SOFT:
        if (objects instanceof ReferenceValueMap.Soft<?, ?>)
        {
          return false;
        }

        newObjects = new ReferenceValueMap.Soft<CDOID, InternalCDOObject>();
        break;

      case WEAK:
        if (objects instanceof ReferenceValueMap.Weak<?, ?>)
        {
          return false;
        }

        newObjects = new ReferenceValueMap.Weak<CDOID, InternalCDOObject>();
        break;

      default:
        throw new IllegalArgumentException(Messages.getString("CDOViewImpl.29")); //$NON-NLS-1$
      }

      if (objects == null)
      {
        objects = newObjects;
        IListener[] listeners = getListeners();
        if (listeners != null)
        {
          fireEvent(new CacheReferenceTypeEventImpl(), listeners);
        }

        return true;
      }

      for (Entry<CDOID, InternalCDOObject> entry : objects.entrySet())
      {
        InternalCDOObject object = entry.getValue();
        if (object != null)
        {
          newObjects.put(entry.getKey(), object);
        }
      }

      ConcurrentMap<CDOID, InternalCDOObject> oldObjects = objects;
      synchronized (objects)
      {
        objects = newObjects;
      }

      oldObjects.clear();
      IListener[] listeners = getListeners();
      if (listeners != null)
      {
        fireEvent(new CacheReferenceTypeEventImpl(), listeners);
      }

      return true;
    }

    /**
     * @author Eike Stepper
     */
    private final class CacheReferenceTypeEventImpl extends OptionsEvent implements CacheReferenceTypeEvent
    {
      private static final long serialVersionUID = 1L;

      public CacheReferenceTypeEventImpl()
      {
        super(OptionsImpl.this);
      }
    }

    /**
     * @author Eike Stepper
     */
    private final class ChangeSubscriptionPoliciesEventImpl extends OptionsEvent implements
        ChangeSubscriptionPoliciesEvent
    {
      private static final long serialVersionUID = 1L;

      public ChangeSubscriptionPoliciesEventImpl()
      {
        super(OptionsImpl.this);
      }
    }

    /**
     * @author Eike Stepper
     */
    private final class InvalidationNotificationEventImpl extends OptionsEvent implements InvalidationNotificationEvent
    {
      private static final long serialVersionUID = 1L;

      public InvalidationNotificationEventImpl()
      {
        super(OptionsImpl.this);
      }
    }

    /**
     * @author Eike Stepper
     */
    private final class RevisionPrefetchingPolicyEventImpl extends OptionsEvent implements
        RevisionPrefetchingPolicyEvent
    {
      private static final long serialVersionUID = 1L;

      public RevisionPrefetchingPolicyEventImpl()
      {
        super(OptionsImpl.this);
      }
    }

    /**
     * @author Eike Stepper
     */
    private final class ReferencePolicyEventImpl extends OptionsEvent implements ReferencePolicyEvent
    {
      private static final long serialVersionUID = 1L;

      public ReferencePolicyEventImpl()
      {
        super(OptionsImpl.this);
      }
    }

    /**
     * @author Simon McDuff
     */
    private final class StaleReferencePolicyEventImpl extends OptionsEvent implements StaleReferencePolicyEvent
    {
      private static final long serialVersionUID = 1L;

      public StaleReferencePolicyEventImpl()
      {
        super(OptionsImpl.this);
      }
    }
  }
}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.view;

import org.eclipse.emf.cdo.common.id.CDOID;

import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;

import java.util.Collection;

/**
 * @author Eike Stepper
 */
public class RemoteLockEvent implements CDOViewEvent {
	private Collection<CDOID> cdoIds;
	private String user;
	private LockType lockType;

	public RemoteLockEvent(String user, Collection<CDOID> cdoIds,
			LockType lockType) {
		super();
		this.user = user;
		this.lockType = lockType;
		this.cdoIds = cdoIds;
	}

	public String getUser() {
		return user;
	}

	public LockType getLockType() {
		return lockType;
	}

	public Collection<CDOID> getCdoIds() {
		return cdoIds;
	}

	public CDOView getSource() {
		return null;
	}

}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.view;

import org.eclipse.emf.cdo.common.id.CDOID;

import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;

import java.util.Collection;

/**
 * @author Juan Pedro Silva
 */
public class RemoteLockReleasedEvent extends RemoteLockEvent {
	public RemoteLockReleasedEvent(String user, Collection<CDOID> cdoIds,
			LockType lockType) {
		super(user, cdoIds, lockType);
	}
}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.view;

import org.eclipse.emf.cdo.common.id.CDOID;

import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;

import java.util.Collection;

/**
 * @author Juan Pedro Silva
 */
public class RemoteLockAcquiredEvent extends RemoteLockEvent {

	public RemoteLockAcquiredEvent(String user, Collection<CDOID> cdoIds,
			LockType lockType) {
		super(user, cdoIds, lockType);
	}
}

Lines 288-293 Link Here

(-)src/org/eclipse/emf/cdo/internal/net4j/protocol/CDOClientProtocol.java (+24 lines)
288	case CDOProtocolConstants.SIGNAL_REMOTE_MESSAGE_NOTIFICATION:	288	case CDOProtocolConstants.SIGNAL_REMOTE_MESSAGE_NOTIFICATION:
289	return new RemoteMessageNotificationIndication(this);	289	return new RemoteMessageNotificationIndication(this);
290		290
		291	/**
		292	* @author Juan Pedro Silva
		293	*/
		294	case CDOProtocolConstants.SIGNAL_REMOTE_LOCK_CHANGED_NOTIFICATION:
		295	return new RemoteLockChangedIndication(this);
		296
		297	/** ----------------------------------------------------- */
		298
291	default:	299	default:
292	return super.createSignalReactor(signalID);	300	return super.createSignalReactor(signalID);
293	}	301	}
Lines 347-350 Link Here
347	REVISION_LOADING.stop(request);	355	REVISION_LOADING.stop(request);
348	}	356	}
349	}	357	}
		358
		359	/**
		360	* @author Juan Pedro Silva
		361	*/
		362	public void unsubscribeRemoteLocks()
		363	{
		364	send(new UnsubscribeRemoteLocksRequest(this));
		365	}
		366
		367	/**
		368	* @author Juan Pedro Silva
		369	*/
		370	public void subscribeRemoteLocks()
		371	{
		372	send(new SubscribeRemoteLocksRequest(this));
		373	}
350	}	374	}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.internal.net4j.protocol;

import org.eclipse.emf.cdo.common.io.CDODataInput;
import org.eclipse.emf.cdo.common.io.CDODataOutput;
import org.eclipse.emf.cdo.common.protocol.CDOProtocolConstants;
import org.eclipse.emf.cdo.internal.net4j.bundle.OM;

import org.eclipse.net4j.util.om.trace.ContextTracer;

import java.io.IOException;

/**
 * @author Juan Pedro Silva
 */
public class UnsubscribeRemoteLocksRequest extends CDOClientRequest<Boolean>
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG_PROTOCOL, UnsubscribeRemoteLocksRequest.class);

  public UnsubscribeRemoteLocksRequest(CDOClientProtocol protocol)
  {
    super(protocol, CDOProtocolConstants.SIGNAL_UNREGISTER_LOCK_LISTENER);
  }

  @Override
  protected void requesting(CDODataOutput out) throws IOException
  {
    if (TRACER.isEnabled())
    {
      TRACER.trace("Unsubscribing from Lock Notifications"); //$NON-NLS-1$
    }
  }

  @Override
  protected Boolean confirming(CDODataInput in) throws IOException
  {
    return in.readBoolean();
  }
}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.internal.net4j.protocol;

import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.io.CDODataInput;
import org.eclipse.emf.cdo.common.protocol.CDOProtocolConstants;
import org.eclipse.emf.cdo.internal.net4j.bundle.OM;
import org.eclipse.emf.cdo.view.CDOView;

import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
import org.eclipse.net4j.util.io.IORuntimeException;
import org.eclipse.net4j.util.om.trace.ContextTracer;

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

/**
 * @author Juan Pedro Silva
 * @see org.eclipse.emf.cdo.server.internal.net4j.protocol.LockObjectsIndication
 */
public class RemoteLockChangedIndication extends CDOClientIndication
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG_PROTOCOL, RemoteLockChangedIndication.class);

  private LockType lockType;

  private Set<CDOID> lockedObjects;

  private String user;

  private int sessionId;

  private boolean lock;

  public RemoteLockChangedIndication(CDOClientProtocol cdoClientProtocol)
  {
    super(cdoClientProtocol, CDOProtocolConstants.SIGNAL_REMOTE_LOCK_CHANGED_NOTIFICATION);
  }

  @Override
  protected void indicating(CDODataInput in) throws IOException
  {
    long timeStamp = in.readLong();
    if (TRACER.isEnabled())
    {
      TRACER.format("Read timeStamp: {0,date} {0,time}", timeStamp); //$NON-NLS-1$
    }

    int size = in.readInt();
    if (TRACER.isEnabled())
    {
      TRACER.format("Reading {0} locked IDs", size); //$NON-NLS-1$
    }

    lockedObjects = new HashSet<CDOID>();
    for (int i = 0; i < size; i++)
    {
      CDOID dirtyOID = in.readCDOID();
      if (TRACER.isEnabled())
      {
        TRACER.format("Read locked ID: {0}", dirtyOID); //$NON-NLS-1$
      }

      lockedObjects.add(dirtyOID);
    }
    lock = in.readBoolean();
    lockType = in.readCDOLockType();
    user = in.readString();
    try
    {
      for (CDOView cv : getSession().getViews())
      {
        if (cv.hasListeners())
        {
          cv.notifyRemoteLock(lock, user, lockedObjects, lockType);
        }
      }
    }
    catch (Exception ex) // Interrupted
    {
      throw new IORuntimeException(ex);
    }
  }
}




/**
 /**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.internal.net4j.protocol;

import org.eclipse.emf.cdo.common.io.CDODataInput;
import org.eclipse.emf.cdo.common.io.CDODataOutput;
import org.eclipse.emf.cdo.common.protocol.CDOProtocolConstants;
import org.eclipse.emf.cdo.internal.net4j.bundle.OM;

import org.eclipse.net4j.util.om.trace.ContextTracer;

import java.io.IOException;

/**
 * @author Juan Pedro Silva
 */
public class SubscribeRemoteLocksRequest extends CDOClientRequest<Boolean>
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG_PROTOCOL, SubscribeRemoteLocksRequest.class);

  public SubscribeRemoteLocksRequest(CDOClientProtocol protocol)
  {
    super(protocol, CDOProtocolConstants.SIGNAL_REGISTER_LOCK_LISTENER);
  }

  @Override
  protected void requesting(CDODataOutput out) throws IOException
  {
    if (TRACER.isEnabled())
    {
      TRACER.trace("Subscribing to Lock Notifications"); //$NON-NLS-1$
    }
  }

  @Override
  protected Boolean confirming(CDODataInput in) throws IOException
  {
    return in.readBoolean();
  }
}





    return result;
  }

  /**
   * @author Juan Pedro Silva
   */
  public void subscribeRemoteLocks()
  {
    throw new UnsupportedOperationException();
  }

  /**
   * @author Juan Pedro Silva
   */
  public void unsubscribeRemoteLocks()
  {
    throw new UnsupportedOperationException();
  }
}

Lines 21-29 Link Here

(-)src/org/eclipse/emf/cdo/internal/server/embedded/EmbeddedServerSessionProtocol.java (+13 lines)
21	import org.eclipse.emf.cdo.spi.server.InternalRepository;	21	import org.eclipse.emf.cdo.spi.server.InternalRepository;
22	import org.eclipse.emf.cdo.spi.server.InternalSession;	22	import org.eclipse.emf.cdo.spi.server.InternalSession;
23		23
		24	import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
24	import org.eclipse.net4j.util.lifecycle.Lifecycle;	25	import org.eclipse.net4j.util.lifecycle.Lifecycle;
25		26
26	import java.util.Arrays;	27	import java.util.Arrays;
		28	import java.util.Collection;
27	import java.util.HashSet;	29	import java.util.HashSet;
28	import java.util.List;	30	import java.util.List;
29		31
Lines 77-84 Link Here
77	throw new UnsupportedOperationException();	79	throw new UnsupportedOperationException();
78	}	80	}
79		81
		82	/**
		83	* @author Juan Pedro Silva
		84	*/
80	public boolean sendRemoteMessageNotification(InternalSession sender, CDORemoteSessionMessage message)	85	public boolean sendRemoteMessageNotification(InternalSession sender, CDORemoteSessionMessage message)
81	{	86	{
82	throw new UnsupportedOperationException();	87	throw new UnsupportedOperationException();
83	}	88	}
		89
		90	/**
		91	* @author Juan Pedro Silva
		92	*/
		93	public void sendRemoteLockNotification(boolean b, String user, Collection<CDOID> cdoids, LockType lockType)
		94	{
		95	throw new UnsupportedOperationException();
		96	}
84	}	97	}




import org.eclipse.emf.cdo.spi.server.InternalView;

import org.eclipse.net4j.util.ReflectUtil.ExcludeFromDump;
import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
import org.eclipse.net4j.util.container.Container;
import org.eclipse.net4j.util.event.EventUtil;
import org.eclipse.net4j.util.event.IListener;


import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;

    manager = null;
    super.doDeactivate();
  }

  /**
   * @author Juan Pedro Silva
   */
  public void notifyRemoteLock(boolean b, String user, Collection<CDOID> cdoids, LockType lockType)
  {
    getProtocol().sendRemoteLockNotification(b, user, cdoids, lockType);
  }
}

Lines 24-29 Link Here

(-)src/org/eclipse/emf/cdo/internal/server/LockManager.java (+39 lines)
24	import org.eclipse.net4j.util.container.IContainer;	24	import org.eclipse.net4j.util.container.IContainer;
25	import org.eclipse.net4j.util.event.IListener;	25	import org.eclipse.net4j.util.event.IListener;
26		26
		27	import java.util.Collection;
		28
27	/**	29	/**
28	* @author Simon McDuff	30	* @author Simon McDuff
29	* @since 3.0	31	* @since 3.0
Lines 91-94 Link Here
91		93
92	super.doDeactivate();	94	super.doDeactivate();
93	}	95	}
		96
		97	/**
		98	* @author Juan Pedro Silva
		99	* @param lock
		100	* : True = Lock, false = Unlock
		101	*/
		102	@Override
		103	protected void notifyRemoteLockChanged(boolean b, IView sender, Collection<? extends CDOID> cdoids, LockType lockType)
		104	{
		105	for (Object il : registeredLockListeners)
		106	{
		107	ISession is = (ISession)il;
		108	is.notifyRemoteLock(b, sender.getSession().getUserID(), (Collection<CDOID>)cdoids, lockType);
		109	}
		110	}
		111
		112	/**
		113	* @author Juan Pedro Silva
		114	*/
		115	@Override
		116	protected void registerListener(Object listenerToRegister)
		117	{
		118	registeredLockListeners.add(listenerToRegister);
		119	}
		120
		121	/**
		122	* @author Juan Pedro Silva
		123	*/
		124	@Override
		125	protected void unRegisterListener(Object listenerToRegister)
		126	{
		127	registeredLockListeners.remove(listenerToRegister);
		128	if (registeredLockListeners.isEmpty())
		129	{
		130	hasListenerRegistered = false;
		131	}
		132	}
94	}	133	}

Lines 12-21 Link Here

(-)src/org/eclipse/emf/cdo/server/ISession.java (+16 lines)
12	package org.eclipse.emf.cdo.server;	12	package org.eclipse.emf.cdo.server;
13		13
14	import org.eclipse.emf.cdo.common.CDOCommonSession;	14	import org.eclipse.emf.cdo.common.CDOCommonSession;
		15	import org.eclipse.emf.cdo.common.id.CDOID;
15	import org.eclipse.emf.cdo.spi.server.ISessionProtocol;	16	import org.eclipse.emf.cdo.spi.server.ISessionProtocol;
16		17
		18	import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
17	import org.eclipse.net4j.util.container.IContainer;	19	import org.eclipse.net4j.util.container.IContainer;
18		20
		21	import java.util.Collection;
		22
19	/**	23	/**
20	* @author Eike Stepper	24	* @author Eike Stepper
21	*/	25	*/
Lines 50-53 Link Here
50	* @since 2.0	54	* @since 2.0
51	*/	55	*/
52	public ITransaction openTransaction(int viewID);	56	public ITransaction openTransaction(int viewID);
		57
		58	/**
		59	* @author Juan Pedro Silva
		60	*/
		61	public String getUserID();
		62
		63	/**
		64	* @author Juan Pedro Silva
		65	* @param lock
		66	* : True = Lock, false = Unlock
		67	*/
		68	public void notifyRemoteLock(boolean b, String user, Collection<CDOID> cdoids, LockType lockType);
53	}	69	}

Lines 19-24 Link Here

(-)src/org/eclipse/emf/cdo/spi/server/ISessionProtocol.java (+8 lines)
19	import org.eclipse.emf.cdo.server.ISession;	19	import org.eclipse.emf.cdo.server.ISession;
20	import org.eclipse.emf.cdo.session.remote.CDORemoteSessionMessage;	20	import org.eclipse.emf.cdo.session.remote.CDORemoteSessionMessage;
21		21
		22	import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
		23
		24	import java.util.Collection;
22	import java.util.List;	25	import java.util.List;
23		26
24	/**	27	/**
Lines 35-38 Link Here
35	public void sendRemoteSessionNotification(byte opcode, ISession session);	38	public void sendRemoteSessionNotification(byte opcode, ISession session);
36		39
37	public boolean sendRemoteMessageNotification(InternalSession sender, CDORemoteSessionMessage message);	40	public boolean sendRemoteMessageNotification(InternalSession sender, CDORemoteSessionMessage message);
		41
		42	/**
		43	* @author Juan Pedro Silva
		44	*/
		45	public void sendRemoteLockNotification(boolean b, String user, Collection<CDOID> cdoids, LockType lockType);
38	}	46	}

Lines 19-24 Link Here

(-)src/org/eclipse/net4j/util/concurrent/RWLockManager.java (+82 lines)
19	import java.util.Collection;	19	import java.util.Collection;
20	import java.util.Collections;	20	import java.util.Collections;
21	import java.util.HashMap;	21	import java.util.HashMap;
		22	import java.util.HashSet;
22	import java.util.List;	23	import java.util.List;
23	import java.util.Map;	24	import java.util.Map;
24	import java.util.Set;	25	import java.util.Set;
Lines 94-99 Link Here
94		95
95	private Object lockChanged = new Object();	96	private Object lockChanged = new Object();
96		97
		98	protected boolean hasListenerRegistered;
		99
		100	protected Set<Object> registeredLockListeners = new HashSet<Object>();
		101
97	/**	102	/**
98	* @since 3.0	103	* @since 3.0
99	*/	104	*/
Lines 101-106 Link Here
101	throws InterruptedException	106	throws InterruptedException
102	{	107	{
103	lock(getLockingStrategy(type), context, objectsToLock, timeout);	108	lock(getLockingStrategy(type), context, objectsToLock, timeout);
		109	notifyRemoteLockChanged(true, context, objectsToLock, type);
104	}	110	}
105		111
106	/**	112	/**
Lines 121-126 Link Here
121	public void unlock(LockType type, V context, Collection<? extends K> objectsToUnlock)	127	public void unlock(LockType type, V context, Collection<? extends K> objectsToUnlock)
122	{	128	{
123	unlock(getLockingStrategy(type), context, objectsToUnlock);	129	unlock(getLockingStrategy(type), context, objectsToUnlock);
		130	notifyRemoteLockChanged(false, context, objectsToUnlock, type);
124	}	131	}
125		132
126	/**	133	/**
Lines 635-638 Link Here
635	throw new UnsupportedOperationException();	642	throw new UnsupportedOperationException();
636	}	643	}
637	}	644	}
		645
		646	/**
		647	* @author Juan Pedro Silva
		648	*/
		649	public void registerLockListeners(Collection<Object> collToRegister)
		650	{
		651	for (Object il : collToRegister)
		652	{
		653	registerListener(il);
		654	}
		655	}
		656
		657	/**
		658	* @author Juan Pedro Silva
		659	*/
		660	public void registerLockListener(Object listenerToRegister)
		661	{
		662	registerListener(listenerToRegister);
		663	}
		664
		665	/**
		666	* @author Juan Pedro Silva
		667	*/
		668	public void unRegisterLockListener(Object listenerToRegister)
		669	{
		670	unRegisterListener(listenerToRegister);
		671	}
		672
		673	/**
		674	* @author Juan Pedro Silva
		675	*/
		676	public void unRegisterLockListeners(Collection<Object> collToUnregister)
		677	{
		678	for (Object il : collToUnregister)
		679	{
		680	unRegisterListener(il);
		681	}
		682	}
		683
		684	/**
		685	* @author Juan Pedro Silva
		686	*/
		687	public boolean hasListenerRegistered()
		688	{
		689	return hasListenerRegistered;
		690	}
		691
		692	/**
		693	* @author Juan Pedro Silva
		694	*/
		695	protected void registerListener(Object listenerToRegister)
		696	{
		697	registeredLockListeners.add(listenerToRegister);
		698	}
		699
		700	/**
		701	* @author Juan Pedro Silva
		702	*/
		703	protected void unRegisterListener(Object listenerToRegister)
		704	{
		705	registeredLockListeners.remove(listenerToRegister);
		706	if (registeredLockListeners.isEmpty())
		707	{
		708	hasListenerRegistered = false;
709	}
710	}
711
712	/**
713	* @author Juan Pedro Silva
714	* @param lock
715	* : True = Lock, false = Unlock
716	*/
717	protected void notifyRemoteLockChanged(boolean b, V context, Collection<? extends K> cdoids, LockType lockType)
718	{
719	}
638	}	720	}




  public boolean hasLockByOthers(LockType type, V context, K objectToLock);

  /**
   * @author Juan Pedro Silva
   */
  public void registerLockListeners(Collection<Object> collToRegister);

  /**
   * @author Juan Pedro Silva
   */
  public void registerLockListener(Object listenerToRegister);

  /**
   * @author Juan Pedro Silva
   */
  public void unRegisterLockListener(Object listenerToRegister);

  /**
   * @author Juan Pedro Silva
   */
  public void unRegisterLockListeners(Collection<Object> collToUnregister);

  /**
   * @author Juan Pedro Silva
   */
  public boolean hasListenerRegistered();

  /**
   * @author Simon McDuff
   */
  public static enum LockType




          fireDirtyPropertyChange();
        }
      };

      /**
       *@author Juan Pedro Silva
       *@see I don't like this registration here. I rather have it under an option, which is the proper place. However,
       *      this is currently the way I'm using to be sure eventHandler's listeners have been registered.
       *@TODO: Make the registration optional.
       */
      CDOView lm = getView();
      lm.registerLockListeners(eventHandler.getLockListeners());

    }
    catch (RuntimeException ex)
    {

Lines 13-18 Link Here

(-)src/org/eclipse/emf/cdo/ui/CDOEventHandler.java (+66 lines)
13	package org.eclipse.emf.cdo.ui;	13	package org.eclipse.emf.cdo.ui;
14		14
15	import org.eclipse.emf.cdo.CDOObject;	15	import org.eclipse.emf.cdo.CDOObject;
		16	import org.eclipse.emf.cdo.common.id.CDOID;
16	import org.eclipse.emf.cdo.internal.ui.ItemsProcessor;	17	import org.eclipse.emf.cdo.internal.ui.ItemsProcessor;
17	import org.eclipse.emf.cdo.internal.ui.bundle.OM;	18	import org.eclipse.emf.cdo.internal.ui.bundle.OM;
18	import org.eclipse.emf.cdo.session.CDOSession;	19	import org.eclipse.emf.cdo.session.CDOSession;
Lines 21-26 Link Here
21	import org.eclipse.emf.cdo.transaction.CDOTransactionStartedEvent;	22	import org.eclipse.emf.cdo.transaction.CDOTransactionStartedEvent;
22	import org.eclipse.emf.cdo.view.CDOView;	23	import org.eclipse.emf.cdo.view.CDOView;
23	import org.eclipse.emf.cdo.view.CDOViewInvalidationEvent;	24	import org.eclipse.emf.cdo.view.CDOViewInvalidationEvent;
		25	import org.eclipse.emf.cdo.view.RemoteLockAcquiredEvent;
		26	import org.eclipse.emf.cdo.view.RemoteLockReleasedEvent;
24		27
25	import org.eclipse.net4j.util.container.IContainerDelta;	28	import org.eclipse.net4j.util.container.IContainerDelta;
26	import org.eclipse.net4j.util.container.IContainerEvent;	29	import org.eclipse.net4j.util.container.IContainerEvent;
Lines 36-41 Link Here
36	import org.eclipse.jface.viewers.TreeViewer;	39	import org.eclipse.jface.viewers.TreeViewer;
37	import org.eclipse.ui.PlatformUI;	40	import org.eclipse.ui.PlatformUI;
38		41
		42	import java.util.ArrayList;
		43	import java.util.Collection;
39	import java.util.List;	44	import java.util.List;
40	import java.util.Set;	45	import java.util.Set;
41		46
Lines 321-324 Link Here
321	protected void viewClosed()	326	protected void viewClosed()
322	{	327	{
323	}	328	}
		329
		330	/**
		331	* @author Juan Pedro Silva
		332	*/
		333	private IListener lockListener = new IListener()
		334	{
		335	public void notifyEvent(IEvent event)
		336	{
		337	if (event instanceof RemoteLockAcquiredEvent)
		338	{
		339	RemoteLockAcquiredEvent e = (RemoteLockAcquiredEvent)event;
		340	System.err.println("RemoteLockAcquiredEvent received. LockType: " + e.getLockType());
		341	if (e.getUser() != null)
		342	{
		343	System.err.println("User: " + e.getUser());
		344	}
		345	int i = 1;
		346	for (CDOID ci : e.getCdoIds())
		347	{
		348	System.err.println("CDOID: " + ci + " (" + i + ").");
		349	i++;
		350	}
		351	}
		352	}
		353	};
		354
		355	/**
		356	* @author Juan Pedro Silva
		357	*/
		358	private IListener unlockListener = new IListener()
		359	{
		360	public void notifyEvent(IEvent event)
		361	{
		362	if (event instanceof RemoteLockReleasedEvent)
		363	{
		364	RemoteLockReleasedEvent e = (RemoteLockReleasedEvent)event;
		365	System.err.println("RemoteLockReleasedEvent received. LockType: " + e.getLockType());
		366	if (e.getUser() != null)
		367	{
		368	System.err.println("User: " + e.getUser());
		369	}
		370	int i = 1;
		371	for (CDOID ci : e.getCdoIds())
		372	{
		373	System.err.println("CDOID: " + ci + " (" + i + ").");
		374	i++;
		375	}
		376	}
		377	}
		378	};
		379
		380	/**
		381	* @author Juan Pedro Silva
		382	*/
		383	public Collection<IListener> getLockListeners()
		384	{
		385	ArrayList<IListener> ail = new ArrayList<IListener>();
		386	ail.add(lockListener);
		387	ail.add(unlockListener);
		388	return ail;
		389	}
324	}	390	}




import org.eclipse.net4j.channel.IChannel;
import org.eclipse.net4j.signal.SignalProtocol;
import org.eclipse.net4j.signal.SignalReactor;
import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
import org.eclipse.net4j.util.io.StringCompressor;
import org.eclipse.net4j.util.io.StringIO;
import org.eclipse.net4j.util.lifecycle.LifecycleUtil;

import java.util.Collection;
import java.util.List;

/**

    case CDOProtocolConstants.SIGNAL_REMOTE_MESSAGE:
      return new RemoteMessageIndication(this);

      /**
       * @author Juan Pedro Silva
       */
    case CDOProtocolConstants.SIGNAL_REGISTER_LOCK_LISTENER:
      return new RegisterLockListenerIndication(this);

    case CDOProtocolConstants.SIGNAL_UNREGISTER_LOCK_LISTENER:
      return new UnregisterLockListenerIndication(this);

    default:
      return super.createSignalReactor(signalID);
    }
  }

  /**
   * @author Juan Pedro Silva True = Lock, false = Unlock
   * @param lock
   *          True = Lock, false = Unlock
   */
  public void sendRemoteLockNotification(boolean b, String user, Collection<CDOID> cdoids, LockType lockType)
  {
    try
    {
      IChannel channel = getChannel();
      if (LifecycleUtil.isActive(channel))
      {
        new RemoteLockChangedNotificationRequest(channel, b, user, cdoids, lockType).sendAsync();
      }
      else
      {
        OM.LOG.warn("Session channel is inactive: " + this); //$NON-NLS-1$
      }
    }
    catch (Exception ex)
    {
      OM.LOG.error(ex);
    }
  }
}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.server.internal.net4j.protocol;

import org.eclipse.emf.cdo.common.io.CDODataInput;
import org.eclipse.emf.cdo.common.io.CDODataOutput;
import org.eclipse.emf.cdo.common.protocol.CDOProtocolConstants;
import org.eclipse.emf.cdo.server.internal.net4j.bundle.OM;

import org.eclipse.net4j.util.om.trace.ContextTracer;

import java.io.IOException;

/**
 * @author Juan Pedro Silva
 */
public class UnregisterLockListenerIndication extends CDOReadIndication
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG_PROTOCOL,
      UnregisterLockListenerIndication.class);

  public UnregisterLockListenerIndication(CDOServerProtocol protocol)
  {
    super(protocol, CDOProtocolConstants.SIGNAL_UNREGISTER_LOCK_LISTENER);
  }

  @Override
  protected void indicating(CDODataInput in) throws IOException
  {
    if (TRACER.isEnabled())
    {
      TRACER.trace("Unregistering Lock Listener"); //$NON-NLS-1$
    }

    getRepository().getLockManager().unRegisterLockListener(getSession());
  }

  @Override
  protected void responding(CDODataOutput out) throws IOException
  {
    out.writeBoolean(true);
  }
}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.server.internal.net4j.protocol;

import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.io.CDODataOutput;
import org.eclipse.emf.cdo.common.protocol.CDOProtocolConstants;
import org.eclipse.emf.cdo.server.internal.net4j.bundle.OM;

import org.eclipse.net4j.channel.IChannel;
import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
import org.eclipse.net4j.util.om.trace.ContextTracer;

import java.io.IOException;
import java.util.Collection;

/**
 * @author Juan Pedro Silva
 */
public class RemoteLockChangedNotificationRequest extends CDOServerRequest
{

  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG_PROTOCOL,
      RemoteLockChangedNotificationRequest.class);

  private long timeStamp;

  private Collection<CDOID> lockedObjects;

  private LockType lockType;

  private String userID;

  private boolean lock;

  public RemoteLockChangedNotificationRequest(IChannel channel, boolean lock, String userID, Collection<CDOID> cdoids,
      LockType lockType)
  {
    super(channel, CDOProtocolConstants.SIGNAL_REMOTE_LOCK_CHANGED_NOTIFICATION);
    timeStamp = System.currentTimeMillis();
    this.userID = userID;
    this.lock = lock;
    lockedObjects = cdoids;
    this.lockType = lockType;
  }

  @Override
  protected void requesting(CDODataOutput out) throws IOException
  {
    if (TRACER.isEnabled())
    {
      TRACER.format("Writing timeStamp: {0,date} {0,time}", timeStamp); //$NON-NLS-1$
    }

    out.writeLong(timeStamp);
    if (TRACER.isEnabled())
    {
      TRACER.format("Writing {0} locked IDs", lockedObjects.size()); //$NON-NLS-1$
    }

    out.writeInt(lockedObjects == null ? 0 : lockedObjects.size());
    for (CDOID id : lockedObjects)
    {
      if (TRACER.isEnabled())
      {
        TRACER.format("Writing locked ID: {0}", id); //$NON-NLS-1$
      }
      out.writeCDOID(id);
    }
    out.writeBoolean(lock);
    out.writeCDOLockType(lockType);
    out.writeString(userID);
  }

}




/**
 * Copyright (c) 2004 - 2009 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
 */
package org.eclipse.emf.cdo.server.internal.net4j.protocol;

import org.eclipse.emf.cdo.common.io.CDODataInput;
import org.eclipse.emf.cdo.common.io.CDODataOutput;
import org.eclipse.emf.cdo.common.protocol.CDOProtocolConstants;
import org.eclipse.emf.cdo.server.internal.net4j.bundle.OM;

import org.eclipse.net4j.util.om.trace.ContextTracer;

import java.io.IOException;

/**
 * @author Juan Pedro Silva
 */
public class RegisterLockListenerIndication extends CDOReadIndication
{
  private static final ContextTracer TRACER = new ContextTracer(OM.DEBUG_PROTOCOL, RegisterLockListenerIndication.class);

  public RegisterLockListenerIndication(CDOServerProtocol protocol)
  {
    super(protocol, CDOProtocolConstants.SIGNAL_REGISTER_LOCK_LISTENER);
  }

  @Override
  protected void indicating(CDODataInput in) throws IOException
  {
    if (TRACER.isEnabled())
    {
      TRACER.trace("Registering Lock Listener"); //$NON-NLS-1$
    }

    getRepository().getLockManager().registerLockListener(getSession());
  }

  @Override
  protected void responding(CDODataOutput out) throws IOException
  {
    out.writeBoolean(true);
  }
}




  public static final short SIGNAL_REMOTE_SESSION_NOTIFICATION = 32;

  // //////////////////////////////////////////////////////////////////////
  // Lock Notification

  /**
   * @author Juan Pedro Silva
   */
  public static final short SIGNAL_REGISTER_LOCK_LISTENER = 35;

  public static final short SIGNAL_UNREGISTER_LOCK_LISTENER = 36;

  public static final short SIGNAL_REMOTE_LOCK_CHANGED_NOTIFICATION = 37;

  // //////////////////////////////////////////////////////////////////////
  // Session Management

  public static final int ERROR_REPOSITORY_NOT_FOUND = -1;

Return to bug 283274

Lines 467-470 Link Here

(-)src/org/eclipse/emf/cdo/internal/server/embedded/EmbeddedClientSessionProtocol.java (+16 lines)
467		467
468	return result;	468	return result;
469	}	469	}
		470
		471	/**
		472	* @author Juan Pedro Silva
		473	*/
		474	public void subscribeRemoteLocks()
		475	{
		476	throw new UnsupportedOperationException();
		477	}
		478
		479	/**
		480	* @author Juan Pedro Silva
		481	*/
		482	public void unsubscribeRemoteLocks()
		483	{
		484	throw new UnsupportedOperationException();
		485	}
470	}	486	}

Lines 1277-1282 Link Here

(-)src/org/eclipse/emf/cdo/internal/ui/editor/CDOEditor.java (+10 lines)
1277	fireDirtyPropertyChange();	1277	fireDirtyPropertyChange();
1278	}	1278	}
1279	};	1279	};
		1280
		1281	/**
		1282	*@author Juan Pedro Silva
		1283	*@see I don't like this registration here. I rather have it under an option, which is the proper place. However,
		1284	* this is currently the way I'm using to be sure eventHandler's listeners have been registered.
		1285	*@TODO: Make the registration optional.
		1286	*/
		1287	CDOView lm = getView();
		1288	lm.registerLockListeners(eventHandler.getLockListeners());
		1289
1280	}	1290	}
1281	catch (RuntimeException ex)	1291	catch (RuntimeException ex)
1282	{	1292	{

Lines 48-418 Link Here

(-)src/org/eclipse/emf/spi/cdo/CDOSessionProtocol.java (-367 / +358 lines)
48	* @author Eike Stepper	48	* @author Eike Stepper
49	* @since 2.0	49	* @since 2.0
50	*/	50	*/
51	public interface CDOSessionProtocol extends CDOProtocol, PackageLoader, RevisionLoader	51	public interface CDOSessionProtocol extends CDOProtocol, PackageLoader,
52	{	52	RevisionLoader {
53	public void setPassiveUpdate(Map<CDOID, CDOIDAndVersion> idAndVersions, int initialChunkSize,	53	public void setPassiveUpdate(Map<CDOID, CDOIDAndVersion> idAndVersions,
54	boolean passiveUpdateEnabled);	54	int initialChunkSize, boolean passiveUpdateEnabled);
55		55
56	public RepositoryTimeResult getRepositoryTime();	56	public RepositoryTimeResult getRepositoryTime();
57		57
58	/**	58	/**
59	* @param revision	59	* @param revision
60	* @param feature	60	* @param feature
61	* @param accessIndex	61	* @param accessIndex
62	* Index of the item access at the client (with modifications)	62	* Index of the item access at the client (with modifications)
63	* @param fetchIndex	63	* @param fetchIndex
64	* Index of the item access at the server (without any modifications)	64	* Index of the item access at the server (without any
65	* @param fromIndex	65	* modifications)
66	* Load objects at the client from fromIndex (inclusive)	66	* @param fromIndex
67	* @param toIndex	67	* Load objects at the client from fromIndex (inclusive)
68	* Load objects at the client to toIndex (inclusive)	68	* @param toIndex
69	*/	69	* Load objects at the client to toIndex (inclusive)
70	public Object loadChunk(InternalCDORevision revision, EStructuralFeature feature, int accessIndex, int fetchIndex,	70	*/
71	int fromIndex, int toIndex);	71	public Object loadChunk(InternalCDORevision revision,
72		72	EStructuralFeature feature, int accessIndex, int fetchIndex,
73	public Collection<CDOTimeStampContext> syncRevisions(Map<CDOID, CDOIDAndVersion> allRevisions, int initialChunkSize);	73	int fromIndex, int toIndex);
74		74
75	/**	75	public Collection<CDOTimeStampContext> syncRevisions(
76	* @since 3.0	76	Map<CDOID, CDOIDAndVersion> allRevisions, int initialChunkSize);
77	*/	77
78	public void openView(int viewId, CDOCommonView.Type type, long timeStamp);	78	/**
79		79	* @since 3.0
80	public void closeView(int viewId);	80	*/
81		81	public void openView(int viewId, CDOCommonView.Type type, long timeStamp);
82	public boolean[] setAudit(int viewId, long timeStamp, List<InternalCDOObject> invalidObjects);	82
83		83	public void closeView(int viewId);
84	public void changeSubscription(int viewId, List<CDOID> cdoIDs, boolean subscribeMode, boolean clear);	84
85		85	public boolean[] setAudit(int viewId, long timeStamp,
86	/**	86	List<InternalCDOObject> invalidObjects);
87	* @since 3.0	87
88	*/	88	public void changeSubscription(int viewId, List<CDOID> cdoIDs,
89	public void query(int viewID, AbstractQueryIterator<?> queryResult);	89	boolean subscribeMode, boolean clear);
90		90
91	public boolean cancelQuery(int queryId);	91	/**
92		92	* @since 3.0
93	/**	93	*/
94	* @since 3.0	94	public void query(int viewID, AbstractQueryIterator<?> queryResult);
95	*/	95
96	public void lockObjects(CDOView view, Map<CDOID, CDOIDAndVersion> objects, long timeout, LockType lockType)	96	public boolean cancelQuery(int queryId);
97	throws InterruptedException;	97
98		98	/**
99	/**	99	* @since 3.0
100	* @since 3.0	100	*/
101	*/	101	public void lockObjects(CDOView view, Map<CDOID, CDOIDAndVersion> objects,
102	public void unlockObjects(CDOView view, Collection<? extends CDOObject> objects, LockType lockType);	102	long timeout, LockType lockType) throws InterruptedException;
103		103
104	/**	104	/**
105	* @since 3.0	105	* @since 3.0
106	*/	106	*/
107	public boolean isObjectLocked(CDOView view, CDOObject object, LockType lockType, boolean byOthers);	107	public void unlockObjects(CDOView view,
108		108	Collection<? extends CDOObject> objects, LockType lockType);
109	public CommitTransactionResult commitTransaction(InternalCDOCommitContext commitContext, OMMonitor monitor);	109
110		110	/**
111	public CommitTransactionResult commitTransactionPhase1(InternalCDOXACommitContext xaContext, OMMonitor monitor);	111	* @since 3.0
112		112	*/
113	public CommitTransactionResult commitTransactionPhase2(InternalCDOXACommitContext xaContext, OMMonitor monitor);	113	public boolean isObjectLocked(CDOView view, CDOObject object,
114		114	LockType lockType, boolean byOthers);
115	public CommitTransactionResult commitTransactionPhase3(InternalCDOXACommitContext xaContext, OMMonitor monitor);	115
116		116	public CommitTransactionResult commitTransaction(
117	public CommitTransactionResult commitTransactionCancel(InternalCDOXACommitContext xaContext, OMMonitor monitor);	117	InternalCDOCommitContext commitContext, OMMonitor monitor);
118		118
119	public List<CDORemoteSession> getRemoteSessions(InternalCDORemoteSessionManager manager, boolean subscribe);	119	public CommitTransactionResult commitTransactionPhase1(
120		120	InternalCDOXACommitContext xaContext, OMMonitor monitor);
121	/**	121
122	* @since 3.0	122	public CommitTransactionResult commitTransactionPhase2(
123	*/	123	InternalCDOXACommitContext xaContext, OMMonitor monitor);
124	public Set<Integer> sendRemoteMessage(CDORemoteSessionMessage message, List<CDORemoteSession> recipients);	124
125		125	public CommitTransactionResult commitTransactionPhase3(
126	/**	126	InternalCDOXACommitContext xaContext, OMMonitor monitor);
127	* @since 3.0	127
128	*/	128	public CommitTransactionResult commitTransactionCancel(
129	public boolean unsubscribeRemoteSessions();	129	InternalCDOXACommitContext xaContext, OMMonitor monitor);
130		130
131	/**	131	public List<CDORemoteSession> getRemoteSessions(
132	* @author Eike Stepper	132	InternalCDORemoteSessionManager manager, boolean subscribe);
133	*/	133
134	public final class OpenSessionResult	134	/**
135	{	135	* @since 3.0
136	private int sessionID;	136	*/
137		137	public Set<Integer> sendRemoteMessage(CDORemoteSessionMessage message,
138	private String repositoryUUID;	138	List<CDORemoteSession> recipients);
139		139
140	private long repositoryCreationTime;	140	/**
141		141	* @since 3.0
142	private long lastUpdateTime;	142	*/
143		143	public boolean unsubscribeRemoteSessions();
144	private RepositoryTimeResult repositoryTimeResult;	144
145		145	/**
146	private boolean repositorySupportingAudits;	146	* @author Eike Stepper
147		147	*/
148	private List<InternalCDOPackageUnit> packageUnits = new ArrayList<InternalCDOPackageUnit>();	148	public final class OpenSessionResult {
149		149	private int sessionID;
150	/**	150
151	* @since 3.0	151	private String repositoryUUID;
152	*/	152
153	public OpenSessionResult(int sessionID, String repositoryUUID, long repositoryCreationTime, long lastUpdateTime,	153	private long repositoryCreationTime;
154	boolean repositorySupportingAudits)	154
155	{	155	private long lastUpdateTime;
156	this.sessionID = sessionID;	156
157	this.repositoryUUID = repositoryUUID;	157	private RepositoryTimeResult repositoryTimeResult;
158	this.repositoryCreationTime = repositoryCreationTime;	158
159	this.lastUpdateTime = lastUpdateTime;	159	private boolean repositorySupportingAudits;
160	this.repositorySupportingAudits = repositorySupportingAudits;	160
161	}	161	private List<InternalCDOPackageUnit> packageUnits = new ArrayList<InternalCDOPackageUnit>();
162		162
163	public int getSessionID()	163	/**
164	{	164	* @since 3.0
165	return sessionID;	165	*/
166	}	166	public OpenSessionResult(int sessionID, String repositoryUUID,
167		167	long repositoryCreationTime, long lastUpdateTime,
168	public String getRepositoryUUID()	168	boolean repositorySupportingAudits) {
169	{	169	this.sessionID = sessionID;
170	return repositoryUUID;	170	this.repositoryUUID = repositoryUUID;
171	}	171	this.repositoryCreationTime = repositoryCreationTime;
172		172	this.lastUpdateTime = lastUpdateTime;
173	public long getRepositoryCreationTime()	173	this.repositorySupportingAudits = repositorySupportingAudits;
174	{	174	}
175	return repositoryCreationTime;	175
176	}	176	public int getSessionID() {
177		177	return sessionID;
178	public boolean isRepositorySupportingAudits()	178	}
179	{	179
180	return repositorySupportingAudits;	180	public String getRepositoryUUID() {
181	}	181	return repositoryUUID;
182		182	}
183	public RepositoryTimeResult getRepositoryTimeResult()	183
184	{	184	public long getRepositoryCreationTime() {
185	return repositoryTimeResult;	185	return repositoryCreationTime;
186	}	186	}
187		187
188	public void setRepositoryTimeResult(RepositoryTimeResult repositoryTimeResult)	188	public boolean isRepositorySupportingAudits() {
189	{	189	return repositorySupportingAudits;
190	this.repositoryTimeResult = repositoryTimeResult;	190	}
191	}	191
192		192	public RepositoryTimeResult getRepositoryTimeResult() {
193	/**	193	return repositoryTimeResult;
194	* @since 3.0	194	}
195	*/	195
196	public long getLastUpdateTime()	196	public void setRepositoryTimeResult(
197	{	197	RepositoryTimeResult repositoryTimeResult) {
198	return lastUpdateTime;	198	this.repositoryTimeResult = repositoryTimeResult;
199	}	199	}
200		200
201	public List<InternalCDOPackageUnit> getPackageUnits()	201	/**
202	{	202	* @since 3.0
203	return packageUnits;	203	*/
204	}	204	public long getLastUpdateTime() {
205	}	205	return lastUpdateTime;
206		206	}
207	/**	207
208	* @author Eike Stepper	208	public List<InternalCDOPackageUnit> getPackageUnits() {
209	*/	209	return packageUnits;
210	public final class RepositoryTimeResult	210	}
211	{	211	}
212	private long requested;	212
213		213	/**
214	private long indicated;	214	* @author Eike Stepper
215		215	*/
216	private long responded;	216	public final class RepositoryTimeResult {
217		217	private long requested;
218	private long confirmed;	218
219		219	private long indicated;
220	public RepositoryTimeResult()	220
221	{	221	private long responded;
222	}	222
223		223	private long confirmed;
224	public long getRequested()	224
225	{	225	public RepositoryTimeResult() {
226	return requested;	226	}
227	}	227
228		228	public long getRequested() {
229	public void setRequested(long requested)	229	return requested;
230	{	230	}
231	this.requested = requested;	231
232	}	232	public void setRequested(long requested) {
233		233	this.requested = requested;
234	public long getIndicated()	234	}
235	{	235
236	return indicated;	236	public long getIndicated() {
237	}	237	return indicated;
238		238	}
239	public void setIndicated(long indicated)	239
240	{	240	public void setIndicated(long indicated) {
241	this.indicated = indicated;	241	this.indicated = indicated;
242	}	242	}
243		243
244	public long getResponded()	244	public long getResponded() {
245	{	245	return responded;
246	return responded;	246	}
247	}	247
248		248	public void setResponded(long responded) {
249	public void setResponded(long responded)	249	this.responded = responded;
250	{	250	}
251	this.responded = responded;	251
252	}	252	public long getConfirmed() {
253		253	return confirmed;
254	public long getConfirmed()	254	}
255	{	255
256	return confirmed;	256	public void setConfirmed(long confirmed) {
257	}	257	this.confirmed = confirmed;
258		258	}
259	public void setConfirmed(long confirmed)	259
260	{	260	public long getAproximateRepositoryOffset() {
261	this.confirmed = confirmed;	261	long latency = confirmed - requested >> 1;
262	}	262	long shift = confirmed - responded;
263		263	return shift - latency;
264	public long getAproximateRepositoryOffset()	264	}
265	{	265
266	long latency = confirmed - requested >> 1;	266	public long getAproximateRepositoryTime() {
267	long shift = confirmed - responded;	267	long offset = getAproximateRepositoryOffset();
268	return shift - latency;	268	return System.currentTimeMillis() + offset;
269	}	269	}
270		270
271	public long getAproximateRepositoryTime()	271	@Override
272	{	272	public String toString() {
273	long offset = getAproximateRepositoryOffset();	273	return MessageFormat
274	return System.currentTimeMillis() + offset;	274	.format(
275	}	275	"RepositoryTime[requested={0,date} {0,time}, indicated={1,date} {1,time}, responded={2,date} {2,time}, confirmed={3,date} {3,time}]",
276		276	requested, indicated, responded, confirmed);
277	@Override	277	}
278	public String toString()	278	}
279	{	279
280	return MessageFormat	280	/**
281	.format(	281	* @author Eike Stepper
282	"RepositoryTime[requested={0,date} {0,time}, indicated={1,date} {1,time}, responded={2,date} {2,time}, confirmed={3,date} {3,time}]",	282	*/
283	requested, indicated, responded, confirmed);	283	public final class CommitTransactionResult {
284	}	284	private String rollbackMessage;
285	}	285
286		286	private long timeStamp;
287	/**	287
288	* @author Eike Stepper	288	// private List<CDOIDMetaRange> metaIDRanges = new
289	*/	289	// ArrayList<CDOIDMetaRange>();
290	public final class CommitTransactionResult	290
291	{	291	private Map<CDOIDTemp, CDOID> idMappings = new HashMap<CDOIDTemp, CDOID>();
292	private String rollbackMessage;	292
293		293	private CDOReferenceAdjuster referenceAdjuster;
294	private long timeStamp;	294
295		295	private InternalCDOCommitContext commitContext;
296	// private List<CDOIDMetaRange> metaIDRanges = new ArrayList<CDOIDMetaRange>();	296
297		297	public CommitTransactionResult(InternalCDOCommitContext commitContext,
298	private Map<CDOIDTemp, CDOID> idMappings = new HashMap<CDOIDTemp, CDOID>();	298	String rollbackMessage) {
299		299	this.rollbackMessage = rollbackMessage;
300	private CDOReferenceAdjuster referenceAdjuster;	300	this.commitContext = commitContext;
301		301	}
302	private InternalCDOCommitContext commitContext;	302
303		303	public CommitTransactionResult(InternalCDOCommitContext commitContext,
304	public CommitTransactionResult(InternalCDOCommitContext commitContext, String rollbackMessage)	304	long timeStamp) {
305	{	305	this.timeStamp = timeStamp;
306	this.rollbackMessage = rollbackMessage;	306	this.commitContext = commitContext;
307	this.commitContext = commitContext;	307	}
308	}	308
309		309	public CDOReferenceAdjuster getReferenceAdjuster() {
310	public CommitTransactionResult(InternalCDOCommitContext commitContext, long timeStamp)	310	if (referenceAdjuster == null) {
311	{	311	referenceAdjuster = createReferenceAdjuster();
312	this.timeStamp = timeStamp;	312	}
313	this.commitContext = commitContext;	313
314	}	314	return referenceAdjuster;
315		315	}
316	public CDOReferenceAdjuster getReferenceAdjuster()	316
317	{	317	public void setReferenceAdjuster(CDOReferenceAdjuster referenceAdjuster) {
318	if (referenceAdjuster == null)	318	this.referenceAdjuster = referenceAdjuster;
319	{	319	}
320	referenceAdjuster = createReferenceAdjuster();	320
321	}	321	public InternalCDOCommitContext getCommitContext() {
322		322	return commitContext;
323	return referenceAdjuster;	323	}
324	}	324
325		325	public String getRollbackMessage() {
326	public void setReferenceAdjuster(CDOReferenceAdjuster referenceAdjuster)	326	return rollbackMessage;
327	{	327	}
328	this.referenceAdjuster = referenceAdjuster;	328
329	}	329	public long getTimeStamp() {
330		330	return timeStamp;
331	public InternalCDOCommitContext getCommitContext()	331	}
332	{	332
333	return commitContext;	333	public Map<CDOIDTemp, CDOID> getIDMappings() {
334	}	334	return idMappings;
335		335	}
336	public String getRollbackMessage()	336
337	{	337	public void addIDMapping(CDOIDTemp oldID, CDOID newID) {
338	return rollbackMessage;	338	idMappings.put(oldID, newID);
339	}	339	}
340		340
341	public long getTimeStamp()	341	// /**
342	{	342	// * @since 3.0
343	return timeStamp;	343	// */
344	}	344	// public List<CDOIDMetaRange> getMetaIDRanges()
345		345	// {
346	public Map<CDOIDTemp, CDOID> getIDMappings()	346	// return metaIDRanges;
347	{	347	// }
348	return idMappings;	348	//
349	}	349	// /**
350		350	// * @since 3.0
351	public void addIDMapping(CDOIDTemp oldID, CDOID newID)	351	// */
352	{	352	// public void addMetaIDRange(CDOIDMetaRange metaIDRange)
353	idMappings.put(oldID, newID);	353	// {
354	}	354	// metaIDRanges.add(metaIDRange);
355		355	// }
356	// /**	356
357	// * @since 3.0	357	protected PostCommitReferenceAdjuster createReferenceAdjuster() {
358	// */	358	return new PostCommitReferenceAdjuster(commitContext
359	// public List<CDOIDMetaRange> getMetaIDRanges()	359	.getTransaction(), new CDOIDMapper(idMappings));
360	// {	360	}
361	// return metaIDRanges;	361
362	// }	362	/**
363	//	363	* @author Simon McDuff
364	// /**	364	*/
365	// * @since 3.0	365	protected static class PostCommitReferenceAdjuster implements
366	// */	366	CDOReferenceAdjuster {
367	// public void addMetaIDRange(CDOIDMetaRange metaIDRange)	367	private CDOIDProvider idProvider;
368	// {	368
369	// metaIDRanges.add(metaIDRange);	369	private CDOIDMapper idMapper;
370	// }	370
371		371	public PostCommitReferenceAdjuster(CDOIDProvider idProvider,
372	protected PostCommitReferenceAdjuster createReferenceAdjuster()	372	CDOIDMapper idMapper) {
373	{	373	this.idProvider = idProvider;
374	return new PostCommitReferenceAdjuster(commitContext.getTransaction(), new CDOIDMapper(idMappings));	374	this.idMapper = idMapper;
375	}	375	}
376		376
377	/**	377	public CDOIDProvider getIdProvider() {
378	* @author Simon McDuff	378	return idProvider;
379	*/	379	}
380	protected static class PostCommitReferenceAdjuster implements CDOReferenceAdjuster	380
381	{	381	public CDOIDMapper getIdMapper() {
382	private CDOIDProvider idProvider;	382	return idMapper;
383		383	}
384	private CDOIDMapper idMapper;	384
385		385	public Object adjustReference(Object id) {
386	public PostCommitReferenceAdjuster(CDOIDProvider idProvider, CDOIDMapper idMapper)	386	if (id == null \|\| id == CDOID.NULL) {
387	{	387	return id;
388	this.idProvider = idProvider;	388	}
389	this.idMapper = idMapper;	389
390	}	390	if (idProvider != null
391		391	&& (id instanceof CDOID \|\| id instanceof InternalEObject)) {
392	public CDOIDProvider getIdProvider()	392	id = idProvider.provideCDOID(id);
393	{	393	}
394	return idProvider;	394
395	}	395	return idMapper.adjustReference(id);
396		396	}
397	public CDOIDMapper getIdMapper()	397	}
398	{	398	}
399	return idMapper;	399
400	}	400	/**
401		401	* @author Juan Pedro Silva
402	public Object adjustReference(Object id)	402	*/
403	{	403	public void subscribeRemoteLocks();
404	if (id == null \|\| id == CDOID.NULL)	404
405	{	405	/**
406	return id;	406	* @author Juan Pedro Silva
407	}	407	*/
408		408	public void unsubscribeRemoteLocks();
409	if (idProvider != null && (id instanceof CDOID \|\| id instanceof InternalEObject))
410	{
411	id = idProvider.provideCDOID(id);
412	}
413
414	return idMapper.adjustReference(id);
415	}
416	}
417	}
418	}	409	}

Lines 35-119 Link Here

(-)src/org/eclipse/emf/spi/cdo/InternalCDOSession.java (-81 / +97 lines)
35	* @author Eike Stepper	35	* @author Eike Stepper
36	* @since 2.0	36	* @since 2.0
37	*/	37	*/
38	public interface InternalCDOSession extends CDOSession, PackageProcessor, PackageLoader, RevisionLocker, ILifecycle	38	public interface InternalCDOSession extends CDOSession, PackageProcessor,
39	{	39	PackageLoader, RevisionLocker, ILifecycle {
40	/**	40	/**
41	* @since 3.0	41	* @since 3.0
42	*/	42	*/
43	public InternalCDOSessionConfiguration getConfiguration();	43	public InternalCDOSessionConfiguration getConfiguration();
44		44
45	public CDOSessionProtocol getSessionProtocol();	45	public CDOSessionProtocol getSessionProtocol();
46		46
47	/**	47	/**
48	* @since 3.0	48	* @since 3.0
49	*/	49	*/
50	public void setSessionProtocol(CDOSessionProtocol sessionProtocol);	50	public void setSessionProtocol(CDOSessionProtocol sessionProtocol);
51		51
52	public InternalCDOPackageRegistry getPackageRegistry();	52	public InternalCDOPackageRegistry getPackageRegistry();
53		53
54	/**	54	/**
55	* @since 3.0	55	* @since 3.0
56	*/	56	*/
57	public InternalCDORevisionManager getRevisionManager();	57	public InternalCDORevisionManager getRevisionManager();
58		58
59	public void setExceptionHandler(CDOSession.ExceptionHandler exceptionHandler);	59	public void setExceptionHandler(CDOSession.ExceptionHandler exceptionHandler);
60		60
61	/**	61	/**
62	* @since 3.0	62	* @since 3.0
63	*/	63	*/
64	public void setFetchRuleManager(CDOFetchRuleManager fetchRuleManager);	64	public void setFetchRuleManager(CDOFetchRuleManager fetchRuleManager);
65		65
66	/**	66	/**
67	* @since 3.0	67	* @since 3.0
68	*/	68	*/
69	public void setRepositoryInfo(CDORepositoryInfo repositoryInfo);	69	public void setRepositoryInfo(CDORepositoryInfo repositoryInfo);
70		70
71	/**	71	/**
72	* @since 3.0	72	* @since 3.0
73	*/	73	*/
74	public InternalCDORemoteSessionManager getRemoteSessionManager();	74	public InternalCDORemoteSessionManager getRemoteSessionManager();
75		75
76	/**	76	/**
77	* @since 3.0	77	* @since 3.0
78	*/	78	*/
79	public void setRemoteSessionManager(InternalCDORemoteSessionManager remoteSessionManager);	79	public void setRemoteSessionManager(
80		80	InternalCDORemoteSessionManager remoteSessionManager);
81	/**	81
82	* @since 3.0	82	/**
83	*/	83	* @since 3.0
84	public void setSessionID(int sessionID);	84	*/
85		85	public void setSessionID(int sessionID);
86	public void setUserID(String userID);	86
87		87	public void setUserID(String userID);
88	/**	88
89	* @since 3.0	89	/**
90	*/	90	* @since 3.0
91	public void setLastUpdateTime(long lastUpdateTime);	91	*/
92		92	public void setLastUpdateTime(long lastUpdateTime);
93	public void viewDetached(InternalCDOView view);	93
94		94	public void viewDetached(InternalCDOView view);
95	/**	95
96	* @since 3.0	96	/**
97	*/	97	* @since 3.0
98	public Object resolveElementProxy(CDORevision revision, EStructuralFeature feature, int accessIndex, int serverIndex);	98	*/
99		99	public Object resolveElementProxy(CDORevision revision,
100	/**	100	EStructuralFeature feature, int accessIndex, int serverIndex);
101	* @since 3.0	101
102	*/	102	/**
103	public Object getCommitLock();	103	* @since 3.0
104		104	*/
105	public void handleCommitNotification(long timeStamp, Collection<CDOPackageUnit> newPackageUnits,	105	public Object getCommitLock();
106	Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects, Collection<CDORevisionDelta> deltas,	106
107	InternalCDOView excludedView);	107	public void handleCommitNotification(long timeStamp,
108		108	Collection<CDOPackageUnit> newPackageUnits,
109	public void handleSyncResponse(long timestamp, Collection<CDOPackageUnit> newPackageUnits,	109	Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects,
110	Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects);	110	Collection<CDORevisionDelta> deltas, InternalCDOView excludedView);
111		111
112	/**	112	public void handleSyncResponse(long timestamp,
113	* In some cases we need to sync without propagating event. Lock is a good example.	113	Collection<CDOPackageUnit> newPackageUnits,
114	*	114	Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects);
115	* @since 3.0	115
116	*/	116	/**
117	public void reviseRevisions(final long timeStamp, Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects,	117	* In some cases we need to sync without propagating event. Lock is a good
118	InternalCDOView excludedView);	118	* example.
		119	*
		120	* @since 3.0
		121	*/
		122	public void reviseRevisions(final long timeStamp,
		123	Set<CDOIDAndVersion> dirtyOIDs, Collection<CDOID> detachedObjects,
		124	InternalCDOView excludedView);
		125
		126	/**
		127	* @author Juan Pedro Silva
		128	*/
		129	public void registerLockListeners(InternalCDOView cdoView);
		130
		131	/**
		132	* @author Juan Pedro Silva
		133	*/
		134	public void unregisterLockListeners(InternalCDOView cdoView);
119	}	135	}

Added Link Here

(-)src/org/eclipse/emf/cdo/view/RemoteLockEvent.java (+51 lines)
1	/**
2	* Copyright (c) 2004 - 2009 Eike Stepper (Berlin, Germany) and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Eike Stepper - initial API and implementation
10	*/
11	package org.eclipse.emf.cdo.view;
12
13	import org.eclipse.emf.cdo.common.id.CDOID;
14
15	import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
16
17	import java.util.Collection;
18
19	/**
20	* @author Eike Stepper
21	*/
22	public class RemoteLockEvent implements CDOViewEvent {
23	private Collection<CDOID> cdoIds;
24	private String user;
25	private LockType lockType;
26
27	public RemoteLockEvent(String user, Collection<CDOID> cdoIds,
28	LockType lockType) {
29	super();
30	this.user = user;
31	this.lockType = lockType;
32	this.cdoIds = cdoIds;
33	}
34
35	public String getUser() {
36	return user;
37	}
38
39	public LockType getLockType() {
40	return lockType;
41	}
42
43	public Collection<CDOID> getCdoIds() {
44	return cdoIds;
45	}
46
47	public CDOView getSource() {
48	return null;
49	}
50
51	}

Lines 49-54 Link Here

(-)src/org/eclipse/net4j/util/concurrent/IRWLockManager.java (+25 lines)
49	public boolean hasLockByOthers(LockType type, V context, K objectToLock);	49	public boolean hasLockByOthers(LockType type, V context, K objectToLock);
50		50
51	/**	51	/**
		52	* @author Juan Pedro Silva
		53	*/
		54	public void registerLockListeners(Collection<Object> collToRegister);
		55
		56	/**
		57	* @author Juan Pedro Silva
		58	*/
		59	public void registerLockListener(Object listenerToRegister);
		60
		61	/**
		62	* @author Juan Pedro Silva
		63	*/
		64	public void unRegisterLockListener(Object listenerToRegister);
		65
		66	/**
		67	* @author Juan Pedro Silva
		68	*/
		69	public void unRegisterLockListeners(Collection<Object> collToUnregister);
		70
		71	/**
		72	* @author Juan Pedro Silva
		73	*/
		74	public boolean hasListenerRegistered();
		75
		76	/**
52	* @author Simon McDuff	77	* @author Simon McDuff
53	*/	78	*/
54	public static enum LockType	79	public static enum LockType

Lines 30-39 Link Here

(-)src/org/eclipse/emf/cdo/server/internal/net4j/protocol/CDOServerProtocol.java (+36 lines)
30	import org.eclipse.net4j.channel.IChannel;	30	import org.eclipse.net4j.channel.IChannel;
31	import org.eclipse.net4j.signal.SignalProtocol;	31	import org.eclipse.net4j.signal.SignalProtocol;
32	import org.eclipse.net4j.signal.SignalReactor;	32	import org.eclipse.net4j.signal.SignalReactor;
		33	import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
33	import org.eclipse.net4j.util.io.StringCompressor;	34	import org.eclipse.net4j.util.io.StringCompressor;
34	import org.eclipse.net4j.util.io.StringIO;	35	import org.eclipse.net4j.util.io.StringIO;
35	import org.eclipse.net4j.util.lifecycle.LifecycleUtil;	36	import org.eclipse.net4j.util.lifecycle.LifecycleUtil;
36		37
		38	import java.util.Collection;
37	import java.util.List;	39	import java.util.List;
38		40
39	/**	41	/**
Lines 233-240 Link Here
233	case CDOProtocolConstants.SIGNAL_REMOTE_MESSAGE:	235	case CDOProtocolConstants.SIGNAL_REMOTE_MESSAGE:
234	return new RemoteMessageIndication(this);	236	return new RemoteMessageIndication(this);
235		237
		238	/**
		239	* @author Juan Pedro Silva
		240	*/
		241	case CDOProtocolConstants.SIGNAL_REGISTER_LOCK_LISTENER:
		242	return new RegisterLockListenerIndication(this);
		243
		244	case CDOProtocolConstants.SIGNAL_UNREGISTER_LOCK_LISTENER:
		245	return new UnregisterLockListenerIndication(this);
		246
236	default:	247	default:
237	return super.createSignalReactor(signalID);	248	return super.createSignalReactor(signalID);
238	}	249	}
239	}	250	}
		251
		252	/**
		253	* @author Juan Pedro Silva True = Lock, false = Unlock
		254	* @param lock
		255	* True = Lock, false = Unlock
		256	*/
		257	public void sendRemoteLockNotification(boolean b, String user, Collection<CDOID> cdoids, LockType lockType)
		258	{
		259	try
		260	{
		261	IChannel channel = getChannel();
		262	if (LifecycleUtil.isActive(channel))
		263	{
		264	new RemoteLockChangedNotificationRequest(channel, b, user, cdoids, lockType).sendAsync();
		265	}
		266	else
		267	{
		268	OM.LOG.warn("Session channel is inactive: " + this); //$NON-NLS-1$
		269	}
		270	}
		271	catch (Exception ex)
		272	{
		273	OM.LOG.error(ex);
		274	}
		275	}
240	}	276	}

Lines 92-97 Link Here

(-)src/org/eclipse/emf/cdo/common/protocol/CDOProtocolConstants.java (+12 lines)
92	public static final short SIGNAL_REMOTE_SESSION_NOTIFICATION = 32;	92	public static final short SIGNAL_REMOTE_SESSION_NOTIFICATION = 32;
93		93
94	// //////////////////////////////////////////////////////////////////////	94	// //////////////////////////////////////////////////////////////////////
		95	// Lock Notification
		96
		97	/**
		98	* @author Juan Pedro Silva
		99	*/
		100	public static final short SIGNAL_REGISTER_LOCK_LISTENER = 35;
		101
		102	public static final short SIGNAL_UNREGISTER_LOCK_LISTENER = 36;
		103
		104	public static final short SIGNAL_REMOTE_LOCK_CHANGED_NOTIFICATION = 37;
		105
		106	// //////////////////////////////////////////////////////////////////////
95	// Session Management	107	// Session Management
96		108
97	public static final int ERROR_REPOSITORY_NOT_FOUND = -1;	109	public static final int ERROR_REPOSITORY_NOT_FOUND = -1;