user/src/com/google/gwt/requestfactory/client/impl/DeltaValueStoreJsonImpl.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.JavaScriptObject;
 import com.google.gwt.core.client.JsArray;
 import com.google.gwt.valuestore.client.SyncResultImpl;
 import com.google.gwt.valuestore.shared.Property;
 import com.google.gwt.valuestore.shared.Record;
 import com.google.gwt.valuestore.shared.SyncResult;
 import com.google.gwt.valuestore.shared.WriteOperation;

 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 /**
  * <p>
  * <span style="color:red">Experimental API: This class is still under rapid
  * development, and is very likely to be deleted. Use it at your own risk.
  * </span>
  * </p>
  * Accumulates the local edits, made in the context of a
  * {@link com.google.gwt.requestfactory.shared.RequestObject}.
  *
  */
 class DeltaValueStoreJsonImpl {

   static class ReturnRecord extends JavaScriptObject {

     public static final native JsArray<ReturnRecord> getRecords(
         JavaScriptObject response, String operation) /*-{
       return response[operation];
     }-*/;

     private static native void fillKeys(JavaScriptObject jso, HashSet<String> s) /*-{
       for (key in jso) {
         if (jso.hasOwnProperty(key)) {
           s.@java.util.HashSet::add(Ljava/lang/Object;)(key);
         }
       }
     }-*/;

     protected ReturnRecord() {
     }

     public final native void fillViolations(HashMap<String, String> s) /*-{
       for (key in this.violations) {
         if (this.violations.hasOwnProperty(key)) {
           s.@java.util.HashMap::put(Ljava/lang/Object;Ljava/lang/Object;)(key, this.violations[key]);
         }
       }
     }-*/;

     public final native String getFutureId()/*-{
       return this.futureId;
     }-*/;

     public final Long getId() {
       String parts[] = getSchemaAndId().split("-");
       return Long.parseLong(parts[1]);
     }

     public final String getSchema() {
       String parts[] = getSchemaAndId().split("-");
       return parts[0];
     }

     public final native String getSchemaAndId() /*-{
       return this.id;
     }-*/;

     public final native String getVersion()/*-{
       return this.version;
     }-*/;

     public final native boolean hasFutureId()/*-{
       return 'futureId' in this;
     }-*/;

     public final native boolean hasId()/*-{
       return 'id' in this;
     }-*/;

     public final native boolean hasViolations()/*-{
       return 'violations' in this;
     }-*/;
   }

   private static final HashMap<String, String> NULL_VIOLATIONS = new HashMap<String, String>();

   private boolean used = false;

   private final ValueStoreJsonImpl master;
   private final RequestFactoryJsonImpl requestFactory;

   // track C-U-D of CRUD operations
   private final Map<RecordKey, RecordJsoImpl> creates = new HashMap<RecordKey, RecordJsoImpl>();
   private final Map<RecordKey, RecordJsoImpl> updates = new HashMap<RecordKey, RecordJsoImpl>();
   // nothing for deletes because DeltaValueStore is not involved in deletes. The
   // operation alone suffices.

   private final Map<RecordKey, WriteOperation> operations = new HashMap<RecordKey, WriteOperation>();

   public DeltaValueStoreJsonImpl(ValueStoreJsonImpl master,
       RequestFactoryJsonImpl requestFactory) {
     this.master = master;
     this.requestFactory = requestFactory;
   }

   public void addValidation() {
     throw new UnsupportedOperationException("Auto-generated method stub");
   }

   public void clearUsed() {
     used = false;
   }

   public Set<SyncResult> commit(JavaScriptObject returnedJso) {
     Set<SyncResult> syncResults = new HashSet<SyncResult>();
     HashSet<String> keys = new HashSet<String>();
     ReturnRecord.fillKeys(returnedJso, keys);

     Set<RecordKey> toRemove = new HashSet<RecordKey>();
     if (keys.contains(WriteOperation.CREATE.name())) {
       JsArray<ReturnRecord> newRecords = ReturnRecord.getRecords(returnedJso,
           WriteOperation.CREATE.name());
       /*
        * construct 2 maps: (i) futureId to the datastore Id, (ii) futureId to
        * violationsMap
        */
       Map<Long, Long> futureToDatastoreId = new HashMap<Long, Long>();
       Map<Long, Map<String, String>> violationsMap = new HashMap<Long, Map<String, String>>();
       int length = newRecords.length();
       for (int i = 0; i < length; i++) {
         ReturnRecord sync = newRecords.get(i);
         if (sync.hasViolations()) {
           // does not have an id.
           assert !sync.hasId();
           HashMap<String, String> violations = new HashMap<String, String>();
           sync.fillViolations(violations);
           violationsMap.put(Long.valueOf(sync.getFutureId()), violations);
         } else {
           violationsMap.put(Long.valueOf(sync.getFutureId()), NULL_VIOLATIONS);
           futureToDatastoreId.put(Long.valueOf(sync.getFutureId()),
               sync.getId());
         }
       }

       for (Map.Entry<RecordKey, RecordJsoImpl> entry : creates.entrySet()) {
         final RecordKey futureKey = entry.getKey();
         // TODO change violationsMap to <Long, String>
         Map<String, String> violations = violationsMap.get(futureKey.id);
         assert violations != null;
         if (violations == NULL_VIOLATIONS) {
           Long datastoreId = futureToDatastoreId.get(futureKey.id);
           assert datastoreId != null;
           final RecordKey key = new RecordKey(datastoreId, futureKey.schema,
               RequestFactoryJsonImpl.NOT_FUTURE);
           RecordJsoImpl value = entry.getValue();
           value.set(Record.id, datastoreId);
           RecordJsoImpl masterRecord = master.records.get(key);
           assert masterRecord == null;
           master.records.put(key, value);
           masterRecord = value;
           toRemove.add(new RecordKey(datastoreId, futureKey.schema,
               RequestFactoryJsonImpl.IS_FUTURE));
           requestFactory.postChangeEvent(masterRecord, WriteOperation.CREATE);
           syncResults.add(makeSyncResult(masterRecord, null, futureKey.id));
         } else {
           // do not change the masterRecord or fire event
           syncResults.add(makeSyncResult(entry.getValue(), violations,
               futureKey.id));
         }
       }
     }
     processToRemove(toRemove, WriteOperation.CREATE);
     toRemove.clear();

     if (keys.contains(WriteOperation.DELETE.name())) {
       JsArray<ReturnRecord> deletedRecords = ReturnRecord.getRecords(
           returnedJso, WriteOperation.DELETE.name());
       Map<Long, Map<String, String>> violationsMap = getViolationsMap(deletedRecords);
       int length = deletedRecords.length();

       for (int i = 0; i < length; i++) {
         final RecordKey key = new RecordKey(deletedRecords.get(i).getId(),
             requestFactory.getSchema(deletedRecords.get(i).getSchema()),
             RequestFactoryJsonImpl.NOT_FUTURE);
         Map<String, String> violations = violationsMap.get(key.id);
         assert violations != null;
         /*
          * post change event if no violations.
          *
          * TODO: there needs to be a separate path for violations, not mingled
          * with update events.
          */
         if (violations == NULL_VIOLATIONS) {
           requestFactory.postChangeEvent(RecordJsoImpl.create(key.id, 1,
               key.schema), WriteOperation.DELETE);
         }
         RecordJsoImpl masterRecord = master.records.get(key);
         if (masterRecord != null) {
           master.records.remove(key);
           syncResults.add(makeSyncResult(masterRecord, null, null));
         } else {
           syncResults.add(makeSyncResult(masterRecord, violations, null));
         }
       }
     }

     if (keys.contains(WriteOperation.UPDATE.name())) {
       JsArray<ReturnRecord> updatedRecords = ReturnRecord.getRecords(
           returnedJso, WriteOperation.UPDATE.name());
       Map<Long, Map<String, String>> violationsMap = getViolationsMap(updatedRecords);

       int length = updatedRecords.length();
       for (int i = 0; i < length; i++) {
         final RecordKey key = new RecordKey(updatedRecords.get(i).getId(),
             requestFactory.getSchema(updatedRecords.get(i).getSchema()),
             RequestFactoryJsonImpl.NOT_FUTURE);
         Map<String, String> violations = violationsMap.get(key.id);
         assert violations != null;
         // post change events if no violations.
         if (violations == NULL_VIOLATIONS) {
           requestFactory.postChangeEvent(RecordJsoImpl.create(key.id, 1,
               key.schema), WriteOperation.UPDATE);
         }

         RecordJsoImpl masterRecord = master.records.get(key);
         RecordJsoImpl value = updates.get(key);
         if (masterRecord != null && value != null) {
           // no support for partial updates.
           masterRecord.merge(value);
           toRemove.add(key);
         }
         if (masterRecord != null) {
           syncResults.add(makeSyncResult(masterRecord, null, null));
         } else {
           // do not change the masterRecord or fire event
           syncResults.add(makeSyncResult(masterRecord, violations, null));
         }
       }
     }
     processToRemove(toRemove, WriteOperation.UPDATE);
     return syncResults;
   }

   public boolean isChanged() {
     assert !used;
     return !operations.isEmpty();
   }

   public <V> void set(Property<V> property, Record record, V value) {
     checkArgumentsAndState(record, "set");
     RecordImpl recordImpl = (RecordImpl) record;
     RecordKey recordKey = new RecordKey(recordImpl);

     RecordJsoImpl rawMasterRecord = master.records.get(recordKey);
     WriteOperation priorOperation = operations.get(recordKey);
     if (rawMasterRecord == null && priorOperation == null) {
       operations.put(recordKey, WriteOperation.CREATE);
       creates.put(recordKey, recordImpl.asJso());
       priorOperation = WriteOperation.CREATE;
     }
     if (priorOperation == null) {
       addNewChangeRecord(recordKey, recordImpl, property, value);
       return;
     }

     RecordJsoImpl priorRecord = null;
     switch (priorOperation) {
       case CREATE:
         // nothing to do here.
         priorRecord = creates.get(recordKey);
         assert priorRecord != null;
         priorRecord.set(property, value);
         break;
       case UPDATE:
         priorRecord = updates.get(recordKey);
         assert priorRecord != null;

         if (isRealChange(property, value, rawMasterRecord)) {
           priorRecord.set(property, value);
           updates.put(recordKey, priorRecord);
           return;
         }
         /*
          * Not done yet. If the user has changed the value back to the original
          * value, we should eliminate the previous value from the changeRecord.
          * And if the changeRecord is now empty, we should drop it entirely.
          */

         if (priorRecord.isDefined(property.getName())) {
           priorRecord.delete(property.getName());
         }
         if (updates.containsKey(recordKey) && priorRecord.isEmpty()) {
           updates.remove(recordKey);
           operations.remove(recordKey);
         }
         break;
     }
   }

   String toJson() {
     used = true;

     StringBuffer jsonData = new StringBuffer("{");
     for (WriteOperation writeOperation : new WriteOperation[] {
         WriteOperation.CREATE, WriteOperation.UPDATE}) {
       String jsonDataForOperation = getJsonForOperation(writeOperation);
       if (jsonDataForOperation.equals("")) {
         continue;
       }
       if (jsonData.length() > 1) {
         jsonData.append(",");
       }
       jsonData.append(jsonDataForOperation);
     }
     jsonData.append("}");
     return jsonData.toString();
   }

   /**
    * returns true if a new change record has been added.
    */
   private <V> boolean addNewChangeRecord(RecordKey recordKey,
       RecordImpl recordImpl, Property<V> property, V value) {
     RecordJsoImpl rawMasterRecord = master.records.get(recordKey);
     RecordJsoImpl changeRecord = newChangeRecord(recordImpl);
     if (isRealChange(property, value, rawMasterRecord)) {
       changeRecord.set(property, value);
       updates.put(recordKey, changeRecord);
       operations.put(recordKey, WriteOperation.UPDATE);
       return true;
     }
     return false;
   }

   private void checkArgumentsAndState(Record record, String methodName) {
     if (used) {
       throw new IllegalStateException(methodName
           + " can only be called on an un-used DeltaValueStore");
     }
     if (!(record instanceof RecordImpl)) {
       throw new IllegalArgumentException(record + " + must be an instance of "
           + RecordImpl.class);
     }
   }

   private String getJsonForOperation(WriteOperation writeOperation) {
     Map<RecordKey, RecordJsoImpl> recordsMap = getRecordsMap(writeOperation);
     if (recordsMap.size() == 0) {
       return "";
     }
     StringBuffer requestData = new StringBuffer("\"" + writeOperation.name()
         + "\":[");
     boolean first = true;
     for (Map.Entry<RecordKey, RecordJsoImpl> entry : recordsMap.entrySet()) {
       RecordJsoImpl impl = entry.getValue();
       if (first) {
         first = false;
       } else {
         requestData.append(",");
       }
       requestData.append("{\""
           + entry.getValue().getSchema().getToken() + "\":");
       if (writeOperation != WriteOperation.DELETE) {
         requestData.append(impl.toJson());
       } else {
         requestData.append(impl.toJsonIdVersion());
       }
       requestData.append("}");
     }
     requestData.append("]");
     return requestData.toString();
   }

   private Map<RecordKey, RecordJsoImpl> getRecordsMap(
       WriteOperation writeOperation) {
     switch (writeOperation) {
       case CREATE:
         return creates;
       case UPDATE:
         return updates;
       default:
         throw new IllegalStateException("unknow writeOperation "
             + writeOperation.name());
     }
   }

   private Map<Long, Map<String, String>> getViolationsMap(
       JsArray<ReturnRecord> records) {
     Map<Long, Map<String, String>> violationsMap = new HashMap<Long, Map<String, String>>();
     int length = records.length();
     for (int i = 0; i < length; i++) {
       ReturnRecord record = records.get(i);
       HashMap<String, String> violations = null;
       if (record.hasViolations()) {
         violations = new HashMap<String, String>();
         record.fillViolations(violations);
       } else {
         violations = NULL_VIOLATIONS;
       }
       violationsMap.put(record.getId(), violations);
     }
     return violationsMap;
   }

   private <V> boolean isRealChange(Property<V> property, V value,
       RecordJsoImpl rawMasterRecord) {
     RecordJsoImpl masterRecord = null;

     if (rawMasterRecord == null) {
       return true;
     }

     masterRecord = rawMasterRecord.cast();

     if (!masterRecord.isDefined(property.getName())) {
       return true;
     }

     V masterValue = masterRecord.get(property);

     if (masterValue == value) {
       return false;
     }

     if ((masterValue != null)) {
       return !masterValue.equals(value);
     }

     return true;
   }

   private SyncResultImpl makeSyncResult(RecordJsoImpl jso,
       Map<String, String> violations, Long futureId) {
     return new SyncResultImpl(jso.getSchema().create(jso), violations, futureId);
   }

   private RecordJsoImpl newChangeRecord(RecordImpl fromRecord) {
     return RecordJsoImpl.emptyCopy(fromRecord.asJso());
   }

   private void processToRemove(Set<RecordKey> toRemove,
       WriteOperation writeOperation) {
     for (RecordKey recordKey : toRemove) {
       operations.remove(recordKey);
       if (writeOperation == WriteOperation.CREATE) {
         creates.remove(recordKey);
       } else if (writeOperation == WriteOperation.UPDATE) {
         updates.remove(recordKey);
       }
     }
   }
 }
	/*
	* 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.JavaScriptObject;
	import com.google.gwt.core.client.JsArray;
	import com.google.gwt.valuestore.client.SyncResultImpl;
	import com.google.gwt.valuestore.shared.Property;
	import com.google.gwt.valuestore.shared.Record;
	import com.google.gwt.valuestore.shared.SyncResult;
	import com.google.gwt.valuestore.shared.WriteOperation;

	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;

	/**
	* <p>
	* <span style="color:red">Experimental API: This class is still under rapid
	* development, and is very likely to be deleted. Use it at your own risk.
	* </span>
	* </p>
	* Accumulates the local edits, made in the context of a
	* {@link com.google.gwt.requestfactory.shared.RequestObject}.
	*
	*/
	class DeltaValueStoreJsonImpl {

	static class ReturnRecord extends JavaScriptObject {

	public static final native JsArray<ReturnRecord> getRecords(
	JavaScriptObject response, String operation) /*-{
	return response[operation];
	}-*/;

	private static native void fillKeys(JavaScriptObject jso, HashSet<String> s) /*-{
	for (key in jso) {
	if (jso.hasOwnProperty(key)) {
	s.@java.util.HashSet::add(Ljava/lang/Object;)(key);
	}
	}
	}-*/;

	protected ReturnRecord() {
	}

	public final native void fillViolations(HashMap<String, String> s) /*-{
	for (key in this.violations) {
	if (this.violations.hasOwnProperty(key)) {
	s.@java.util.HashMap::put(Ljava/lang/Object;Ljava/lang/Object;)(key, this.violations[key]);
	}
	}
	}-*/;

	public final native String getFutureId()/*-{
	return this.futureId;
	}-*/;

	public final Long getId() {
	String parts[] = getSchemaAndId().split("-");
	return Long.parseLong(parts[1]);
	}

	public final String getSchema() {
	String parts[] = getSchemaAndId().split("-");
	return parts[0];
	}

	public final native String getSchemaAndId() /*-{
	return this.id;
	}-*/;

	public final native String getVersion()/*-{
	return this.version;
	}-*/;

	public final native boolean hasFutureId()/*-{
	return 'futureId' in this;
	}-*/;

	public final native boolean hasId()/*-{
	return 'id' in this;
	}-*/;

	public final native boolean hasViolations()/*-{
	return 'violations' in this;
	}-*/;
	}

	private static final HashMap<String, String> NULL_VIOLATIONS = new HashMap<String, String>();

	private boolean used = false;

	private final ValueStoreJsonImpl master;
	private final RequestFactoryJsonImpl requestFactory;

	// track C-U-D of CRUD operations
	private final Map<RecordKey, RecordJsoImpl> creates = new HashMap<RecordKey, RecordJsoImpl>();
	private final Map<RecordKey, RecordJsoImpl> updates = new HashMap<RecordKey, RecordJsoImpl>();
	// nothing for deletes because DeltaValueStore is not involved in deletes. The
	// operation alone suffices.

	private final Map<RecordKey, WriteOperation> operations = new HashMap<RecordKey, WriteOperation>();

	public DeltaValueStoreJsonImpl(ValueStoreJsonImpl master,
	RequestFactoryJsonImpl requestFactory) {
	this.master = master;
	this.requestFactory = requestFactory;
	}

	public void addValidation() {
	throw new UnsupportedOperationException("Auto-generated method stub");
	}

	public void clearUsed() {
	used = false;
	}

	public Set<SyncResult> commit(JavaScriptObject returnedJso) {
	Set<SyncResult> syncResults = new HashSet<SyncResult>();
	HashSet<String> keys = new HashSet<String>();
	ReturnRecord.fillKeys(returnedJso, keys);

	Set<RecordKey> toRemove = new HashSet<RecordKey>();
	if (keys.contains(WriteOperation.CREATE.name())) {
	JsArray<ReturnRecord> newRecords = ReturnRecord.getRecords(returnedJso,
	WriteOperation.CREATE.name());
	/*
	* construct 2 maps: (i) futureId to the datastore Id, (ii) futureId to
	* violationsMap
	*/
	Map<Long, Long> futureToDatastoreId = new HashMap<Long, Long>();
	Map<Long, Map<String, String>> violationsMap = new HashMap<Long, Map<String, String>>();
	int length = newRecords.length();
	for (int i = 0; i < length; i++) {
	ReturnRecord sync = newRecords.get(i);
	if (sync.hasViolations()) {
	// does not have an id.
	assert !sync.hasId();
	HashMap<String, String> violations = new HashMap<String, String>();
	sync.fillViolations(violations);
	violationsMap.put(Long.valueOf(sync.getFutureId()), violations);
	} else {
	violationsMap.put(Long.valueOf(sync.getFutureId()), NULL_VIOLATIONS);
	futureToDatastoreId.put(Long.valueOf(sync.getFutureId()),
	sync.getId());
	}
	}

	for (Map.Entry<RecordKey, RecordJsoImpl> entry : creates.entrySet()) {
	final RecordKey futureKey = entry.getKey();
	// TODO change violationsMap to <Long, String>
	Map<String, String> violations = violationsMap.get(futureKey.id);
	assert violations != null;
	if (violations == NULL_VIOLATIONS) {
	Long datastoreId = futureToDatastoreId.get(futureKey.id);
	assert datastoreId != null;
	final RecordKey key = new RecordKey(datastoreId, futureKey.schema,
	RequestFactoryJsonImpl.NOT_FUTURE);
	RecordJsoImpl value = entry.getValue();
	value.set(Record.id, datastoreId);
	RecordJsoImpl masterRecord = master.records.get(key);
	assert masterRecord == null;
	master.records.put(key, value);
	masterRecord = value;
	toRemove.add(new RecordKey(datastoreId, futureKey.schema,
	RequestFactoryJsonImpl.IS_FUTURE));
	requestFactory.postChangeEvent(masterRecord, WriteOperation.CREATE);
	syncResults.add(makeSyncResult(masterRecord, null, futureKey.id));
	} else {
	// do not change the masterRecord or fire event
	syncResults.add(makeSyncResult(entry.getValue(), violations,
	futureKey.id));
	}
	}
	}
	processToRemove(toRemove, WriteOperation.CREATE);
	toRemove.clear();

	if (keys.contains(WriteOperation.DELETE.name())) {
	JsArray<ReturnRecord> deletedRecords = ReturnRecord.getRecords(
	returnedJso, WriteOperation.DELETE.name());
	Map<Long, Map<String, String>> violationsMap = getViolationsMap(deletedRecords);
	int length = deletedRecords.length();

	for (int i = 0; i < length; i++) {
	final RecordKey key = new RecordKey(deletedRecords.get(i).getId(),
	requestFactory.getSchema(deletedRecords.get(i).getSchema()),
	RequestFactoryJsonImpl.NOT_FUTURE);
	Map<String, String> violations = violationsMap.get(key.id);
	assert violations != null;
	/*
	* post change event if no violations.
	*
	* TODO: there needs to be a separate path for violations, not mingled
	* with update events.
	*/
	if (violations == NULL_VIOLATIONS) {
	requestFactory.postChangeEvent(RecordJsoImpl.create(key.id, 1,
	key.schema), WriteOperation.DELETE);
	}
	RecordJsoImpl masterRecord = master.records.get(key);
	if (masterRecord != null) {
	master.records.remove(key);
	syncResults.add(makeSyncResult(masterRecord, null, null));
	} else {
	syncResults.add(makeSyncResult(masterRecord, violations, null));
	}
	}
	}

	if (keys.contains(WriteOperation.UPDATE.name())) {
	JsArray<ReturnRecord> updatedRecords = ReturnRecord.getRecords(
	returnedJso, WriteOperation.UPDATE.name());
	Map<Long, Map<String, String>> violationsMap = getViolationsMap(updatedRecords);

	int length = updatedRecords.length();
	for (int i = 0; i < length; i++) {
	final RecordKey key = new RecordKey(updatedRecords.get(i).getId(),
	requestFactory.getSchema(updatedRecords.get(i).getSchema()),
	RequestFactoryJsonImpl.NOT_FUTURE);
	Map<String, String> violations = violationsMap.get(key.id);
	assert violations != null;
	// post change events if no violations.
	if (violations == NULL_VIOLATIONS) {
	requestFactory.postChangeEvent(RecordJsoImpl.create(key.id, 1,
	key.schema), WriteOperation.UPDATE);
	}

	RecordJsoImpl masterRecord = master.records.get(key);
	RecordJsoImpl value = updates.get(key);
	if (masterRecord != null && value != null) {
	// no support for partial updates.
	masterRecord.merge(value);
	toRemove.add(key);
	}
	if (masterRecord != null) {
	syncResults.add(makeSyncResult(masterRecord, null, null));
	} else {
	// do not change the masterRecord or fire event
	syncResults.add(makeSyncResult(masterRecord, violations, null));
	}
	}
	}
	processToRemove(toRemove, WriteOperation.UPDATE);
	return syncResults;
	}

	public boolean isChanged() {
	assert !used;
	return !operations.isEmpty();
	}

	public <V> void set(Property<V> property, Record record, V value) {
	checkArgumentsAndState(record, "set");
	RecordImpl recordImpl = (RecordImpl) record;
	RecordKey recordKey = new RecordKey(recordImpl);

	RecordJsoImpl rawMasterRecord = master.records.get(recordKey);
	WriteOperation priorOperation = operations.get(recordKey);
	if (rawMasterRecord == null && priorOperation == null) {
	operations.put(recordKey, WriteOperation.CREATE);
	creates.put(recordKey, recordImpl.asJso());
	priorOperation = WriteOperation.CREATE;
	}
	if (priorOperation == null) {
	addNewChangeRecord(recordKey, recordImpl, property, value);
	return;
	}

	RecordJsoImpl priorRecord = null;
	switch (priorOperation) {
	case CREATE:
	// nothing to do here.
	priorRecord = creates.get(recordKey);
	assert priorRecord != null;
	priorRecord.set(property, value);
	break;
	case UPDATE:
	priorRecord = updates.get(recordKey);
	assert priorRecord != null;

	if (isRealChange(property, value, rawMasterRecord)) {
	priorRecord.set(property, value);
	updates.put(recordKey, priorRecord);
	return;
	}
	/*
	* Not done yet. If the user has changed the value back to the original
	* value, we should eliminate the previous value from the changeRecord.
	* And if the changeRecord is now empty, we should drop it entirely.
	*/

	if (priorRecord.isDefined(property.getName())) {
	priorRecord.delete(property.getName());
	}
	if (updates.containsKey(recordKey) && priorRecord.isEmpty()) {
	updates.remove(recordKey);
	operations.remove(recordKey);
	}
	break;
	}
	}

	String toJson() {
	used = true;

	StringBuffer jsonData = new StringBuffer("{");
	for (WriteOperation writeOperation : new WriteOperation[] {
	WriteOperation.CREATE, WriteOperation.UPDATE}) {
	String jsonDataForOperation = getJsonForOperation(writeOperation);
	if (jsonDataForOperation.equals("")) {
	continue;
	}
	if (jsonData.length() > 1) {
	jsonData.append(",");
	}
	jsonData.append(jsonDataForOperation);
	}
	jsonData.append("}");
	return jsonData.toString();
	}

	/**
	* returns true if a new change record has been added.
	*/
	private <V> boolean addNewChangeRecord(RecordKey recordKey,
	RecordImpl recordImpl, Property<V> property, V value) {
	RecordJsoImpl rawMasterRecord = master.records.get(recordKey);
	RecordJsoImpl changeRecord = newChangeRecord(recordImpl);
	if (isRealChange(property, value, rawMasterRecord)) {
	changeRecord.set(property, value);
	updates.put(recordKey, changeRecord);
	operations.put(recordKey, WriteOperation.UPDATE);
	return true;
	}
	return false;
	}

	private void checkArgumentsAndState(Record record, String methodName) {
	if (used) {
	throw new IllegalStateException(methodName
	+ " can only be called on an un-used DeltaValueStore");
	}
	if (!(record instanceof RecordImpl)) {
	throw new IllegalArgumentException(record + " + must be an instance of "
	+ RecordImpl.class);
	}
	}

	private String getJsonForOperation(WriteOperation writeOperation) {
	Map<RecordKey, RecordJsoImpl> recordsMap = getRecordsMap(writeOperation);
	if (recordsMap.size() == 0) {
	return "";
	}
	StringBuffer requestData = new StringBuffer("\"" + writeOperation.name()
	+ "\":[");
	boolean first = true;
	for (Map.Entry<RecordKey, RecordJsoImpl> entry : recordsMap.entrySet()) {
	RecordJsoImpl impl = entry.getValue();
	if (first) {
	first = false;
	} else {
	requestData.append(",");
	}
	requestData.append("{\""
	+ entry.getValue().getSchema().getToken() + "\":");
	if (writeOperation != WriteOperation.DELETE) {
	requestData.append(impl.toJson());
	} else {
	requestData.append(impl.toJsonIdVersion());
	}
	requestData.append("}");
	}
	requestData.append("]");
	return requestData.toString();
	}

	private Map<RecordKey, RecordJsoImpl> getRecordsMap(
	WriteOperation writeOperation) {
	switch (writeOperation) {
	case CREATE:
	return creates;
	case UPDATE:
	return updates;
	default:
	throw new IllegalStateException("unknow writeOperation "
	+ writeOperation.name());
	}
	}

	private Map<Long, Map<String, String>> getViolationsMap(
	JsArray<ReturnRecord> records) {
	Map<Long, Map<String, String>> violationsMap = new HashMap<Long, Map<String, String>>();
	int length = records.length();
	for (int i = 0; i < length; i++) {
	ReturnRecord record = records.get(i);
	HashMap<String, String> violations = null;
	if (record.hasViolations()) {
	violations = new HashMap<String, String>();
	record.fillViolations(violations);
	} else {
	violations = NULL_VIOLATIONS;
	}
	violationsMap.put(record.getId(), violations);
	}
	return violationsMap;
	}

	private <V> boolean isRealChange(Property<V> property, V value,
	RecordJsoImpl rawMasterRecord) {
	RecordJsoImpl masterRecord = null;

	if (rawMasterRecord == null) {
	return true;
	}

	masterRecord = rawMasterRecord.cast();

	if (!masterRecord.isDefined(property.getName())) {
	return true;
	}

	V masterValue = masterRecord.get(property);

	if (masterValue == value) {
	return false;
	}

	if ((masterValue != null)) {
	return !masterValue.equals(value);
	}

	return true;
	}

	private SyncResultImpl makeSyncResult(RecordJsoImpl jso,
	Map<String, String> violations, Long futureId) {
	return new SyncResultImpl(jso.getSchema().create(jso), violations, futureId);
	}

	private RecordJsoImpl newChangeRecord(RecordImpl fromRecord) {
	return RecordJsoImpl.emptyCopy(fromRecord.asJso());
	}

	private void processToRemove(Set<RecordKey> toRemove,
	WriteOperation writeOperation) {
	for (RecordKey recordKey : toRemove) {
	operations.remove(recordKey);
	if (writeOperation == WriteOperation.CREATE) {
	creates.remove(recordKey);
	} else if (writeOperation == WriteOperation.UPDATE) {
	updates.remove(recordKey);
	}
	}
	}
	}