framework/bundles/org.eclipse.ecf.sync/src/org/eclipse/ecf/internal/sync/doc/cola/ColaSynchronizationStrategy.java - gerrit/ecf/org.eclipse.ecf - Git at Google

 /****************************************************************************
  * Copyright (c) 2008 Mustafa K. Isik 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:
  *    Mustafa K. Isik - initial API and implementation
  *****************************************************************************/

 package org.eclipse.ecf.internal.sync.doc.cola;

 import java.util.*;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.core.runtime.IAdapterManager;
 import org.eclipse.ecf.core.identity.ID;
 import org.eclipse.ecf.core.util.Trace;
 import org.eclipse.ecf.internal.sync.Activator;
 import org.eclipse.ecf.internal.sync.SyncDebugOptions;
 import org.eclipse.ecf.sync.*;
 import org.eclipse.ecf.sync.doc.DocumentChangeMessage;
 import org.eclipse.ecf.sync.doc.IDocumentChange;
 import org.eclipse.osgi.util.NLS;

 public class ColaSynchronizationStrategy implements
 		IModelSynchronizationStrategy {

 	// <ColaDocumentChangeMessage>
 	private final List unacknowledgedLocalOperations;
 	private final boolean isInitiator;
 	private long localOperationsCount;
 	private long remoteOperationsCount;

 	// <ID, ColaSynchronizationStrategy>
 	private static Map sessionStrategies = new HashMap();

 	private ColaSynchronizationStrategy(boolean isInitiator) {
 		this.isInitiator = isInitiator;
 		unacknowledgedLocalOperations = new LinkedList();
 		localOperationsCount = 0;
 		remoteOperationsCount = 0;
 	}

 	public static ColaSynchronizationStrategy getInstanceFor(ID client,
 			boolean isInitiator) {
 		ColaSynchronizationStrategy existingStrategy = (ColaSynchronizationStrategy) sessionStrategies
 				.get(client);
 		if (existingStrategy != null
 				&& existingStrategy.isInitiator == isInitiator)
 			return existingStrategy;
 		existingStrategy = new ColaSynchronizationStrategy(isInitiator);
 		sessionStrategies.put(client, existingStrategy);
 		return existingStrategy;
 	}

 	public static void cleanUpFor(ID client) {
 		sessionStrategies.remove(client);
 	}

 	public static void dispose() {
 		sessionStrategies.clear();
 	}

 	/**
 	 * Handles proper transformation of incoming
 	 * <code>ColaDocumentChangeMessage</code>s. Returned
 	 * <code>DocumentChangeMessage</code>s can be applied directly to the shared
 	 * document. The method implements the concurrency algorithm described in
 	 * <code>http://wiki.eclipse.org/RT_Shared_Editing</code>
 	 *
 	 * @param remoteMsg
 	 * @return List contains <code>DocumentChangeMessage</code>s ready for
 	 *         sequential application to document
 	 */
 	public List transformIncomingMessage(final DocumentChangeMessage remoteMsg) {
 		if (!(remoteMsg instanceof ColaDocumentChangeMessage)) {
 			throw new IllegalArgumentException(
 					"DocumentChangeMessage is incompatible with Cola SynchronizationStrategy"); //$NON-NLS-1$
 		}
 		Trace.entering(Activator.PLUGIN_ID, SyncDebugOptions.METHODS_ENTERING,
 				this.getClass(), "transformIncomingMessage", remoteMsg); //$NON-NLS-1$
 		ColaDocumentChangeMessage transformedRemote = (ColaDocumentChangeMessage) remoteMsg;

 		final List transformedRemotes = new LinkedList();
 		transformedRemotes.add(transformedRemote);

 		remoteOperationsCount++;
 		Trace.trace(Activator.PLUGIN_ID, "unacknowledgedLocalOperations="
 				+ unacknowledgedLocalOperations);
 		// this is where the concurrency algorithm is executed
 		if (!unacknowledgedLocalOperations.isEmpty()) {// Do not remove this. It
 														// is necessary. The
 														// following iterator
 														// does not suffice.
 			// remove operations from queue that have been implicitly
 			// acknowledged as received on the remote site by the reception of
 			// this message
 			for (final Iterator it = unacknowledgedLocalOperations.iterator(); it
 					.hasNext();) {
 				final ColaDocumentChangeMessage unackedLocalOp = (ColaDocumentChangeMessage) it
 						.next();
 				if (transformedRemote.getRemoteOperationsCount() > unackedLocalOp
 						.getLocalOperationsCount()) {
 					Trace.trace(
 							Activator.PLUGIN_ID,
 							NLS.bind(
 									"transformIncomingMessage.removing {0}", unackedLocalOp)); //$NON-NLS-1$
 					it.remove();
 				} else {
 					// the unackowledgedLocalOperations queue is ordered and
 					// sorted
 					// due to sequential insertion of local ops, thus once a
 					// local op with a higher
 					// or equal local op count (i.e. remote op count from the
 					// remote operation's view)
 					// is reached, we can abandon the check for the remaining
 					// queue items
 					Trace.trace(Activator.PLUGIN_ID,
 							"breaking out of unackedLocalOperations loop"); //$NON-NLS-1$
 					break;// exits for-loop
 				}
 			}

 			// at this point the queue has been freed of operations that
 			// don't require to be transformed against

 			if (!unacknowledgedLocalOperations.isEmpty()) {
 				ColaDocumentChangeMessage localOp = (ColaDocumentChangeMessage) unacknowledgedLocalOperations
 						.get(0);
 				Assert.isTrue(transformedRemote.getRemoteOperationsCount() == localOp
 						.getLocalOperationsCount());

 				for (final ListIterator unackOpsListIt = unacknowledgedLocalOperations
 						.listIterator(); unackOpsListIt.hasNext();) {
 					for (final ListIterator trafoRemotesIt = transformedRemotes
 							.listIterator(); trafoRemotesIt.hasNext();) {
 						// returns new instance
 						// clarify operation preference, owner/docshare
 						// initiator
 						// consistently comes first
 						localOp = (ColaDocumentChangeMessage) unackOpsListIt
 								.next();
 						transformedRemote = (ColaDocumentChangeMessage) trafoRemotesIt
 								.next();
 						transformedRemote = transformedRemote.transformAgainst(
 								localOp, isInitiator);

 						if (transformedRemote.isSplitUp()) {
 							// currently this only happens for a remote deletion
 							// that needs to be transformed against a locally
 							// applied insertion
 							// attention: before applying a list of deletions to
 							// docshare, the indices need to be
 							// updated/finalized one last time
 							// since deletions can only be applied sequentially
 							// and every deletion is going to change the
 							// underlying document and the
 							// respective indices!
 							trafoRemotesIt.remove();
 							for (final Iterator splitUpIterator = transformedRemote
 									.getSplitUpRepresentation().iterator(); splitUpIterator
 									.hasNext();) {
 								trafoRemotesIt.add(splitUpIterator.next());
 							}
 							// according to the ListIterator documentation it
 							// seems so as if the following line is unnecessary,
 							// as a call to next() after the last removal and
 							// additions will return what it would have returned
 							// anyway
 							// trafoRemotesIt.next();//TODO not sure about the
 							// need for this - I want to jump over the two
 							// inserted ops and reach the end of this iterator
 						}

 						// TODO check whether or not this collection shuffling
 						// does what it is supposed to, i.e. remove current
 						// localop in unack list and add split up representation
 						// instead
 						if (localOp.isSplitUp()) {
 							// local operation has been split up during
 							// operational transform --> remove current version
 							// and add new versions plus jump over those
 							unackOpsListIt.remove();
 							for (final Iterator splitUpOpIterator = localOp
 									.getSplitUpRepresentation().iterator(); splitUpOpIterator
 									.hasNext();) {
 								unackOpsListIt.add(splitUpOpIterator.next());
 							}
 							// according to the ListIterator documentation it
 							// seems so as if the following line is unnecessary,
 							// as a call to next() after the last removal and
 							// additions will return what it would have returned
 							// anyway
 							// unackOpsListIt.next();//TODO check whether or not
 							// this does jump over both inserted operations that
 							// replaced the current unack op
 						}// end split up localop handling
 					}// transformedRemotes List iteration
 				}
 			}

 		}
 		Trace.exiting(Activator.PLUGIN_ID, SyncDebugOptions.METHODS_EXITING,
 				this.getClass(), "transformIncomingMessage", transformedRemote); //$NON-NLS-1$

 		// TODO find a cleaner and more OO way of cleaning up the list if it
 		// contains multiple deletions:
 		if (transformedRemotes.size() > 1) {
 			final ColaDocumentChangeMessage firstOp = (ColaDocumentChangeMessage) transformedRemotes
 					.get(0);
 			if (firstOp.isDeletion()) {
 				// this means all operations in the return list must also be
 				// deletions, i.e. modify virtual/optimistic offset for
 				// sequential application to document
 				final ListIterator deletionFinalizerIt = transformedRemotes
 						.listIterator();
 				ColaDocumentChangeMessage previousDel = (ColaDocumentChangeMessage) deletionFinalizerIt
 						.next();// jump over first del-op does not need
 								// modification, we know this is OK because of
 								// previous size check;
 				ColaDocumentChangeMessage currentDel;

 				for (; deletionFinalizerIt.hasNext();) {
 					currentDel = (ColaDocumentChangeMessage) deletionFinalizerIt
 							.next();
 					currentDel.setOffset(currentDel.getOffset()
 							- previousDel.getLengthOfReplacedText());
 					previousDel = currentDel;
 				}
 			}
 		}

 		return transformedRemotes;
 	}

 	public String toString() {
 		final StringBuffer buf = new StringBuffer("ColaSynchronizationStrategy"); //$NON-NLS-1$
 		return buf.toString();
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see
 	 * org.eclipse.ecf.sync.doc.IDocumentSynchronizationStrategy#registerLocalChange
 	 * (org.eclipse.ecf.sync.doc.IModelChange)
 	 */
 	public IModelChangeMessage[] registerLocalChange(IModelChange localChange) {
 		List results = new ArrayList();
 		Trace.entering(Activator.PLUGIN_ID, SyncDebugOptions.METHODS_ENTERING,
 				this.getClass(), "registerLocalChange", localChange); //$NON-NLS-1$
 		if (localChange instanceof IDocumentChange) {
 			final IDocumentChange docChange = (IDocumentChange) localChange;
 			final ColaDocumentChangeMessage colaMsg = new ColaDocumentChangeMessage(
 					new DocumentChangeMessage(docChange.getOffset(),
 							docChange.getLengthOfReplacedText(),
 							docChange.getText()), localOperationsCount,
 					remoteOperationsCount);
 			// If not replacement, we simply add to
 			// unacknowledgedLocalOperations and add message
 			// to results
 			if (!colaMsg.isReplacement()) {
 				unacknowledgedLocalOperations.add(colaMsg);
 				localOperationsCount++;
 				results.add(colaMsg);
 			} else {
 				// It *is a replacement message, so we add both a delete and an
 				// insert message
 				// First create/add a delete message (text set to "")...
 				ColaDocumentChangeMessage delMsg = new ColaDocumentChangeMessage(
 						new DocumentChangeMessage(docChange.getOffset(),
 								docChange.getLengthOfReplacedText(), ""),
 						localOperationsCount, remoteOperationsCount);
 				unacknowledgedLocalOperations.add(delMsg);
 				localOperationsCount++;
 				results.add(delMsg);
 				// Then create/add the insert message (length set to 0)
 				ColaDocumentChangeMessage insMsg = new ColaDocumentChangeMessage(
 						new DocumentChangeMessage(docChange.getOffset(), 0,
 								docChange.getText()), localOperationsCount,
 						remoteOperationsCount);
 				unacknowledgedLocalOperations.add(insMsg);
 				localOperationsCount++;
 				results.add(insMsg);
 			}
 			Trace.exiting(Activator.PLUGIN_ID,
 					SyncDebugOptions.METHODS_EXITING, this.getClass(),
 					"registerLocalChange", colaMsg); //$NON-NLS-1$
 		}
 		return (IModelChangeMessage[]) results
 				.toArray(new IModelChangeMessage[] {});
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ecf.sync.doc.IDocumentSynchronizationStrategy#
 	 * toDocumentChangeMessage(byte[])
 	 */
 	public IModelChange deserializeRemoteChange(byte[] bytes)
 			throws SerializationException {
 		return DocumentChangeMessage.deserialize(bytes);
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.ecf.sync.doc.IDocumentSynchronizationStrategy#
 	 * transformRemoteChange(org.eclipse.ecf.sync.doc.IModelChangeMessage)
 	 */
 	public IModelChange[] transformRemoteChange(IModelChange remoteChange) {
 		if (!(remoteChange instanceof DocumentChangeMessage))
 			return new IDocumentChange[0];
 		final DocumentChangeMessage m = (DocumentChangeMessage) remoteChange;
 		final List l = this.transformIncomingMessage(m);
 		return (IDocumentChange[]) l.toArray(new IDocumentChange[] {});
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
 	 */
 	public Object getAdapter(Class adapter) {
 		if (adapter == null)
 			return null;
 		IAdapterManager manager = Activator.getDefault().getAdapterManager();
 		if (manager == null)
 			return null;
 		return manager.loadAdapter(this, adapter.getName());
 	}
 }
	/****************************************************************************
	* Copyright (c) 2008 Mustafa K. Isik 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:
	* Mustafa K. Isik - initial API and implementation
	*****************************************************************************/

	package org.eclipse.ecf.internal.sync.doc.cola;

	import java.util.*;
	import org.eclipse.core.runtime.Assert;
	import org.eclipse.core.runtime.IAdapterManager;
	import org.eclipse.ecf.core.identity.ID;
	import org.eclipse.ecf.core.util.Trace;
	import org.eclipse.ecf.internal.sync.Activator;
	import org.eclipse.ecf.internal.sync.SyncDebugOptions;
	import org.eclipse.ecf.sync.*;
	import org.eclipse.ecf.sync.doc.DocumentChangeMessage;
	import org.eclipse.ecf.sync.doc.IDocumentChange;
	import org.eclipse.osgi.util.NLS;

	public class ColaSynchronizationStrategy implements
	IModelSynchronizationStrategy {

	// <ColaDocumentChangeMessage>
	private final List unacknowledgedLocalOperations;
	private final boolean isInitiator;
	private long localOperationsCount;
	private long remoteOperationsCount;

	// <ID, ColaSynchronizationStrategy>
	private static Map sessionStrategies = new HashMap();

	private ColaSynchronizationStrategy(boolean isInitiator) {
	this.isInitiator = isInitiator;
	unacknowledgedLocalOperations = new LinkedList();
	localOperationsCount = 0;
	remoteOperationsCount = 0;
	}

	public static ColaSynchronizationStrategy getInstanceFor(ID client,
	boolean isInitiator) {
	ColaSynchronizationStrategy existingStrategy = (ColaSynchronizationStrategy) sessionStrategies
	.get(client);
	if (existingStrategy != null
	&& existingStrategy.isInitiator == isInitiator)
	return existingStrategy;
	existingStrategy = new ColaSynchronizationStrategy(isInitiator);
	sessionStrategies.put(client, existingStrategy);
	return existingStrategy;
	}

	public static void cleanUpFor(ID client) {
	sessionStrategies.remove(client);
	}

	public static void dispose() {
	sessionStrategies.clear();
	}

	/**
	* Handles proper transformation of incoming
	* <code>ColaDocumentChangeMessage</code>s. Returned
	* <code>DocumentChangeMessage</code>s can be applied directly to the shared
	* document. The method implements the concurrency algorithm described in
	* <code>http://wiki.eclipse.org/RT_Shared_Editing</code>
	*
	* @param remoteMsg
	* @return List contains <code>DocumentChangeMessage</code>s ready for
	* sequential application to document
	*/
	public List transformIncomingMessage(final DocumentChangeMessage remoteMsg) {
	if (!(remoteMsg instanceof ColaDocumentChangeMessage)) {
	throw new IllegalArgumentException(
	"DocumentChangeMessage is incompatible with Cola SynchronizationStrategy"); //$NON-NLS-1$
	}
	Trace.entering(Activator.PLUGIN_ID, SyncDebugOptions.METHODS_ENTERING,
	this.getClass(), "transformIncomingMessage", remoteMsg); //$NON-NLS-1$
	ColaDocumentChangeMessage transformedRemote = (ColaDocumentChangeMessage) remoteMsg;

	final List transformedRemotes = new LinkedList();
	transformedRemotes.add(transformedRemote);

	remoteOperationsCount++;
	Trace.trace(Activator.PLUGIN_ID, "unacknowledgedLocalOperations="
	+ unacknowledgedLocalOperations);
	// this is where the concurrency algorithm is executed
	if (!unacknowledgedLocalOperations.isEmpty()) {// Do not remove this. It
	// is necessary. The
	// following iterator
	// does not suffice.
	// remove operations from queue that have been implicitly
	// acknowledged as received on the remote site by the reception of
	// this message
	for (final Iterator it = unacknowledgedLocalOperations.iterator(); it
	.hasNext();) {
	final ColaDocumentChangeMessage unackedLocalOp = (ColaDocumentChangeMessage) it
	.next();
	if (transformedRemote.getRemoteOperationsCount() > unackedLocalOp
	.getLocalOperationsCount()) {
	Trace.trace(
	Activator.PLUGIN_ID,
	NLS.bind(
	"transformIncomingMessage.removing {0}", unackedLocalOp)); //$NON-NLS-1$
	it.remove();
	} else {
	// the unackowledgedLocalOperations queue is ordered and
	// sorted
	// due to sequential insertion of local ops, thus once a
	// local op with a higher
	// or equal local op count (i.e. remote op count from the
	// remote operation's view)
	// is reached, we can abandon the check for the remaining
	// queue items
	Trace.trace(Activator.PLUGIN_ID,
	"breaking out of unackedLocalOperations loop"); //$NON-NLS-1$
	break;// exits for-loop
	}
	}

	// at this point the queue has been freed of operations that
	// don't require to be transformed against

	if (!unacknowledgedLocalOperations.isEmpty()) {
	ColaDocumentChangeMessage localOp = (ColaDocumentChangeMessage) unacknowledgedLocalOperations
	.get(0);
	Assert.isTrue(transformedRemote.getRemoteOperationsCount() == localOp
	.getLocalOperationsCount());

	for (final ListIterator unackOpsListIt = unacknowledgedLocalOperations
	.listIterator(); unackOpsListIt.hasNext();) {
	for (final ListIterator trafoRemotesIt = transformedRemotes
	.listIterator(); trafoRemotesIt.hasNext();) {
	// returns new instance
	// clarify operation preference, owner/docshare
	// initiator
	// consistently comes first
	localOp = (ColaDocumentChangeMessage) unackOpsListIt
	.next();
	transformedRemote = (ColaDocumentChangeMessage) trafoRemotesIt
	.next();
	transformedRemote = transformedRemote.transformAgainst(
	localOp, isInitiator);

	if (transformedRemote.isSplitUp()) {
	// currently this only happens for a remote deletion
	// that needs to be transformed against a locally
	// applied insertion
	// attention: before applying a list of deletions to
	// docshare, the indices need to be
	// updated/finalized one last time
	// since deletions can only be applied sequentially
	// and every deletion is going to change the
	// underlying document and the
	// respective indices!
	trafoRemotesIt.remove();
	for (final Iterator splitUpIterator = transformedRemote
	.getSplitUpRepresentation().iterator(); splitUpIterator
	.hasNext();) {
	trafoRemotesIt.add(splitUpIterator.next());
	}
	// according to the ListIterator documentation it
	// seems so as if the following line is unnecessary,
	// as a call to next() after the last removal and
	// additions will return what it would have returned
	// anyway
	// trafoRemotesIt.next();//TODO not sure about the
	// need for this - I want to jump over the two
	// inserted ops and reach the end of this iterator
	}

	// TODO check whether or not this collection shuffling
	// does what it is supposed to, i.e. remove current
	// localop in unack list and add split up representation
	// instead
	if (localOp.isSplitUp()) {
	// local operation has been split up during
	// operational transform --> remove current version
	// and add new versions plus jump over those
	unackOpsListIt.remove();
	for (final Iterator splitUpOpIterator = localOp
	.getSplitUpRepresentation().iterator(); splitUpOpIterator
	.hasNext();) {
	unackOpsListIt.add(splitUpOpIterator.next());
	}
	// according to the ListIterator documentation it
	// seems so as if the following line is unnecessary,
	// as a call to next() after the last removal and
	// additions will return what it would have returned
	// anyway
	// unackOpsListIt.next();//TODO check whether or not
	// this does jump over both inserted operations that
	// replaced the current unack op
	}// end split up localop handling
	}// transformedRemotes List iteration
	}
	}

	}
	Trace.exiting(Activator.PLUGIN_ID, SyncDebugOptions.METHODS_EXITING,
	this.getClass(), "transformIncomingMessage", transformedRemote); //$NON-NLS-1$

	// TODO find a cleaner and more OO way of cleaning up the list if it
	// contains multiple deletions:
	if (transformedRemotes.size() > 1) {
	final ColaDocumentChangeMessage firstOp = (ColaDocumentChangeMessage) transformedRemotes
	.get(0);
	if (firstOp.isDeletion()) {
	// this means all operations in the return list must also be
	// deletions, i.e. modify virtual/optimistic offset for
	// sequential application to document
	final ListIterator deletionFinalizerIt = transformedRemotes
	.listIterator();
	ColaDocumentChangeMessage previousDel = (ColaDocumentChangeMessage) deletionFinalizerIt
	.next();// jump over first del-op does not need
	// modification, we know this is OK because of
	// previous size check;
	ColaDocumentChangeMessage currentDel;

	for (; deletionFinalizerIt.hasNext();) {
	currentDel = (ColaDocumentChangeMessage) deletionFinalizerIt
	.next();
	currentDel.setOffset(currentDel.getOffset()
	- previousDel.getLengthOfReplacedText());
	previousDel = currentDel;
	}
	}
	}

	return transformedRemotes;
	}

	public String toString() {
	final StringBuffer buf = new StringBuffer("ColaSynchronizationStrategy"); //$NON-NLS-1$
	return buf.toString();
	}

	/*
	* (non-Javadoc)
	*
	* @see
	* org.eclipse.ecf.sync.doc.IDocumentSynchronizationStrategy#registerLocalChange
	* (org.eclipse.ecf.sync.doc.IModelChange)
	*/
	public IModelChangeMessage[] registerLocalChange(IModelChange localChange) {
	List results = new ArrayList();
	Trace.entering(Activator.PLUGIN_ID, SyncDebugOptions.METHODS_ENTERING,
	this.getClass(), "registerLocalChange", localChange); //$NON-NLS-1$
	if (localChange instanceof IDocumentChange) {
	final IDocumentChange docChange = (IDocumentChange) localChange;
	final ColaDocumentChangeMessage colaMsg = new ColaDocumentChangeMessage(
	new DocumentChangeMessage(docChange.getOffset(),
	docChange.getLengthOfReplacedText(),
	docChange.getText()), localOperationsCount,
	remoteOperationsCount);
	// If not replacement, we simply add to
	// unacknowledgedLocalOperations and add message
	// to results
	if (!colaMsg.isReplacement()) {
	unacknowledgedLocalOperations.add(colaMsg);
	localOperationsCount++;
	results.add(colaMsg);
	} else {
	// It *is a replacement message, so we add both a delete and an
	// insert message
	// First create/add a delete message (text set to "")...
	ColaDocumentChangeMessage delMsg = new ColaDocumentChangeMessage(
	new DocumentChangeMessage(docChange.getOffset(),
	docChange.getLengthOfReplacedText(), ""),
	localOperationsCount, remoteOperationsCount);
	unacknowledgedLocalOperations.add(delMsg);
	localOperationsCount++;
	results.add(delMsg);
	// Then create/add the insert message (length set to 0)
	ColaDocumentChangeMessage insMsg = new ColaDocumentChangeMessage(
	new DocumentChangeMessage(docChange.getOffset(), 0,
	docChange.getText()), localOperationsCount,
	remoteOperationsCount);
	unacknowledgedLocalOperations.add(insMsg);
	localOperationsCount++;
	results.add(insMsg);
	}
	Trace.exiting(Activator.PLUGIN_ID,
	SyncDebugOptions.METHODS_EXITING, this.getClass(),
	"registerLocalChange", colaMsg); //$NON-NLS-1$
	}
	return (IModelChangeMessage[]) results
	.toArray(new IModelChangeMessage[] {});
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ecf.sync.doc.IDocumentSynchronizationStrategy#
	* toDocumentChangeMessage(byte[])
	*/
	public IModelChange deserializeRemoteChange(byte[] bytes)
	throws SerializationException {
	return DocumentChangeMessage.deserialize(bytes);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.ecf.sync.doc.IDocumentSynchronizationStrategy#
	* transformRemoteChange(org.eclipse.ecf.sync.doc.IModelChangeMessage)
	*/
	public IModelChange[] transformRemoteChange(IModelChange remoteChange) {
	if (!(remoteChange instanceof DocumentChangeMessage))
	return new IDocumentChange[0];
	final DocumentChangeMessage m = (DocumentChangeMessage) remoteChange;
	final List l = this.transformIncomingMessage(m);
	return (IDocumentChange[]) l.toArray(new IDocumentChange[] {});
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	*/
	public Object getAdapter(Class adapter) {
	if (adapter == null)
	return null;
	IAdapterManager manager = Activator.getDefault().getAdapterManager();
	if (manager == null)
	return null;
	return manager.loadAdapter(this, adapter.getName());
	}
	}