2.1/user/src/com/google/gwt/requestfactory/client/impl/AbstractRequestContext.java - gwt - Git at Google

 /*
  * Copyright 2010 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.requestfactory.client.impl;

 import com.google.gwt.core.client.JsArray;
 import com.google.gwt.editor.client.AutoBean;
 import com.google.gwt.editor.client.AutoBeanUtils;
 import com.google.gwt.editor.client.AutoBeanVisitor;
 import com.google.gwt.requestfactory.client.impl.messages.RequestContentData;
 import com.google.gwt.requestfactory.client.impl.messages.ReturnRecord;
 import com.google.gwt.requestfactory.client.impl.messages.SideEffects;
 import com.google.gwt.requestfactory.shared.EntityProxy;
 import com.google.gwt.requestfactory.shared.EntityProxyChange;
 import com.google.gwt.requestfactory.shared.Receiver;
 import com.google.gwt.requestfactory.shared.RequestContext;
 import com.google.gwt.requestfactory.shared.RequestTransport.TransportReceiver;
 import com.google.gwt.requestfactory.shared.ServerFailure;
 import com.google.gwt.requestfactory.shared.ValueCodex;
 import com.google.gwt.requestfactory.shared.Violation;
 import com.google.gwt.requestfactory.shared.WriteOperation;
 import com.google.gwt.requestfactory.shared.impl.Constants;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * Base implementations for RequestContext services.
  */
 public class AbstractRequestContext implements RequestContext {
   private static final String PARENT_OBJECT = "parentObject";

   private List<AbstractRequest<?>> invocations = new ArrayList<AbstractRequest<?>>();
   private boolean locked;
   private final AbstractRequestFactory requestFactory;
   /**
    * A map of all EntityProxies that the RequestContext has interacted with.
    * Objects are placed into this map by being passed into {@link #edit} or as
    * an invocation argument.
    */
   private final Map<SimpleEntityProxyId<?>, AutoBean<?>> editedProxies = new LinkedHashMap<SimpleEntityProxyId<?>, AutoBean<?>>();
   private Set<Violation> errors = new LinkedHashSet<Violation>();
   /**
    * A map that contains the canonical instance of an entity to return in the
    * return graph, since this is built from scratch.
    */
   private final Map<SimpleEntityProxyId<?>, AutoBean<?>> returnedProxies = new HashMap<SimpleEntityProxyId<?>, AutoBean<?>>();

   protected AbstractRequestContext(AbstractRequestFactory factory) {
     this.requestFactory = factory;
   }

   /**
    * Create a new object, with an ephemeral id.
    */
   public <T extends EntityProxy> T create(Class<T> clazz) {
     checkLocked();

     AutoBean<T> created = requestFactory.createEntityProxy(clazz,
         requestFactory.allocateId(clazz));
     return takeOwnership(created);
   }

   public <T extends EntityProxy> T edit(T object) {
     AutoBean<T> bean = checkStreamsNotCrossed(object);

     checkLocked();

     @SuppressWarnings("unchecked")
     AutoBean<T> previouslySeen = (AutoBean<T>) editedProxies.get(object.stableId());
     if (previouslySeen != null && !previouslySeen.isFrozen()) {
       /*
        * If we've seen the object before, it might be because it was passed in
        * as a method argument. This does not guarantee its mutability, so check
        * that here before returning the cached object.
        */
       return previouslySeen.as();
     }

     // Create editable copies
     AutoBean<T> parent = bean;
     bean = cloneBeanAndCollections(bean);
     bean.setTag(PARENT_OBJECT, parent);
     return takeOwnership(bean);
   }

   /**
    * Make sure there's a default receiver so errors don't get dropped. This
    * behavior should be revisited when chaining is supported, depending on
    * whether or not chained invocations can fail independently.
    */
   public void fire() {
     boolean needsReceiver = true;
     for (AbstractRequest<?> request : invocations) {
       if (request.hasReceiver()) {
         needsReceiver = false;
         break;
       }
     }

     if (needsReceiver) {
       doFire(new Receiver<Void>() {
         @Override
         public void onSuccess(Void response) {
           // Don't care
         }
       });
     } else {
       doFire(null);
     }
   }

   public void fire(final Receiver<Void> receiver) {
     if (receiver == null) {
       throw new IllegalArgumentException();
     }
     doFire(receiver);
   }

   public AbstractRequestFactory getRequestFactory() {
     return requestFactory;
   }

   public boolean isChanged() {
     /*
      * NB: Don't use the presence of ephemeral objects for this test.
      *
      * Diff the objects until one is found to be different. It's not just a
      * simple flag-check because of the possibility of "unmaking" a change, per
      * the JavaDoc.
      */
     for (AutoBean<?> bean : editedProxies.values()) {
       AutoBean<?> previous = bean.getTag(PARENT_OBJECT);
       if (previous == null) {
         // Compare to empty object
         Class<?> proxyClass = ((EntityProxy) bean.as()).stableId().getProxyClass();
         previous = getRequestFactory().getAutoBeanFactory().create(proxyClass);
       }
       if (!AutoBeanUtils.diff(previous, bean).isEmpty()) {
         return true;
       }
     }
     return false;
   }

   public boolean isLocked() {
     return locked;
   }

   public void reuse() {
     freezeEntities(false);
     locked = false;
   }

   /**
    * Called by individual invocations to aggregate all errors.
    */
   protected void addErrors(Collection<Violation> errors) {
     this.errors.addAll(errors);
   }

   /**
    * Called by generated subclasses to enqueue a method invocation.
    */
   protected void addInvocation(AbstractRequest<?> request) {
     if (invocations.size() > 0) {
       // TODO(bobv): Upgrade wire protocol and server to handle chains
       throw new IllegalStateException("Method chaining not implemented");
     }
     invocations.add(request);
     for (Object arg : request.getRequestData().getParameters()) {
       retainArg(arg);
     }
   }

   /**
    * Creates or retrieves a new canonical AutoBean to represent the given id in
    * the returned payload.
    */
   <Q extends EntityProxy> AutoBean<Q> getProxyForReturnPayloadGraph(
       SimpleEntityProxyId<Q> id) {
     assert !id.isEphemeral();

     @SuppressWarnings("unchecked")
     AutoBean<Q> bean = (AutoBean<Q>) returnedProxies.get(id);
     if (bean == null) {
       Class<Q> proxyClass = id.getProxyClass();
       bean = requestFactory.createEntityProxy(proxyClass, id);
       returnedProxies.put(id, bean);
     }

     return bean;
   }

   /**
    * Create a new EntityProxy from a snapshot in the return payload.
    *
    * @param id the EntityProxyId of the object
    * @param returnRecord the JSON map containing property/value pairs
    * @param operations the WriteOperation eventns to broadcast over the EventBus
    */
   <Q extends EntityProxy> Q processReturnRecord(SimpleEntityProxyId<Q> id,
       final ReturnRecord returnRecord, WriteOperation... operations) {

     AutoBean<Q> toMutate = getProxyForReturnPayloadGraph(id);

     // Apply updates
     toMutate.accept(new AutoBeanVisitor() {
       @Override
       public boolean visitReferenceProperty(String propertyName,
           AutoBean<?> value, PropertyContext ctx) {
         if (ctx.canSet()) {
           if (returnRecord.hasProperty(propertyName)) {
             Object raw = returnRecord.get(propertyName);
             if (returnRecord.isNull(propertyName)) {
               ctx.set(null);
             } else {
               Object decoded = EntityCodex.decode(ctx.getType(),
                   ctx.getElementType(), AbstractRequestContext.this, raw);
               ctx.set(decoded);
             }
           }
         }
         return false;
       }

       @Override
       public boolean visitValueProperty(String propertyName, Object value,
           PropertyContext ctx) {
         if (ctx.canSet()) {
           if (returnRecord.hasProperty(propertyName)) {
             Object raw = returnRecord.get(propertyName);
             if (returnRecord.isNull(propertyName)) {
               ctx.set(null);
             } else {
               Object decoded = ValueCodex.convertFromString(ctx.getType(),
                   String.valueOf(raw));
               ctx.set(decoded);
             }
           }
         }
         return false;
       }
     });

     // Finished applying updates, freeze the bean
     makeImmutable(toMutate);
     Q proxy = toMutate.as();

     /*
      * Notify subscribers if the object differs from when it first came into the
      * RequestContext.
      */
     if (operations != null) {
       for (WriteOperation op : operations) {
         if (op.equals(WriteOperation.UPDATE)
             && !requestFactory.hasVersionChanged(id, returnRecord.getVersion())) {
           // No updates if the server reports no change
           continue;
         }
         requestFactory.getEventBus().fireEventFromSource(
             new EntityProxyChange<EntityProxy>(proxy, op), id.getProxyClass());
       }
     }
     return proxy;
   }

   /**
    * Process a SideEffects message.
    */
   void processSideEffects(SideEffects sideEffects) {
     JsArray<ReturnRecord> persisted = sideEffects.getPersist();
     if (persisted != null) {
       processReturnRecords(persisted, WriteOperation.PERSIST);
     }
     JsArray<ReturnRecord> updated = sideEffects.getUpdate();
     if (updated != null) {
       processReturnRecords(updated, WriteOperation.UPDATE);
     }
     JsArray<ReturnRecord> deleted = sideEffects.getDelete();
     if (deleted != null) {
       processReturnRecords(deleted, WriteOperation.DELETE);
     }
   }

   private void checkLocked() {
     if (locked) {
       throw new IllegalStateException("A request is already in progress");
     }
   }

   /**
    * This method checks that a proxy object is either immutable, or already
    * edited by this context.
    */
   private <T> AutoBean<T> checkStreamsNotCrossed(T object) {
     AutoBean<T> bean = AutoBeanUtils.getAutoBean(object);
     if (bean == null) {
       // Unexpected; some kind of foreign implementation?
       throw new IllegalArgumentException(object.getClass().getName());
     }

     RequestContext context = bean.getTag(EntityProxyCategory.REQUEST_CONTEXT);
     if (!bean.isFrozen() && context != this) {
       /*
        * This means something is way off in the weeds. If a bean is editable,
        * it's supposed to be associated with a RequestContext.
        */
       assert context != null : "Unfrozen bean with null RequestContext";

       /*
        * Already editing the object in another context or it would have been in
        * the editing map.
        */
       throw new IllegalArgumentException("Attempting to edit an EntityProxy"
           + " previously edited by another RequestContext");
     }
     return bean;
   }

   /**
    * Shallow-clones an autobean and makes duplicates of the collection types. A
    * regular {@link AutoBean#clone} won't duplicate reference properties.
    */
   private <T> AutoBean<T> cloneBeanAndCollections(AutoBean<T> toClone) {
     AutoBean<T> clone = toClone.clone(false);
     clone.accept(new AutoBeanVisitor() {
       @Override
       public boolean visitReferenceProperty(String propertyName,
           AutoBean<?> value, PropertyContext ctx) {
         if (value != null) {
           if (List.class == ctx.getType()) {
             ctx.set(new ArrayList<Object>((List<?>) value.as()));
           } else if (Set.class == ctx.getType()) {
             ctx.set(new HashSet<Object>((Set<?>) value.as()));
           }
         }
         return false;
       }
     });
     return clone;
   }

   private void doFire(final Receiver<Void> receiver) {
     checkLocked();
     locked = true;

     freezeEntities(true);

     String payload = makePayload();

     requestFactory.getRequestTransport().send(payload, new TransportReceiver() {
       public void onTransportFailure(String message) {
         ServerFailure failure = new ServerFailure(message, null, null);
         try {
           // TODO: chained methods
           assert invocations.size() == 1;
           invocations.get(0).fail(failure);
           if (receiver != null) {
             receiver.onFailure(failure);
           }
         } finally {
           postRequestCleanup();
         }
       }

       public void onTransportSuccess(String payload) {
         try {
           // TODO: chained methods
           assert invocations.size() == 1;
           invocations.get(0).handleResponseText(payload);

           if (receiver != null) {
             if (errors.isEmpty()) {
               receiver.onSuccess(null);
               // After success, shut down the context
               editedProxies.clear();
               invocations.clear();
               returnedProxies.clear();
             } else {
               receiver.onViolation(errors);
             }
           }
         } finally {
           postRequestCleanup();
         }
       }
     });
   }

   /**
    * Set the frozen status of all EntityProxies owned by this context.
    */
   private void freezeEntities(boolean frozen) {
     for (AutoBean<?> bean : editedProxies.values()) {
       bean.setFrozen(frozen);
     }
   }

   /**
    * Make an EntityProxy immutable.
    */
   private void makeImmutable(final AutoBean<? extends EntityProxy> toMutate) {
     // Always diff'ed against itself, producing a no-op
     toMutate.setTag(PARENT_OBJECT, toMutate);
     // Act with entity-identity semantics
     toMutate.setTag(EntityProxyCategory.REQUEST_CONTEXT, null);
     toMutate.setFrozen(true);
   }

   /**
    * Assemble all of the state that has been accumulated in this context. This
    * includes:
    * <ul>
    * <li>Diffs accumulated on objects passed to {@link #edit}.
    * <li>Invocations accumulated as Request subtypes passed to
    * {@link #addInvocation}.
    * </ul>
    */
   private String makePayload() {
     // TODO: Chained invocations
     assert invocations.size() == 1 : "addInvocation() should have failed";

     // Produces the contentData payload fragment
     RequestContentData data = new RequestContentData();

     // Compute deltas for each entity seen by the context
     for (AutoBean<?> currentView : editedProxies.values()) {
       boolean isPersist = false;
       @SuppressWarnings("unchecked")
       SimpleEntityProxyId<EntityProxy> stableId = EntityProxyCategory.stableId((AutoBean<EntityProxy>) currentView);

       // Encoded string representations of the properties
       Map<String, String> encoded = new LinkedHashMap<String, String>();

       {
         // Find the object to compare against
         AutoBean<?> parent = currentView.getTag(PARENT_OBJECT);
         if (parent == null) {
           // Newly-created object, use a blank object to compare against
           parent = requestFactory.createEntityProxy(stableId.getProxyClass(),
               stableId);

           // Newly-created objects go into the persist operation bucket
           isPersist = true;
           // The ephemeral id is passed to the server
           String clientId = String.valueOf(stableId.getClientId());
           encoded.put(Constants.ENCODED_ID_PROPERTY,
               ValueCodex.encodeForJsonPayload(clientId));
         } else {
           // Requests involving existing objects use the persisted id
           encoded.put(Constants.ENCODED_ID_PROPERTY,
               ValueCodex.encodeForJsonPayload(stableId.getServerId()));
         }

         // Compute the diff
         Map<String, Object> diff = AutoBeanUtils.diff(parent, currentView);
         for (Map.Entry<String, Object> entry : diff.entrySet()) {
           // Make JSON representations of the new values
           encoded.put(entry.getKey(),
               EntityCodex.encodeForJsonPayload(entry.getValue()));
         }
       }

       // Append the payload fragment to the correct bucket
       String typeToken = requestFactory.getTypeToken(stableId.getProxyClass());
       if (isPersist) {
         data.addPersist(typeToken, encoded);
       } else {
         data.addUpdate(typeToken, encoded);
       }
     }

     AbstractRequest<?> request = invocations.get(0);
     // Known issue that the data is double-quoted
     Map<String, String> requestMap = request.getRequestData().getRequestMap(
         data.toJson());
     String string = RequestContentData.flattenKeysToExpressions(requestMap);
     return string;
   }

   /**
    * Delete state that's no longer required.
    */
   private void postRequestCleanup() {
     errors.clear();
   }

   /**
    * Process an array of ReturnRecords, delegating to
    * {@link #processReturnRecord}.
    */
   private void processReturnRecords(JsArray<ReturnRecord> records,
       WriteOperation operations) {
     for (int i = 0, j = records.length(); i < j; i++) {
       ReturnRecord record = records.get(i);
       SimpleEntityProxyId<EntityProxy> id = requestFactory.getId(
           record.getSchema(), record.getEncodedId(), record.getFutureId());
       processReturnRecord(id, record, operations);
     }
   }

   /**
    * Ensures that any method arguments are retained in the context's sphere of
    * influence.
    */
   private void retainArg(Object arg) {
     if (arg instanceof Iterable<?>) {
       for (Object o : (Iterable<?>) arg) {
         retainArg(o);
       }
     } else if (arg instanceof EntityProxy) {
       // Calling edit will validate and set up the tracking we need
       edit((EntityProxy) arg);
     }
   }

   /**
    * Make the EnityProxy bean edited and owned by this RequestContext.
    */
   private <T extends EntityProxy> T takeOwnership(AutoBean<T> bean) {
     editedProxies.put(EntityProxyCategory.stableId(bean), bean);
     bean.setTag(EntityProxyCategory.REQUEST_CONTEXT,
         AbstractRequestContext.this);
     return bean.as();
   }
 }
	/*
	* Copyright 2010 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.requestfactory.client.impl;

	import com.google.gwt.core.client.JsArray;
	import com.google.gwt.editor.client.AutoBean;
	import com.google.gwt.editor.client.AutoBeanUtils;
	import com.google.gwt.editor.client.AutoBeanVisitor;
	import com.google.gwt.requestfactory.client.impl.messages.RequestContentData;
	import com.google.gwt.requestfactory.client.impl.messages.ReturnRecord;
	import com.google.gwt.requestfactory.client.impl.messages.SideEffects;
	import com.google.gwt.requestfactory.shared.EntityProxy;
	import com.google.gwt.requestfactory.shared.EntityProxyChange;
	import com.google.gwt.requestfactory.shared.Receiver;
	import com.google.gwt.requestfactory.shared.RequestContext;
	import com.google.gwt.requestfactory.shared.RequestTransport.TransportReceiver;
	import com.google.gwt.requestfactory.shared.ServerFailure;
	import com.google.gwt.requestfactory.shared.ValueCodex;
	import com.google.gwt.requestfactory.shared.Violation;
	import com.google.gwt.requestfactory.shared.WriteOperation;
	import com.google.gwt.requestfactory.shared.impl.Constants;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedHashMap;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* Base implementations for RequestContext services.
	*/
	public class AbstractRequestContext implements RequestContext {
	private static final String PARENT_OBJECT = "parentObject";

	private List<AbstractRequest<?>> invocations = new ArrayList<AbstractRequest<?>>();
	private boolean locked;
	private final AbstractRequestFactory requestFactory;
	/**
	* A map of all EntityProxies that the RequestContext has interacted with.
	* Objects are placed into this map by being passed into {@link #edit} or as
	* an invocation argument.
	*/
	private final Map<SimpleEntityProxyId<?>, AutoBean<?>> editedProxies = new LinkedHashMap<SimpleEntityProxyId<?>, AutoBean<?>>();
	private Set<Violation> errors = new LinkedHashSet<Violation>();
	/**
	* A map that contains the canonical instance of an entity to return in the
	* return graph, since this is built from scratch.
	*/
	private final Map<SimpleEntityProxyId<?>, AutoBean<?>> returnedProxies = new HashMap<SimpleEntityProxyId<?>, AutoBean<?>>();

	protected AbstractRequestContext(AbstractRequestFactory factory) {
	this.requestFactory = factory;
	}

	/**
	* Create a new object, with an ephemeral id.
	*/
	public <T extends EntityProxy> T create(Class<T> clazz) {
	checkLocked();

	AutoBean<T> created = requestFactory.createEntityProxy(clazz,
	requestFactory.allocateId(clazz));
	return takeOwnership(created);
	}

	public <T extends EntityProxy> T edit(T object) {
	AutoBean<T> bean = checkStreamsNotCrossed(object);

	checkLocked();

	@SuppressWarnings("unchecked")
	AutoBean<T> previouslySeen = (AutoBean<T>) editedProxies.get(object.stableId());
	if (previouslySeen != null && !previouslySeen.isFrozen()) {
	/*
	* If we've seen the object before, it might be because it was passed in
	* as a method argument. This does not guarantee its mutability, so check
	* that here before returning the cached object.
	*/
	return previouslySeen.as();
	}

	// Create editable copies
	AutoBean<T> parent = bean;
	bean = cloneBeanAndCollections(bean);
	bean.setTag(PARENT_OBJECT, parent);
	return takeOwnership(bean);
	}

	/**
	* Make sure there's a default receiver so errors don't get dropped. This
	* behavior should be revisited when chaining is supported, depending on
	* whether or not chained invocations can fail independently.
	*/
	public void fire() {
	boolean needsReceiver = true;
	for (AbstractRequest<?> request : invocations) {
	if (request.hasReceiver()) {
	needsReceiver = false;
	break;
	}
	}

	if (needsReceiver) {
	doFire(new Receiver<Void>() {
	@Override
	public void onSuccess(Void response) {
	// Don't care
	}
	});
	} else {
	doFire(null);
	}
	}

	public void fire(final Receiver<Void> receiver) {
	if (receiver == null) {
	throw new IllegalArgumentException();
	}
	doFire(receiver);
	}

	public AbstractRequestFactory getRequestFactory() {
	return requestFactory;
	}

	public boolean isChanged() {
	/*
	* NB: Don't use the presence of ephemeral objects for this test.
	*
	* Diff the objects until one is found to be different. It's not just a
	* simple flag-check because of the possibility of "unmaking" a change, per
	* the JavaDoc.
	*/
	for (AutoBean<?> bean : editedProxies.values()) {
	AutoBean<?> previous = bean.getTag(PARENT_OBJECT);
	if (previous == null) {
	// Compare to empty object
	Class<?> proxyClass = ((EntityProxy) bean.as()).stableId().getProxyClass();
	previous = getRequestFactory().getAutoBeanFactory().create(proxyClass);
	}
	if (!AutoBeanUtils.diff(previous, bean).isEmpty()) {
	return true;
	}
	}
	return false;
	}

	public boolean isLocked() {
	return locked;
	}

	public void reuse() {
	freezeEntities(false);
	locked = false;
	}

	/**
	* Called by individual invocations to aggregate all errors.
	*/
	protected void addErrors(Collection<Violation> errors) {
	this.errors.addAll(errors);
	}

	/**
	* Called by generated subclasses to enqueue a method invocation.
	*/
	protected void addInvocation(AbstractRequest<?> request) {
	if (invocations.size() > 0) {
	// TODO(bobv): Upgrade wire protocol and server to handle chains
	throw new IllegalStateException("Method chaining not implemented");
	}
	invocations.add(request);
	for (Object arg : request.getRequestData().getParameters()) {
	retainArg(arg);
	}
	}

	/**
	* Creates or retrieves a new canonical AutoBean to represent the given id in
	* the returned payload.
	*/
	<Q extends EntityProxy> AutoBean<Q> getProxyForReturnPayloadGraph(
	SimpleEntityProxyId<Q> id) {
	assert !id.isEphemeral();

	@SuppressWarnings("unchecked")
	AutoBean<Q> bean = (AutoBean<Q>) returnedProxies.get(id);
	if (bean == null) {
	Class<Q> proxyClass = id.getProxyClass();
	bean = requestFactory.createEntityProxy(proxyClass, id);
	returnedProxies.put(id, bean);
	}

	return bean;
	}

	/**
	* Create a new EntityProxy from a snapshot in the return payload.
	*
	* @param id the EntityProxyId of the object
	* @param returnRecord the JSON map containing property/value pairs
	* @param operations the WriteOperation eventns to broadcast over the EventBus
	*/
	<Q extends EntityProxy> Q processReturnRecord(SimpleEntityProxyId<Q> id,
	final ReturnRecord returnRecord, WriteOperation... operations) {

	AutoBean<Q> toMutate = getProxyForReturnPayloadGraph(id);

	// Apply updates
	toMutate.accept(new AutoBeanVisitor() {
	@Override
	public boolean visitReferenceProperty(String propertyName,
	AutoBean<?> value, PropertyContext ctx) {
	if (ctx.canSet()) {
	if (returnRecord.hasProperty(propertyName)) {
	Object raw = returnRecord.get(propertyName);
	if (returnRecord.isNull(propertyName)) {
	ctx.set(null);
	} else {
	Object decoded = EntityCodex.decode(ctx.getType(),
	ctx.getElementType(), AbstractRequestContext.this, raw);
	ctx.set(decoded);
	}
	}
	}
	return false;
	}

	@Override
	public boolean visitValueProperty(String propertyName, Object value,
	PropertyContext ctx) {
	if (ctx.canSet()) {
	if (returnRecord.hasProperty(propertyName)) {
	Object raw = returnRecord.get(propertyName);
	if (returnRecord.isNull(propertyName)) {
	ctx.set(null);
	} else {
	Object decoded = ValueCodex.convertFromString(ctx.getType(),
	String.valueOf(raw));
	ctx.set(decoded);
	}
	}
	}
	return false;
	}
	});

	// Finished applying updates, freeze the bean
	makeImmutable(toMutate);
	Q proxy = toMutate.as();

	/*
	* Notify subscribers if the object differs from when it first came into the
	* RequestContext.
	*/
	if (operations != null) {
	for (WriteOperation op : operations) {
	if (op.equals(WriteOperation.UPDATE)
	&& !requestFactory.hasVersionChanged(id, returnRecord.getVersion())) {
	// No updates if the server reports no change
	continue;
	}
	requestFactory.getEventBus().fireEventFromSource(
	new EntityProxyChange<EntityProxy>(proxy, op), id.getProxyClass());
	}
	}
	return proxy;
	}

	/**
	* Process a SideEffects message.
	*/
	void processSideEffects(SideEffects sideEffects) {
	JsArray<ReturnRecord> persisted = sideEffects.getPersist();
	if (persisted != null) {
	processReturnRecords(persisted, WriteOperation.PERSIST);
	}
	JsArray<ReturnRecord> updated = sideEffects.getUpdate();
	if (updated != null) {
	processReturnRecords(updated, WriteOperation.UPDATE);
	}
	JsArray<ReturnRecord> deleted = sideEffects.getDelete();
	if (deleted != null) {
	processReturnRecords(deleted, WriteOperation.DELETE);
	}
	}

	private void checkLocked() {
	if (locked) {
	throw new IllegalStateException("A request is already in progress");
	}
	}

	/**
	* This method checks that a proxy object is either immutable, or already
	* edited by this context.
	*/
	private <T> AutoBean<T> checkStreamsNotCrossed(T object) {
	AutoBean<T> bean = AutoBeanUtils.getAutoBean(object);
	if (bean == null) {
	// Unexpected; some kind of foreign implementation?
	throw new IllegalArgumentException(object.getClass().getName());
	}

	RequestContext context = bean.getTag(EntityProxyCategory.REQUEST_CONTEXT);
	if (!bean.isFrozen() && context != this) {
	/*
	* This means something is way off in the weeds. If a bean is editable,
	* it's supposed to be associated with a RequestContext.
	*/
	assert context != null : "Unfrozen bean with null RequestContext";

	/*
	* Already editing the object in another context or it would have been in
	* the editing map.
	*/
	throw new IllegalArgumentException("Attempting to edit an EntityProxy"
	+ " previously edited by another RequestContext");
	}
	return bean;
	}

	/**
	* Shallow-clones an autobean and makes duplicates of the collection types. A
	* regular {@link AutoBean#clone} won't duplicate reference properties.
	*/
	private <T> AutoBean<T> cloneBeanAndCollections(AutoBean<T> toClone) {
	AutoBean<T> clone = toClone.clone(false);
	clone.accept(new AutoBeanVisitor() {
	@Override
	public boolean visitReferenceProperty(String propertyName,
	AutoBean<?> value, PropertyContext ctx) {
	if (value != null) {
	if (List.class == ctx.getType()) {
	ctx.set(new ArrayList<Object>((List<?>) value.as()));
	} else if (Set.class == ctx.getType()) {
	ctx.set(new HashSet<Object>((Set<?>) value.as()));
	}
	}
	return false;
	}
	});
	return clone;
	}

	private void doFire(final Receiver<Void> receiver) {
	checkLocked();
	locked = true;

	freezeEntities(true);

	String payload = makePayload();

	requestFactory.getRequestTransport().send(payload, new TransportReceiver() {
	public void onTransportFailure(String message) {
	ServerFailure failure = new ServerFailure(message, null, null);
	try {
	// TODO: chained methods
	assert invocations.size() == 1;
	invocations.get(0).fail(failure);
	if (receiver != null) {
	receiver.onFailure(failure);
	}
	} finally {
	postRequestCleanup();
	}
	}

	public void onTransportSuccess(String payload) {
	try {
	// TODO: chained methods
	assert invocations.size() == 1;
	invocations.get(0).handleResponseText(payload);

	if (receiver != null) {
	if (errors.isEmpty()) {
	receiver.onSuccess(null);
	// After success, shut down the context
	editedProxies.clear();
	invocations.clear();
	returnedProxies.clear();
	} else {
	receiver.onViolation(errors);
	}
	}
	} finally {
	postRequestCleanup();
	}
	}
	});
	}

	/**
	* Set the frozen status of all EntityProxies owned by this context.
	*/
	private void freezeEntities(boolean frozen) {
	for (AutoBean<?> bean : editedProxies.values()) {
	bean.setFrozen(frozen);
	}
	}

	/**
	* Make an EntityProxy immutable.
	*/
	private void makeImmutable(final AutoBean<? extends EntityProxy> toMutate) {
	// Always diff'ed against itself, producing a no-op
	toMutate.setTag(PARENT_OBJECT, toMutate);
	// Act with entity-identity semantics
	toMutate.setTag(EntityProxyCategory.REQUEST_CONTEXT, null);
	toMutate.setFrozen(true);
	}

	/**
	* Assemble all of the state that has been accumulated in this context. This
	* includes:
	* <ul>
	* <li>Diffs accumulated on objects passed to {@link #edit}.
	* <li>Invocations accumulated as Request subtypes passed to
	* {@link #addInvocation}.
	* </ul>
	*/
	private String makePayload() {
	// TODO: Chained invocations
	assert invocations.size() == 1 : "addInvocation() should have failed";

	// Produces the contentData payload fragment
	RequestContentData data = new RequestContentData();

	// Compute deltas for each entity seen by the context
	for (AutoBean<?> currentView : editedProxies.values()) {
	boolean isPersist = false;
	@SuppressWarnings("unchecked")
	SimpleEntityProxyId<EntityProxy> stableId = EntityProxyCategory.stableId((AutoBean<EntityProxy>) currentView);

	// Encoded string representations of the properties
	Map<String, String> encoded = new LinkedHashMap<String, String>();

	{
	// Find the object to compare against
	AutoBean<?> parent = currentView.getTag(PARENT_OBJECT);
	if (parent == null) {
	// Newly-created object, use a blank object to compare against
	parent = requestFactory.createEntityProxy(stableId.getProxyClass(),
	stableId);

	// Newly-created objects go into the persist operation bucket
	isPersist = true;
	// The ephemeral id is passed to the server
	String clientId = String.valueOf(stableId.getClientId());
	encoded.put(Constants.ENCODED_ID_PROPERTY,
	ValueCodex.encodeForJsonPayload(clientId));
	} else {
	// Requests involving existing objects use the persisted id
	encoded.put(Constants.ENCODED_ID_PROPERTY,
	ValueCodex.encodeForJsonPayload(stableId.getServerId()));
	}

	// Compute the diff
	Map<String, Object> diff = AutoBeanUtils.diff(parent, currentView);
	for (Map.Entry<String, Object> entry : diff.entrySet()) {
	// Make JSON representations of the new values
	encoded.put(entry.getKey(),
	EntityCodex.encodeForJsonPayload(entry.getValue()));
	}
	}

	// Append the payload fragment to the correct bucket
	String typeToken = requestFactory.getTypeToken(stableId.getProxyClass());
	if (isPersist) {
	data.addPersist(typeToken, encoded);
	} else {
	data.addUpdate(typeToken, encoded);
	}
	}

	AbstractRequest<?> request = invocations.get(0);
	// Known issue that the data is double-quoted
	Map<String, String> requestMap = request.getRequestData().getRequestMap(
	data.toJson());
	String string = RequestContentData.flattenKeysToExpressions(requestMap);
	return string;
	}

	/**
	* Delete state that's no longer required.
	*/
	private void postRequestCleanup() {
	errors.clear();
	}

	/**
	* Process an array of ReturnRecords, delegating to
	* {@link #processReturnRecord}.
	*/
	private void processReturnRecords(JsArray<ReturnRecord> records,
	WriteOperation operations) {
	for (int i = 0, j = records.length(); i < j; i++) {
	ReturnRecord record = records.get(i);
	SimpleEntityProxyId<EntityProxy> id = requestFactory.getId(
	record.getSchema(), record.getEncodedId(), record.getFutureId());
	processReturnRecord(id, record, operations);
	}
	}

	/**
	* Ensures that any method arguments are retained in the context's sphere of
	* influence.
	*/
	private void retainArg(Object arg) {
	if (arg instanceof Iterable<?>) {
	for (Object o : (Iterable<?>) arg) {
	retainArg(o);
	}
	} else if (arg instanceof EntityProxy) {
	// Calling edit will validate and set up the tracking we need
	edit((EntityProxy) arg);
	}
	}

	/**
	* Make the EnityProxy bean edited and owned by this RequestContext.
	*/
	private <T extends EntityProxy> T takeOwnership(AutoBean<T> bean) {
	editedProxies.put(EntityProxyCategory.stableId(bean), bean);
	bean.setTag(EntityProxyCategory.REQUEST_CONTEXT,
	AbstractRequestContext.this);
	return bean.as();
	}
	}