org.eclipse.mylyn.reviews.core/src/org/eclipse/mylyn/reviews/core/spi/remote/emf/RemoteEmfConsumer.java - mylyn/org.eclipse.mylyn.reviews - Git at Google

 /*******************************************************************************
  * Copyright (c) 2013 Ericsson 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:
  *     Miles Parker (Tasktop Technologies) - initial API and implementation
  *******************************************************************************/

 package org.eclipse.mylyn.reviews.core.spi.remote.emf;

 import java.util.ArrayList;
 import java.util.Collection;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
 import org.eclipse.emf.common.notify.impl.AdapterImpl;
 import org.eclipse.emf.common.notify.impl.NotificationChainImpl;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.InternalEObject;
 import org.eclipse.mylyn.reviews.core.spi.remote.AbstractRemoteConsumer;

 /**
  * Manages the interaction between a remote API and a local EMF object. There can be only one instance of a consumer for
  * a given model object or remote object per factory.
  * <p>
  * After obtaining a consumer using one of the {@link RemoteEmfConsumer} <i>AbstractRemoteEmfFactory#getConsumer()</i>
  * methods, call {@link RemoteEmfConsumer#retrieve(boolean)} to request an update. Any registered
  * {@link IRemoteEmfObserver}s will then receive an {@link IRemoteEmfObserver#updated(EObject, Object, boolean)} event
  * regardless of whether or not the actual state changed.
  *
  * @author Miles Parker
  */
 public class RemoteEmfConsumer<EParentObjectType extends EObject, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType>
 		extends AbstractRemoteConsumer {

 	private final AbstractRemoteEmfFactory<EParentObjectType, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType> factory;

 	private RemoteKeyType remoteKey;

 	private RemoteType remoteObject;

 	private final EParentObjectType parentObject;

 	private EObjectType modelObject;

 	private LocalKeyType localKey;

 	private final Collection<IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>> remoteEmfObservers;

 	private boolean pulling;

 	private boolean retrieving;

 	private boolean sending;

 	boolean userJob;

 	boolean systemJob;

 	//Can set to false for running with in another job
 	boolean asynchronous = true;

 	private class ConsumerAdapter extends AdapterImpl {

 		@Override
 		public void notifyChanged(Notification msg) {
 			if (msg instanceof RemoteNotification) {
 				RemoteNotification remoteMessage = (RemoteNotification) msg;
 				boolean notifyParent = remoteMessage.isMember()
 						&& msg.getNotifier() == parentObject
 						&& ((msg.getNewValue() == modelObject && (msg.getEventType() == RemoteNotification.REMOTE_MEMBER_CREATE || msg.getEventType() == RemoteNotification.REMOTE_MEMBER_FAILURE)) || modelObject instanceof Collection);
 				boolean notifyChild = !remoteMessage.isMember() && msg.getNotifier() == modelObject;
 				if (notifyParent || notifyChild) {
 					synchronized (remoteEmfObservers) {
 						for (IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> listener : remoteEmfObservers) {
 							switch (msg.getEventType()) {
 							case RemoteNotification.REMOTE_MEMBER_CREATE:
 								listener.created(parentObject, modelObject);
 								break;
 							case RemoteNotification.REMOTE_MEMBER_UPDATING:
 							case RemoteNotification.REMOTE_UPDATING:
 								listener.updating(parentObject, modelObject);
 								break;
 							case RemoteNotification.REMOTE_MEMBER_UPDATE:
 							case RemoteNotification.REMOTE_UPDATE:
 								listener.updated(parentObject, modelObject, remoteMessage.isModification());
 								break;
 							case RemoteNotification.REMOTE_SENDING:
 								listener.sending(parentObject, modelObject);
 								break;
 							case RemoteNotification.REMOTE_SEND:
 								listener.sent(parentObject, modelObject);
 								break;
 							case RemoteNotification.REMOTE_MEMBER_FAILURE:
 							case RemoteNotification.REMOTE_FAILURE:
 								listener.failed(parentObject, modelObject, remoteMessage.getStatus());
 							}
 						}
 					}
 				}
 			}
 		}
 	}

 	ConsumerAdapter adapter = new ConsumerAdapter();

 	RemoteEmfConsumer(
 			AbstractRemoteEmfFactory<EParentObjectType, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType> factory,
 			EParentObjectType parent, EObjectType modelObject, LocalKeyType localKey, RemoteType remoteObject,
 			RemoteKeyType remoteKey) {
 		this.parentObject = parent;
 		this.modelObject = modelObject;
 		this.remoteObject = remoteObject;
 		this.remoteKey = remoteKey;
 		this.localKey = localKey;
 		this.factory = factory;
 		if (remoteKey == null && remoteObject != null) {
 			this.remoteKey = factory.getRemoteKey(remoteObject);
 		}
 		if (localKey == null && modelObject != null) {
 			this.localKey = factory.getLocalKey(null, modelObject);
 		}
 		if (modelObject instanceof EObject) {
 			((EObject) modelObject).eAdapters().add(adapter);
 		} else if (parent != null) {
 			parent.eAdapters().add(adapter);
 		}
 		remoteEmfObservers = new ArrayList<IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>>();
 	}

 	/**
 	 * Pulls the results from the factory, populating the remote object with the latest state from the remote API.
 	 * Blocks until the remote API call completes. Does nothing if a retrieval is already occurring.
 	 * <em>This method must not be called from the UI thread.</em>
 	 *
 	 * @param force
 	 *            pull from remote even when API doesn't require
 	 * @param monitor
 	 * @throws CoreException
 	 */
 	@Override
 	public void pull(boolean force, IProgressMonitor monitor) throws CoreException {
 		pulling = true;
 		if (remoteObject != null && remoteKey == null) {
 			remoteKey = factory.getRemoteKey(remoteObject);
 		}
 		if (remoteKey == null && localKey != null) {
 			remoteKey = factory.getRemoteKeyForLocalKey(parentObject, localKey);
 		}
 		//Pull when "needed" or forced, but not when we don't have a remote key as that would be pointless.
 		if ((factory.isPullNeeded(parentObject, modelObject, remoteObject) || force == true) && remoteKey != null) {

 			getFactory().getService().modelExec(new Runnable() {
 				public void run() {
 					parentObject.eNotify(new RemoteENotificationImpl((InternalEObject) parentObject,
 							RemoteNotification.REMOTE_MEMBER_UPDATING, factory.getParentReference(), modelObject));
 					if (modelObject instanceof EObject) {
 						((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
 								RemoteNotification.REMOTE_MEMBER_UPDATING, null, null));
 					}
 				}
 			}, false);
 			try {
 				remoteObject = factory.pull(parentObject, remoteKey, monitor);
 				if (localKey == null) {
 					localKey = factory.getLocalKeyForRemoteObject(remoteObject);
 				}
 				pulling = false;
 			} catch (final CoreException e) {
 				getFactory().getService().modelExec(new Runnable() {
 					public void run() {
 						parentObject.eNotify(new RemoteENotificationImpl((InternalEObject) parentObject,
 								RemoteNotification.REMOTE_MEMBER_FAILURE, factory.getParentReference(), null,
 								e.getStatus()));
 						if (modelObject instanceof EObject) {
 							((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
 									RemoteNotification.REMOTE_FAILURE, null, null, e.getStatus()));
 						}
 					}
 				}, false);
 				throw e;
 			}
 		}
 		pulling = false;
 	}

 	/**
 	 * Returns true whenever the consumer is pulling from Remote API to update the remote state, that is after
 	 * {@link #retrieve(boolean)} has been called but before the {@link RemoteEmfConsumer#applyModel(boolean)} call has
 	 * occurred.
 	 */
 	public boolean isPulling() {
 		return pulling;
 	}

 	@Override
 	public void push(boolean force, IProgressMonitor monitor) throws CoreException {
 		if (remoteObject == null) {
 			throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.mylyn.reviews.core",
 					"Tried to push without a remote object!"));
 		}
 		if (modelObject == null) {
 			throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.mylyn.reviews.core",
 					"Tried to push without a model object!"));
 		}
 		if (modelObject instanceof EObject) {
 			getFactory().getService().modelExec(new Runnable() {
 				@Override
 				public void run() {
 					((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
 							RemoteNotification.REMOTE_SENDING, null, null));
 				}
 			});
 		}
 		if (factory.isPushNeeded(parentObject, modelObject, remoteObject)) {
 			factory.push(remoteObject, monitor);
 		}
 		if (modelObject instanceof EObject) {
 			getFactory().getService().modelExec(new Runnable() {
 				@Override
 				public void run() {
 					((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
 							RemoteNotification.REMOTE_SEND, null, null));
 				}
 			});
 		}
 	}

 	@Override
 	public void applyRemote(boolean force) {
 		factory.updateRemote(parentObject, modelObject, remoteObject);
 	}

 	/**
 	 * Apply the remote object to the local model object.
 	 * <em>This method must be called from the EMF managed (e.g.) UI thread.</em>
 	 *
 	 * @param force
 	 *            apply the changes even when API doesn't require
 	 * @throws CoreException
 	 */
 	@Override
 	public void applyModel(boolean force) {
 		NotificationChain msgs = new NotificationChainImpl();
 		EReference reference = factory.getParentReference();
 		boolean modified = false;
 		if (remoteObject != null) {
 			if (modelObject == null || factory.isCreateModelNeeded(parentObject, modelObject)
 					|| (reference.isMany() && (((Collection<?>) parentObject.eGet(reference)).size() == 0))) {
 				modified = true;
 				modelObject = factory.createModel(parentObject, remoteObject);
 				if (reference.isMany()) {
 					if (modelObject instanceof Collection) {
 						((EList<EObjectType>) parentObject.eGet(reference)).addAll((Collection<EObjectType>) modelObject);
 					} else {
 						((EList<EObjectType>) parentObject.eGet(reference)).add(modelObject);
 					}
 				} else {
 					parentObject.eSet(reference, modelObject);
 				}
 				if (modelObject instanceof EObject) {
 					((EObject) modelObject).eSet(factory.getLocalKeyAttribute(),
 							factory.getLocalKeyForRemoteObject(remoteObject));
 					if (!((EObject) modelObject).eAdapters().contains(adapter)) {
 						((EObject) modelObject).eAdapters().add(adapter);
 					}
 				}
 				msgs.add(new RemoteENotificationImpl((InternalEObject) parentObject,
 						RemoteNotification.REMOTE_MEMBER_CREATE, reference, modelObject));
 			}
 			if (factory.isUpdateModelNeeded(parentObject, modelObject, remoteObject) || force) {
 				modified |= factory.updateModel(parentObject, modelObject, remoteObject);
 			}
 		}
 		msgs.add(new RemoteENotificationImpl((InternalEObject) parentObject, RemoteNotification.REMOTE_MEMBER_UPDATE,
 				reference, modelObject, modified));
 		if (modelObject instanceof EObject) {
 			msgs.add(new RemoteENotificationImpl((InternalEObject) modelObject, RemoteNotification.REMOTE_UPDATE, null,
 					null, modified));
 		}
 		retrieving = false;
 		msgs.dispatch();
 	}

 	/**
 	 * Returns true whenever the consumer is updating model state, that is after a {@link #retrieve(boolean)} has been
 	 * called and until immediately after the {@link IRemoteEmfObserver#updated(EObject, Object, boolean)} has been
 	 * called.
 	 */
 	public boolean isRetrieving() {
 		return retrieving;
 	}

 	/**
 	 * Performs a complete remote request, result application and listener notification against the factory. This is the
 	 * method primary factory consumers will be interested in. The method will asynchronously (as defined by remote
 	 * service implementation):<li>
 	 * <ol>
 	 * Notify any registered {@link IRemoteEmfObserver}s that the object is
 	 * {@link IRemoteEmfObserver#updating(EObject, Object)}.
 	 * </ol>
 	 * <ol>
 	 * Call the remote API, retrieving the results into a local object representing the contents of the remote object.
 	 * </ol>
 	 * <ol>
 	 * If the object does not yet exist, one will be created and added to the appropriate parent object.
 	 * </ol>
 	 * <ol>
 	 * Notify objects of any changes via the standard EMF notification mechanisms. (As a by-product of the above step.)
 	 * </ol>
 	 * <ol>
 	 * Notify any registered {@link IRemoteEmfObserver}s of object creation or update. (An update is notified even if
 	 * object state does not change.)
 	 * </ol>
 	 * </li>
 	 *
 	 * @param force
 	 *            Forces pull and update, even if factory methods
 	 *            {@link AbstractRemoteEmfFactory#isPullNeeded(EObject, Object, Object)} and/or
 	 *            {@link AbstractRemoteEmfFactory#isUpdateModelNeeded(EObject, Object, Object)} return false.
 	 */
 	public void retrieve(boolean force) {
 		if (retrieving) {
 			return;
 		}
 		retrieving = true;
 		getFactory().getService().retrieve(this, force);
 	}

 	/**
 	 * Performs a complete remote send, updating the remote value and then pushing it to the Remote API.
 	 * <ol>
 	 *
 	 * @param force
 	 *            Forces update and push, even if factory methods
 	 *            {@link AbstractRemoteEmfFactory#isPushNeeded(EObject, Object, Object)} returns false.
 	 */
 	public void send(boolean force) {
 		if (sending) {
 			return;
 		}
 		sending = true;
 		getFactory().getService().send(this, force);
 	}

 	/**
 	 * Notifies the consumer that a failure has occurred while performing a retrieval. (Consumers should generally
 	 * handle update and failure notifications through the {@link IRemoteEmfObserver#failed(IStatus)} method instead.)
 	 */
 	@Override
 	public void notifyDone(IStatus status) {
 		retrieving = false;
 		sending = false;
 	}

 	/**
 	 * Unregisters all listeners and adapters.
 	 */
 	@Override
 	public void dispose() {
 		retrieving = false;
 		parentObject.eAdapters().remove(adapter);
 		if (modelObject instanceof EObject) {
 			((EObject) modelObject).eAdapters().remove(adapter);
 		}
 		synchronized (remoteEmfObservers) {
 			remoteEmfObservers.clear();
 		}
 		getFactory().removeConsumer(this);
 		if (getModelObject() instanceof EObject) {
 			getFactory().getFactoryProvider().close((EObject) getModelObject());
 		}
 		modelObject = null;
 		remoteObject = null;
 	}

 	/**
 	 * Adds an observer to this consumer. Updates the consumer field for {@link RemoteEmfObserver}s.
 	 *
 	 * @param observer
 	 *            The observer to add
 	 */
 	public void addObserver(IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> observer) {
 		if (observer instanceof RemoteEmfObserver) {
 			RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> remoteEmfObserver = (RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>) observer;
 			if (remoteEmfObserver.getConsumer() != null && remoteEmfObserver.getConsumer() != this) {
 				remoteEmfObserver.getConsumer().removeObserver(remoteEmfObserver);
 			}
 			remoteEmfObserver.internalSetConsumer(this);
 		}
 		synchronized (remoteEmfObservers) {
 			remoteEmfObservers.add(observer);
 		}
 		if (modelObject instanceof EObject) {
 			if (!((EObject) modelObject).eAdapters().contains(adapter)) {
 				((EObject) modelObject).eAdapters().add(adapter);
 			}
 		} else if (parentObject != null) {
 			if (!((EObject) parentObject).eAdapters().contains(adapter)) {
 				((EObject) parentObject).eAdapters().add(adapter);
 			}
 		}

 	}

 	/**
 	 * Adds an observer to this consumer. Updates the consumer field for {@link RemoteEmfObserver}s.
 	 *
 	 * @param observer
 	 *            The observer to remove
 	 */
 	public void removeObserver(
 			IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> observer) {
 		if (observer instanceof RemoteEmfObserver) {
 			RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> remoteEmfObserver = (RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>) observer;
 			if (remoteEmfObserver.getConsumer() == this) {
 				remoteEmfObserver.internalSetConsumer(null);
 			}
 		}
 		synchronized (remoteEmfObservers) {
 			remoteEmfObservers.remove(observer);
 		}
 		release();
 	}

 	public void release() {
 		if (remoteEmfObservers.size() == 0) {
 			dispose();
 		}
 	}

 	public void updateObservers() {
 		NotificationChain msgs = new NotificationChainImpl();
 		msgs.add(new RemoteENotificationImpl((InternalEObject) parentObject, RemoteNotification.REMOTE_MEMBER_UPDATE,
 				factory.getParentReference(), modelObject, false));
 		if (modelObject instanceof EObject) {
 			msgs.add(new RemoteENotificationImpl((InternalEObject) modelObject, RemoteNotification.REMOTE_UPDATE, null,
 					null, false));
 		}
 		msgs.dispatch();
 	}

 	/**
 	 * Returns the factory that providing services and objects for this consumer.
 	 */
 	public AbstractRemoteEmfFactory<EParentObjectType, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType> getFactory() {
 		return factory;
 	}

 	public void open() {
 		Object object = getFactory().open(parentObject, localKey);
 		if (object instanceof EObject) {
 			modelObject = (EObjectType) object;
 			getFactory().getService().modelExec(new Runnable() {
 				@Override
 				public void run() {
 					if (!((EObject) modelObject).eAdapters().contains(adapter)) {
 						((EObject) modelObject).eAdapters().add(adapter);
 					}
 				}
 			}, true);
 		}
 	}

 	public void save() {
 		if (getModelObject() instanceof EObject) {
 			getFactory().getFactoryProvider().save();
 			getFactory().getFactoryProvider().save((EObject) getModelObject());
 		}
 	}

 	/**
 	 * Returns the parent object for this consumer.
 	 */
 	public EParentObjectType getParentObject() {
 		return parentObject;
 	}

 	/**
 	 * Returns the model object for this consumer, if one has been obtained through the {@link #retrieve(boolean)}
 	 * method or supplied when any object obtained this consumer.
 	 */
 	public EObjectType getModelObject() {
 		return modelObject;
 	}

 	/**
 	 * Returns the local key supplied by the consumer, or the local remote key if it can be inferred from the remote key
 	 * or remote object.
 	 */
 	public LocalKeyType getLocalKey() {
 		if (localKey != null) {
 			return localKey;
 		} else if (remoteKey != null) {
 			return getFactory().getLocalKeyForRemoteKey(remoteKey);
 		} else if (remoteObject != null) {
 			return getFactory().getLocalKeyForRemoteObject(remoteObject);
 		}
 		return null;
 	}

 	/**
 	 * Returns the remote key for this consumer.
 	 */
 	public RemoteKeyType getRemoteKey() {
 		return remoteKey;
 	}

 	/**
 	 * Returns the remote object that maps to this consumer's model object, local key or remote key, if one has been
 	 * supplied or obtained using the remote key.
 	 *
 	 * @return
 	 */
 	public RemoteType getRemoteObject() {
 		return remoteObject;
 	}

 	/**
 	 * Should only be called by RemoteEmfFactory.
 	 *
 	 * @param remoteObject
 	 */
 	void setRemoteObject(RemoteType remoteObject) {
 		if (!factory.getLocalKeyForRemoteObject(remoteObject).equals(getLocalKey())) {
 			throw new RuntimeException(
 					"Internal Error. Tried to set a remote object that doesn't match existing local key or object.");
 		}
 		this.remoteObject = remoteObject;
 	}

 	/**
 	 * Should only be called by RemoteEmfFactory.
 	 *
 	 * @param remoteObject
 	 */
 	void setRemoteKey(RemoteKeyType remoteKey) {
 		if (!factory.getLocalKeyForRemoteKey(remoteKey).equals(getLocalKey())) {
 			throw new RuntimeException(
 					"Internal Error. Tried to set a remote object that doesn't match existing local key or object.");
 		}
 		this.remoteKey = remoteKey;
 	}

 	@Override
 	public String getDescription() {
 		return "Retrieving " + factory.getModelDescription(getParentObject(), getModelObject(), getLocalKey());
 	}

 	@Override
 	public boolean isUserJob() {
 		return userJob;
 	}

 	public void setUiJob(boolean userJob) {
 		this.userJob = userJob;
 	}

 	@Override
 	public boolean isSystemJob() {
 		return systemJob;
 	}

 	public void setSystemJob(boolean systemJob) {
 		this.systemJob = systemJob;
 	}

 	@Override
 	public boolean isAsynchronous() {
 		return getFactory().isAsynchronous() && asynchronous;
 	}

 	public void setAsynchronous(boolean asynchronous) {
 		this.asynchronous = asynchronous;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2013 Ericsson 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:
	* Miles Parker (Tasktop Technologies) - initial API and implementation
	*******************************************************************************/

	package org.eclipse.mylyn.reviews.core.spi.remote.emf;

	import java.util.ArrayList;
	import java.util.Collection;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.notify.NotificationChain;
	import org.eclipse.emf.common.notify.impl.AdapterImpl;
	import org.eclipse.emf.common.notify.impl.NotificationChainImpl;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EReference;
	import org.eclipse.emf.ecore.InternalEObject;
	import org.eclipse.mylyn.reviews.core.spi.remote.AbstractRemoteConsumer;

	/**
	* Manages the interaction between a remote API and a local EMF object. There can be only one instance of a consumer for
	* a given model object or remote object per factory.
	* <p>
	* After obtaining a consumer using one of the {@link RemoteEmfConsumer} <i>AbstractRemoteEmfFactory#getConsumer()</i>
	* methods, call {@link RemoteEmfConsumer#retrieve(boolean)} to request an update. Any registered
	* {@link IRemoteEmfObserver}s will then receive an {@link IRemoteEmfObserver#updated(EObject, Object, boolean)} event
	* regardless of whether or not the actual state changed.
	*
	* @author Miles Parker
	*/
	public class RemoteEmfConsumer<EParentObjectType extends EObject, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType>
	extends AbstractRemoteConsumer {

	private final AbstractRemoteEmfFactory<EParentObjectType, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType> factory;

	private RemoteKeyType remoteKey;

	private RemoteType remoteObject;

	private final EParentObjectType parentObject;

	private EObjectType modelObject;

	private LocalKeyType localKey;

	private final Collection<IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>> remoteEmfObservers;

	private boolean pulling;

	private boolean retrieving;

	private boolean sending;

	boolean userJob;

	boolean systemJob;

	//Can set to false for running with in another job
	boolean asynchronous = true;

	private class ConsumerAdapter extends AdapterImpl {

	@Override
	public void notifyChanged(Notification msg) {
	if (msg instanceof RemoteNotification) {
	RemoteNotification remoteMessage = (RemoteNotification) msg;
	boolean notifyParent = remoteMessage.isMember()
	&& msg.getNotifier() == parentObject
	&& ((msg.getNewValue() == modelObject && (msg.getEventType() == RemoteNotification.REMOTE_MEMBER_CREATE \|\| msg.getEventType() == RemoteNotification.REMOTE_MEMBER_FAILURE)) \|\| modelObject instanceof Collection);
	boolean notifyChild = !remoteMessage.isMember() && msg.getNotifier() == modelObject;
	if (notifyParent \|\| notifyChild) {
	synchronized (remoteEmfObservers) {
	for (IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> listener : remoteEmfObservers) {
	switch (msg.getEventType()) {
	case RemoteNotification.REMOTE_MEMBER_CREATE:
	listener.created(parentObject, modelObject);
	break;
	case RemoteNotification.REMOTE_MEMBER_UPDATING:
	case RemoteNotification.REMOTE_UPDATING:
	listener.updating(parentObject, modelObject);
	break;
	case RemoteNotification.REMOTE_MEMBER_UPDATE:
	case RemoteNotification.REMOTE_UPDATE:
	listener.updated(parentObject, modelObject, remoteMessage.isModification());
	break;
	case RemoteNotification.REMOTE_SENDING:
	listener.sending(parentObject, modelObject);
	break;
	case RemoteNotification.REMOTE_SEND:
	listener.sent(parentObject, modelObject);
	break;
	case RemoteNotification.REMOTE_MEMBER_FAILURE:
	case RemoteNotification.REMOTE_FAILURE:
	listener.failed(parentObject, modelObject, remoteMessage.getStatus());
	}
	}
	}
	}
	}
	}
	}

	ConsumerAdapter adapter = new ConsumerAdapter();

	RemoteEmfConsumer(
	AbstractRemoteEmfFactory<EParentObjectType, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType> factory,
	EParentObjectType parent, EObjectType modelObject, LocalKeyType localKey, RemoteType remoteObject,
	RemoteKeyType remoteKey) {
	this.parentObject = parent;
	this.modelObject = modelObject;
	this.remoteObject = remoteObject;
	this.remoteKey = remoteKey;
	this.localKey = localKey;
	this.factory = factory;
	if (remoteKey == null && remoteObject != null) {
	this.remoteKey = factory.getRemoteKey(remoteObject);
	}
	if (localKey == null && modelObject != null) {
	this.localKey = factory.getLocalKey(null, modelObject);
	}
	if (modelObject instanceof EObject) {
	((EObject) modelObject).eAdapters().add(adapter);
	} else if (parent != null) {
	parent.eAdapters().add(adapter);
	}
	remoteEmfObservers = new ArrayList<IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>>();
	}

	/**
	* Pulls the results from the factory, populating the remote object with the latest state from the remote API.
	* Blocks until the remote API call completes. Does nothing if a retrieval is already occurring.
	* <em>This method must not be called from the UI thread.</em>
	*
	* @param force
	* pull from remote even when API doesn't require
	* @param monitor
	* @throws CoreException
	*/
	@Override
	public void pull(boolean force, IProgressMonitor monitor) throws CoreException {
	pulling = true;
	if (remoteObject != null && remoteKey == null) {
	remoteKey = factory.getRemoteKey(remoteObject);
	}
	if (remoteKey == null && localKey != null) {
	remoteKey = factory.getRemoteKeyForLocalKey(parentObject, localKey);
	}
	//Pull when "needed" or forced, but not when we don't have a remote key as that would be pointless.
	if ((factory.isPullNeeded(parentObject, modelObject, remoteObject) \|\| force == true) && remoteKey != null) {

	getFactory().getService().modelExec(new Runnable() {
	public void run() {
	parentObject.eNotify(new RemoteENotificationImpl((InternalEObject) parentObject,
	RemoteNotification.REMOTE_MEMBER_UPDATING, factory.getParentReference(), modelObject));
	if (modelObject instanceof EObject) {
	((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
	RemoteNotification.REMOTE_MEMBER_UPDATING, null, null));
	}
	}
	}, false);
	try {
	remoteObject = factory.pull(parentObject, remoteKey, monitor);
	if (localKey == null) {
	localKey = factory.getLocalKeyForRemoteObject(remoteObject);
	}
	pulling = false;
	} catch (final CoreException e) {
	getFactory().getService().modelExec(new Runnable() {
	public void run() {
	parentObject.eNotify(new RemoteENotificationImpl((InternalEObject) parentObject,
	RemoteNotification.REMOTE_MEMBER_FAILURE, factory.getParentReference(), null,
	e.getStatus()));
	if (modelObject instanceof EObject) {
	((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
	RemoteNotification.REMOTE_FAILURE, null, null, e.getStatus()));
	}
	}
	}, false);
	throw e;
	}
	}
	pulling = false;
	}

	/**
	* Returns true whenever the consumer is pulling from Remote API to update the remote state, that is after
	* {@link #retrieve(boolean)} has been called but before the {@link RemoteEmfConsumer#applyModel(boolean)} call has
	* occurred.
	*/
	public boolean isPulling() {
	return pulling;
	}

	@Override
	public void push(boolean force, IProgressMonitor monitor) throws CoreException {
	if (remoteObject == null) {
	throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.mylyn.reviews.core",
	"Tried to push without a remote object!"));
	}
	if (modelObject == null) {
	throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.mylyn.reviews.core",
	"Tried to push without a model object!"));
	}
	if (modelObject instanceof EObject) {
	getFactory().getService().modelExec(new Runnable() {
	@Override
	public void run() {
	((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
	RemoteNotification.REMOTE_SENDING, null, null));
	}
	});
	}
	if (factory.isPushNeeded(parentObject, modelObject, remoteObject)) {
	factory.push(remoteObject, monitor);
	}
	if (modelObject instanceof EObject) {
	getFactory().getService().modelExec(new Runnable() {
	@Override
	public void run() {
	((EObject) modelObject).eNotify(new RemoteENotificationImpl((InternalEObject) modelObject,
	RemoteNotification.REMOTE_SEND, null, null));
	}
	});
	}
	}

	@Override
	public void applyRemote(boolean force) {
	factory.updateRemote(parentObject, modelObject, remoteObject);
	}

	/**
	* Apply the remote object to the local model object.
	* <em>This method must be called from the EMF managed (e.g.) UI thread.</em>
	*
	* @param force
	* apply the changes even when API doesn't require
	* @throws CoreException
	*/
	@Override
	public void applyModel(boolean force) {
	NotificationChain msgs = new NotificationChainImpl();
	EReference reference = factory.getParentReference();
	boolean modified = false;
	if (remoteObject != null) {
	if (modelObject == null \|\| factory.isCreateModelNeeded(parentObject, modelObject)
	\|\| (reference.isMany() && (((Collection<?>) parentObject.eGet(reference)).size() == 0))) {
	modified = true;
	modelObject = factory.createModel(parentObject, remoteObject);
	if (reference.isMany()) {
	if (modelObject instanceof Collection) {
	((EList<EObjectType>) parentObject.eGet(reference)).addAll((Collection<EObjectType>) modelObject);
	} else {
	((EList<EObjectType>) parentObject.eGet(reference)).add(modelObject);
	}
	} else {
	parentObject.eSet(reference, modelObject);
	}
	if (modelObject instanceof EObject) {
	((EObject) modelObject).eSet(factory.getLocalKeyAttribute(),
	factory.getLocalKeyForRemoteObject(remoteObject));
	if (!((EObject) modelObject).eAdapters().contains(adapter)) {
	((EObject) modelObject).eAdapters().add(adapter);
	}
	}
	msgs.add(new RemoteENotificationImpl((InternalEObject) parentObject,
	RemoteNotification.REMOTE_MEMBER_CREATE, reference, modelObject));
	}
	if (factory.isUpdateModelNeeded(parentObject, modelObject, remoteObject) \|\| force) {
	modified \|= factory.updateModel(parentObject, modelObject, remoteObject);
	}
	}
	msgs.add(new RemoteENotificationImpl((InternalEObject) parentObject, RemoteNotification.REMOTE_MEMBER_UPDATE,
	reference, modelObject, modified));
	if (modelObject instanceof EObject) {
	msgs.add(new RemoteENotificationImpl((InternalEObject) modelObject, RemoteNotification.REMOTE_UPDATE, null,
	null, modified));
	}
	retrieving = false;
	msgs.dispatch();
	}

	/**
	* Returns true whenever the consumer is updating model state, that is after a {@link #retrieve(boolean)} has been
	* called and until immediately after the {@link IRemoteEmfObserver#updated(EObject, Object, boolean)} has been
	* called.
	*/
	public boolean isRetrieving() {
	return retrieving;
	}

	/**
	* Performs a complete remote request, result application and listener notification against the factory. This is the
	* method primary factory consumers will be interested in. The method will asynchronously (as defined by remote
	* service implementation):<li>
	* <ol>
	* Notify any registered {@link IRemoteEmfObserver}s that the object is
	* {@link IRemoteEmfObserver#updating(EObject, Object)}.
	* </ol>
	* <ol>
	* Call the remote API, retrieving the results into a local object representing the contents of the remote object.
	* </ol>
	* <ol>
	* If the object does not yet exist, one will be created and added to the appropriate parent object.
	* </ol>
	* <ol>
	* Notify objects of any changes via the standard EMF notification mechanisms. (As a by-product of the above step.)
	* </ol>
	* <ol>
	* Notify any registered {@link IRemoteEmfObserver}s of object creation or update. (An update is notified even if
	* object state does not change.)
	* </ol>
	* </li>
	*
	* @param force
	* Forces pull and update, even if factory methods
	* {@link AbstractRemoteEmfFactory#isPullNeeded(EObject, Object, Object)} and/or
	* {@link AbstractRemoteEmfFactory#isUpdateModelNeeded(EObject, Object, Object)} return false.
	*/
	public void retrieve(boolean force) {
	if (retrieving) {
	return;
	}
	retrieving = true;
	getFactory().getService().retrieve(this, force);
	}

	/**
	* Performs a complete remote send, updating the remote value and then pushing it to the Remote API.
	* <ol>
	*
	* @param force
	* Forces update and push, even if factory methods
	* {@link AbstractRemoteEmfFactory#isPushNeeded(EObject, Object, Object)} returns false.
	*/
	public void send(boolean force) {
	if (sending) {
	return;
	}
	sending = true;
	getFactory().getService().send(this, force);
	}

	/**
	* Notifies the consumer that a failure has occurred while performing a retrieval. (Consumers should generally
	* handle update and failure notifications through the {@link IRemoteEmfObserver#failed(IStatus)} method instead.)
	*/
	@Override
	public void notifyDone(IStatus status) {
	retrieving = false;
	sending = false;
	}

	/**
	* Unregisters all listeners and adapters.
	*/
	@Override
	public void dispose() {
	retrieving = false;
	parentObject.eAdapters().remove(adapter);
	if (modelObject instanceof EObject) {
	((EObject) modelObject).eAdapters().remove(adapter);
	}
	synchronized (remoteEmfObservers) {
	remoteEmfObservers.clear();
	}
	getFactory().removeConsumer(this);
	if (getModelObject() instanceof EObject) {
	getFactory().getFactoryProvider().close((EObject) getModelObject());
	}
	modelObject = null;
	remoteObject = null;
	}

	/**
	* Adds an observer to this consumer. Updates the consumer field for {@link RemoteEmfObserver}s.
	*
	* @param observer
	* The observer to add
	*/
	public void addObserver(IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> observer) {
	if (observer instanceof RemoteEmfObserver) {
	RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> remoteEmfObserver = (RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>) observer;
	if (remoteEmfObserver.getConsumer() != null && remoteEmfObserver.getConsumer() != this) {
	remoteEmfObserver.getConsumer().removeObserver(remoteEmfObserver);
	}
	remoteEmfObserver.internalSetConsumer(this);
	}
	synchronized (remoteEmfObservers) {
	remoteEmfObservers.add(observer);
	}
	if (modelObject instanceof EObject) {
	if (!((EObject) modelObject).eAdapters().contains(adapter)) {
	((EObject) modelObject).eAdapters().add(adapter);
	}
	} else if (parentObject != null) {
	if (!((EObject) parentObject).eAdapters().contains(adapter)) {
	((EObject) parentObject).eAdapters().add(adapter);
	}
	}

	}

	/**
	* Adds an observer to this consumer. Updates the consumer field for {@link RemoteEmfObserver}s.
	*
	* @param observer
	* The observer to remove
	*/
	public void removeObserver(
	IRemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> observer) {
	if (observer instanceof RemoteEmfObserver) {
	RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType> remoteEmfObserver = (RemoteEmfObserver<EParentObjectType, EObjectType, LocalKeyType, ObjectCurrentType>) observer;
	if (remoteEmfObserver.getConsumer() == this) {
	remoteEmfObserver.internalSetConsumer(null);
	}
	}
	synchronized (remoteEmfObservers) {
	remoteEmfObservers.remove(observer);
	}
	release();
	}

	public void release() {
	if (remoteEmfObservers.size() == 0) {
	dispose();
	}
	}

	public void updateObservers() {
	NotificationChain msgs = new NotificationChainImpl();
	msgs.add(new RemoteENotificationImpl((InternalEObject) parentObject, RemoteNotification.REMOTE_MEMBER_UPDATE,
	factory.getParentReference(), modelObject, false));
	if (modelObject instanceof EObject) {
	msgs.add(new RemoteENotificationImpl((InternalEObject) modelObject, RemoteNotification.REMOTE_UPDATE, null,
	null, false));
	}
	msgs.dispatch();
	}

	/**
	* Returns the factory that providing services and objects for this consumer.
	*/
	public AbstractRemoteEmfFactory<EParentObjectType, EObjectType, LocalKeyType, RemoteType, RemoteKeyType, ObjectCurrentType> getFactory() {
	return factory;
	}

	public void open() {
	Object object = getFactory().open(parentObject, localKey);
	if (object instanceof EObject) {
	modelObject = (EObjectType) object;
	getFactory().getService().modelExec(new Runnable() {
	@Override
	public void run() {
	if (!((EObject) modelObject).eAdapters().contains(adapter)) {
	((EObject) modelObject).eAdapters().add(adapter);
	}
	}
	}, true);
	}
	}

	public void save() {
	if (getModelObject() instanceof EObject) {
	getFactory().getFactoryProvider().save();
	getFactory().getFactoryProvider().save((EObject) getModelObject());
	}
	}

	/**
	* Returns the parent object for this consumer.
	*/
	public EParentObjectType getParentObject() {
	return parentObject;
	}

	/**
	* Returns the model object for this consumer, if one has been obtained through the {@link #retrieve(boolean)}
	* method or supplied when any object obtained this consumer.
	*/
	public EObjectType getModelObject() {
	return modelObject;
	}

	/**
	* Returns the local key supplied by the consumer, or the local remote key if it can be inferred from the remote key
	* or remote object.
	*/
	public LocalKeyType getLocalKey() {
	if (localKey != null) {
	return localKey;
	} else if (remoteKey != null) {
	return getFactory().getLocalKeyForRemoteKey(remoteKey);
	} else if (remoteObject != null) {
	return getFactory().getLocalKeyForRemoteObject(remoteObject);
	}
	return null;
	}

	/**
	* Returns the remote key for this consumer.
	*/
	public RemoteKeyType getRemoteKey() {
	return remoteKey;
	}

	/**
	* Returns the remote object that maps to this consumer's model object, local key or remote key, if one has been
	* supplied or obtained using the remote key.
	*
	* @return
	*/
	public RemoteType getRemoteObject() {
	return remoteObject;
	}

	/**
	* Should only be called by RemoteEmfFactory.
	*
	* @param remoteObject
	*/
	void setRemoteObject(RemoteType remoteObject) {
	if (!factory.getLocalKeyForRemoteObject(remoteObject).equals(getLocalKey())) {
	throw new RuntimeException(
	"Internal Error. Tried to set a remote object that doesn't match existing local key or object.");
	}
	this.remoteObject = remoteObject;
	}

	/**
	* Should only be called by RemoteEmfFactory.
	*
	* @param remoteObject
	*/
	void setRemoteKey(RemoteKeyType remoteKey) {
	if (!factory.getLocalKeyForRemoteKey(remoteKey).equals(getLocalKey())) {
	throw new RuntimeException(
	"Internal Error. Tried to set a remote object that doesn't match existing local key or object.");
	}
	this.remoteKey = remoteKey;
	}

	@Override
	public String getDescription() {
	return "Retrieving " + factory.getModelDescription(getParentObject(), getModelObject(), getLocalKey());
	}

	@Override
	public boolean isUserJob() {
	return userJob;
	}

	public void setUiJob(boolean userJob) {
	this.userJob = userJob;
	}

	@Override
	public boolean isSystemJob() {
	return systemJob;
	}

	public void setSystemJob(boolean systemJob) {
	this.systemJob = systemJob;
	}

	@Override
	public boolean isAsynchronous() {
	return getFactory().isAsynchronous() && asynchronous;
	}

	public void setAsynchronous(boolean asynchronous) {
	this.asynchronous = asynchronous;
	}
	}