2.2/user/src/com/google/gwt/autobean/shared/AutoBeanCodex.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.autobean.shared;

 import com.google.gwt.autobean.shared.impl.EnumMap;
 import com.google.gwt.autobean.shared.impl.LazySplittable;
 import com.google.gwt.autobean.shared.impl.StringQuoter;

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

 /**
  * Utility methods for encoding an AutoBean graph into a JSON-compatible string.
  * This codex intentionally does not preserve object identity, nor does it
  * encode cycles, but it will detect them.
  */
 public class AutoBeanCodex {
   static class Decoder extends AutoBeanVisitor {
     private final Stack<AutoBean<?>> beanStack = new Stack<AutoBean<?>>();
     private final Stack<Splittable> dataStack = new Stack<Splittable>();
     private AutoBean<?> bean;
     private Splittable data;
     private final AutoBeanFactory factory;

     public Decoder(AutoBeanFactory factory) {
       this.factory = factory;
     }

     @SuppressWarnings("unchecked")
     public <T> AutoBean<T> decode(Splittable data, Class<T> type) {
       push(data, type);
       bean.accept(this);
       return (AutoBean<T>) pop();
     }

     @Override
     public boolean visitCollectionProperty(String propertyName,
         AutoBean<Collection<?>> value, CollectionPropertyContext ctx) {
       if (data.isNull(propertyName)) {
         return false;
       }

       Collection<Object> collection;
       if (List.class.equals(ctx.getType())) {
         collection = new ArrayList<Object>();
       } else if (Set.class.equals(ctx.getType())) {
         collection = new HashSet<Object>();
       } else {
         throw new UnsupportedOperationException("Only List and Set supported");
       }

       boolean isValue = ValueCodex.canDecode(ctx.getElementType());
       boolean isEncoded = Splittable.class.equals(ctx.getElementType());
       Splittable listData = data.get(propertyName);
       for (int i = 0, j = listData.size(); i < j; i++) {
         if (listData.isNull(i)) {
           collection.add(null);
         } else {
           if (isValue) {
             collection.add(decodeValue(ctx.getElementType(), listData.get(i)));
           } else if (isEncoded) {
             collection.add(listData.get(i));
           } else {
             collection.add(decode(listData.get(i), ctx.getElementType()).as());
           }
         }
       }
       ctx.set(collection);
       return false;
     }

     @Override
     public boolean visitMapProperty(String propertyName,
         AutoBean<Map<?, ?>> value, MapPropertyContext ctx) {
       if (data.isNull(propertyName)) {
         return false;
       }

       Map<?, ?> map;
       if (ValueCodex.canDecode(ctx.getKeyType())) {
         map = decodeValueKeyMap(data.get(propertyName), ctx.getKeyType(),
             ctx.getValueType());
       } else {
         map = decodeObjectKeyMap(data.get(propertyName), ctx.getKeyType(),
             ctx.getValueType());
       }
       ctx.set(map);
       return false;
     }

     @Override
     public boolean visitReferenceProperty(String propertyName,
         AutoBean<?> value, PropertyContext ctx) {
       if (data.isNull(propertyName)) {
         return false;
       }

       if (Splittable.class.equals(ctx.getType())) {
         ctx.set(data.get(propertyName));
         return false;
       }

       push(data.get(propertyName), ctx.getType());
       bean.accept(this);
       ctx.set(pop().as());
       return false;
     }

     @Override
     public boolean visitValueProperty(String propertyName, Object value,
         PropertyContext ctx) {
       if (!data.isNull(propertyName)) {
         Object object;
         Splittable propertyValue = data.get(propertyName);
         Class<?> type = ctx.getType();
         object = decodeValue(type, propertyValue);
         ctx.set(object);
       }
       return false;
     }

     private Map<?, ?> decodeObjectKeyMap(Splittable map, Class<?> keyType,
         Class<?> valueType) {
       boolean isEncodedKey = Splittable.class.equals(keyType);
       boolean isEncodedValue = Splittable.class.equals(valueType);
       boolean isValueValue = Splittable.class.equals(valueType);

       Splittable keyList = map.get(0);
       Splittable valueList = map.get(1);
       assert keyList.size() == valueList.size();

       Map<Object, Object> toReturn = new HashMap<Object, Object>(keyList.size());
       for (int i = 0, j = keyList.size(); i < j; i++) {
         Object key;
         if (isEncodedKey) {
           key = keyList.get(i);
         } else {
           key = decode(keyList.get(i), keyType).as();
         }

         Object value;
         if (valueList.isNull(i)) {
           value = null;
         } else if (isEncodedValue) {
           value = keyList.get(i);
         } else if (isValueValue) {
           value = decodeValue(valueType, keyList.get(i));
         } else {
           value = decode(valueList.get(i), valueType).as();
         }

         toReturn.put(key, value);
       }
       return toReturn;
     }

     private Object decodeValue(Class<?> type, Splittable propertyValue) {
       return decodeValue(type, propertyValue.asString());
     }

     private Object decodeValue(Class<?> type, String propertyValue) {
       Object object;
       if (type.isEnum() && bean.getFactory() instanceof EnumMap) {
         // The generics kind of get in the way here
         @SuppressWarnings({"unchecked", "rawtypes"})
         Class<Enum> enumType = (Class<Enum>) type;
         @SuppressWarnings("unchecked")
         Enum<?> e = ((EnumMap) bean.getFactory()).getEnum(enumType,
             propertyValue);
         object = e;
       } else {
         object = ValueCodex.decode(type, propertyValue);
       }
       return object;
     }

     private Map<?, ?> decodeValueKeyMap(Splittable map, Class<?> keyType,
         Class<?> valueType) {
       Map<Object, Object> toReturn = new HashMap<Object, Object>();

       boolean isEncodedValue = Splittable.class.equals(valueType);
       boolean isValueValue = ValueCodex.canDecode(valueType);
       for (String encodedKey : map.getPropertyKeys()) {
         Object key = decodeValue(keyType, encodedKey);
         Object value;
         if (map.isNull(encodedKey)) {
           value = null;
         } else if (isEncodedValue) {
           value = map.get(encodedKey);
         } else if (isValueValue) {
           value = decodeValue(valueType, map.get(encodedKey));
         } else {
           value = decode(map.get(encodedKey), valueType).as();
         }
         toReturn.put(key, value);
       }

       return toReturn;
     }

     private AutoBean<?> pop() {
       dataStack.pop();
       if (dataStack.isEmpty()) {
         data = null;
       } else {
         data = dataStack.peek();
       }
       AutoBean<?> toReturn = beanStack.pop();
       if (beanStack.isEmpty()) {
         bean = null;
       } else {
         bean = beanStack.peek();
       }
       return toReturn;
     }

     private void push(Splittable data, Class<?> type) {
       this.data = data;
       bean = factory.create(type);
       if (bean == null) {
         throw new IllegalArgumentException(
             "The AutoBeanFactory cannot create a " + type.getName());
       }
       dataStack.push(data);
       beanStack.push(bean);
     }
   }

   static class Encoder extends AutoBeanVisitor {
     private EnumMap enumMap;
     private Set<AutoBean<?>> seen = new HashSet<AutoBean<?>>();
     private Stack<StringBuilder> stack = new Stack<StringBuilder>();
     private StringBuilder sb;

     public Encoder(AutoBeanFactory factory) {
       if (factory instanceof EnumMap) {
         enumMap = (EnumMap) factory;
       }
     }

     @Override
     public void endVisit(AutoBean<?> bean, Context ctx) {
       if (sb.length() == 0) {
         // No properties
         sb.append("{");
       } else {
         sb.setCharAt(0, '{');
       }
       sb.append("}");
     }

     @Override
     public void endVisitReferenceProperty(String propertyName,
         AutoBean<?> value, PropertyContext ctx) {
       StringBuilder popped = pop();
       if (popped.length() > 0) {
         sb.append(",\"").append(propertyName).append("\":").append(
             popped.toString());
       }
     }

     @Override
     public boolean visitCollectionProperty(String propertyName,
         AutoBean<Collection<?>> value, CollectionPropertyContext ctx) {
       push(new StringBuilder());

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

       Collection<?> collection = value.as();
       if (collection.isEmpty()) {
         sb.append("[]");
         return false;
       }

       if (ValueCodex.canDecode(ctx.getElementType())) {
         for (Object element : collection) {
           sb.append(",").append(
               encodeValue(ctx.getElementType(), element).getPayload());
         }
       } else {
         boolean isEncoded = Splittable.class.equals(ctx.getElementType());
         for (Object element : collection) {
           sb.append(",");
           if (element == null) {
             sb.append("null");
           } else if (isEncoded) {
             sb.append(((Splittable) element).getPayload());
           } else {
             encodeToStringBuilder(sb, element);
           }
         }
       }
       sb.setCharAt(0, '[');
       sb.append("]");
       return false;
     }

     @Override
     public boolean visitMapProperty(String propertyName,
         AutoBean<Map<?, ?>> value, MapPropertyContext ctx) {
       push(new StringBuilder());

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

       Map<?, ?> map = value.as();
       if (map.isEmpty()) {
         sb.append("{}");
         return false;
       }

       Class<?> keyType = ctx.getKeyType();
       Class<?> valueType = ctx.getValueType();
       boolean isEncodedKey = Splittable.class.equals(keyType);
       boolean isEncodedValue = Splittable.class.equals(valueType);
       boolean isValueKey = ValueCodex.canDecode(keyType);
       boolean isValueValue = ValueCodex.canDecode(valueType);

       if (isValueKey) {
         writeValueKeyMap(map, keyType, valueType, isEncodedValue, isValueValue);
       } else {
         writeObjectKeyMap(map, valueType, isEncodedKey, isEncodedValue,
             isValueValue);
       }

       return false;
     }

     @Override
     public boolean visitReferenceProperty(String propertyName,
         AutoBean<?> value, PropertyContext ctx) {
       push(new StringBuilder());

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

       if (Splittable.class.equals(ctx.getType())) {
         sb.append(((Splittable) value.as()).getPayload());
         return false;
       }

       if (seen.contains(value)) {
         haltOnCycle();
       }

       return true;
     }

     @Override
     public boolean visitValueProperty(String propertyName, Object value,
         PropertyContext ctx) {
       // Skip primitive types whose values are uninteresting.
       Class<?> type = ctx.getType();
       Object blankValue = ValueCodex.getUninitializedFieldValue(type);
       if (value == blankValue || value != null && value.equals(blankValue)) {
         return false;
       }

       // Special handling for enums if we have an obfuscation map
       Splittable split;
       split = encodeValue(type, value);
       sb.append(",\"").append(propertyName).append("\":").append(
           split.getPayload());
       return false;
     }

     StringBuilder pop() {
       StringBuilder toReturn = stack.pop();
       sb = stack.peek();
       return toReturn;
     }

     void push(StringBuilder sb) {
       stack.push(sb);
       this.sb = sb;
     }

     private void encodeToStringBuilder(StringBuilder accumulator, Object value) {
       push(new StringBuilder());
       AutoBean<?> bean = AutoBeanUtils.getAutoBean(value);
       if (!seen.add(bean)) {
         haltOnCycle();
       }
       bean.accept(this);
       accumulator.append(pop().toString());
       seen.remove(bean);
     }

     /**
      * Encodes a value, with special handling for enums to allow the field name
      * to be overridden.
      */
     private Splittable encodeValue(Class<?> expectedType, Object value) {
       Splittable split;
       if (value instanceof Enum<?> && enumMap != null) {
         split = ValueCodex.encode(String.class,
             enumMap.getToken((Enum<?>) value));
       } else {
         split = ValueCodex.encode(expectedType, value);
       }
       return split;
     }

     private void haltOnCycle() {
       throw new HaltException(new UnsupportedOperationException(
           "Cycle detected"));
     }

     /**
      * Writes a map JSON literal where the keys are object types. This is
      * encoded as a list of two lists, since it's possible that two distinct
      * objects have the same encoded form.
      */
     private void writeObjectKeyMap(Map<?, ?> map, Class<?> valueType,
         boolean isEncodedKey, boolean isEncodedValue, boolean isValueValue) {
       StringBuilder keys = new StringBuilder();
       StringBuilder values = new StringBuilder();

       for (Map.Entry<?, ?> entry : map.entrySet()) {
         if (isEncodedKey) {
           keys.append(",").append(((Splittable) entry.getKey()).getPayload());
         } else {
           encodeToStringBuilder(keys.append(","), entry.getKey());
         }

         if (isEncodedValue) {
           values.append(",").append(
               ((Splittable) entry.getValue()).getPayload());
         } else if (isValueValue) {
           values.append(",").append(
               encodeValue(valueType, entry.getValue()).getPayload());
         } else {
           encodeToStringBuilder(values.append(","), entry.getValue());
         }
       }
       keys.setCharAt(0, '[');
       keys.append("]");
       values.setCharAt(0, '[');
       values.append("]");

       sb.append("[").append(keys.toString()).append(",").append(
           values.toString()).append("]");
     }

     /**
      * Writes a map JSON literal where the keys are value types.
      */
     private void writeValueKeyMap(Map<?, ?> map, Class<?> keyType,
         Class<?> valueType, boolean isEncodedValue, boolean isValueValue) {
       for (Map.Entry<?, ?> entry : map.entrySet()) {
         sb.append(",").append(encodeValue(keyType, entry.getKey()).getPayload()).append(
             ":");
         if (isEncodedValue) {
           sb.append(((Splittable) entry.getValue()).getPayload());
         } else if (isValueValue) {
           sb.append(encodeValue(valueType, entry.getValue()).getPayload());
         } else {
           encodeToStringBuilder(sb, entry.getValue());
         }
       }
       sb.setCharAt(0, '{');
       sb.append("}");
     }
   }

   /**
    * Used to stop processing.
    */
   static class HaltException extends RuntimeException {
     public HaltException(RuntimeException cause) {
       super(cause);
     }

     @Override
     public RuntimeException getCause() {
       return (RuntimeException) super.getCause();
     }
   }

   public static <T> AutoBean<T> decode(AutoBeanFactory factory, Class<T> clazz,
       Splittable data) {
     return new Decoder(factory).decode(data, clazz);
   }

   /**
    * Decode an AutoBeanCodex payload.
    *
    * @param <T> the expected return type
    * @param factory an AutoBeanFactory capable of producing {@code AutoBean<T>}
    * @param clazz the expected return type
    * @param payload a payload string previously generated by
    *          {@link #encode(AutoBean)}
    * @return an AutoBean containing the payload contents
    */
   public static <T> AutoBean<T> decode(AutoBeanFactory factory, Class<T> clazz,
       String payload) {
     Splittable data = StringQuoter.split(payload);
     return decode(factory, clazz, data);
   }

   /**
    * Encodes an AutoBean. The actual payload contents can be retrieved through
    * {@link Splittable#getPayload()}.
    *
    * @param bean the bean to encode
    * @return a Splittable that encodes the state of the AutoBean
    */
   public static Splittable encode(AutoBean<?> bean) {
     if (bean == null) {
       return LazySplittable.NULL;
     }

     StringBuilder sb = new StringBuilder();
     encodeForJsoPayload(sb, bean);
     return new LazySplittable(sb.toString());
   }

   // ["prop",value,"prop",value, ...]
   private static void encodeForJsoPayload(StringBuilder sb, AutoBean<?> bean) {
     Encoder e = new Encoder(bean.getFactory());
     e.push(sb);
     try {
       bean.accept(e);
     } catch (HaltException ex) {
       throw ex.getCause();
     }
   }

   private AutoBeanCodex() {
   }
 }
	/*
	* 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.autobean.shared;

	import com.google.gwt.autobean.shared.impl.EnumMap;
	import com.google.gwt.autobean.shared.impl.LazySplittable;
	import com.google.gwt.autobean.shared.impl.StringQuoter;

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

	/**
	* Utility methods for encoding an AutoBean graph into a JSON-compatible string.
	* This codex intentionally does not preserve object identity, nor does it
	* encode cycles, but it will detect them.
	*/
	public class AutoBeanCodex {
	static class Decoder extends AutoBeanVisitor {
	private final Stack<AutoBean<?>> beanStack = new Stack<AutoBean<?>>();
	private final Stack<Splittable> dataStack = new Stack<Splittable>();
	private AutoBean<?> bean;
	private Splittable data;
	private final AutoBeanFactory factory;

	public Decoder(AutoBeanFactory factory) {
	this.factory = factory;
	}

	@SuppressWarnings("unchecked")
	public <T> AutoBean<T> decode(Splittable data, Class<T> type) {
	push(data, type);
	bean.accept(this);
	return (AutoBean<T>) pop();
	}

	@Override
	public boolean visitCollectionProperty(String propertyName,
	AutoBean<Collection<?>> value, CollectionPropertyContext ctx) {
	if (data.isNull(propertyName)) {
	return false;
	}

	Collection<Object> collection;
	if (List.class.equals(ctx.getType())) {
	collection = new ArrayList<Object>();
	} else if (Set.class.equals(ctx.getType())) {
	collection = new HashSet<Object>();
	} else {
	throw new UnsupportedOperationException("Only List and Set supported");
	}

	boolean isValue = ValueCodex.canDecode(ctx.getElementType());
	boolean isEncoded = Splittable.class.equals(ctx.getElementType());
	Splittable listData = data.get(propertyName);
	for (int i = 0, j = listData.size(); i < j; i++) {
	if (listData.isNull(i)) {
	collection.add(null);
	} else {
	if (isValue) {
	collection.add(decodeValue(ctx.getElementType(), listData.get(i)));
	} else if (isEncoded) {
	collection.add(listData.get(i));
	} else {
	collection.add(decode(listData.get(i), ctx.getElementType()).as());
	}
	}
	}
	ctx.set(collection);
	return false;
	}

	@Override
	public boolean visitMapProperty(String propertyName,
	AutoBean<Map<?, ?>> value, MapPropertyContext ctx) {
	if (data.isNull(propertyName)) {
	return false;
	}

	Map<?, ?> map;
	if (ValueCodex.canDecode(ctx.getKeyType())) {
	map = decodeValueKeyMap(data.get(propertyName), ctx.getKeyType(),
	ctx.getValueType());
	} else {
	map = decodeObjectKeyMap(data.get(propertyName), ctx.getKeyType(),
	ctx.getValueType());
	}
	ctx.set(map);
	return false;
	}

	@Override
	public boolean visitReferenceProperty(String propertyName,
	AutoBean<?> value, PropertyContext ctx) {
	if (data.isNull(propertyName)) {
	return false;
	}

	if (Splittable.class.equals(ctx.getType())) {
	ctx.set(data.get(propertyName));
	return false;
	}

	push(data.get(propertyName), ctx.getType());
	bean.accept(this);
	ctx.set(pop().as());
	return false;
	}

	@Override
	public boolean visitValueProperty(String propertyName, Object value,
	PropertyContext ctx) {
	if (!data.isNull(propertyName)) {
	Object object;
	Splittable propertyValue = data.get(propertyName);
	Class<?> type = ctx.getType();
	object = decodeValue(type, propertyValue);
	ctx.set(object);
	}
	return false;
	}

	private Map<?, ?> decodeObjectKeyMap(Splittable map, Class<?> keyType,
	Class<?> valueType) {
	boolean isEncodedKey = Splittable.class.equals(keyType);
	boolean isEncodedValue = Splittable.class.equals(valueType);
	boolean isValueValue = Splittable.class.equals(valueType);

	Splittable keyList = map.get(0);
	Splittable valueList = map.get(1);
	assert keyList.size() == valueList.size();

	Map<Object, Object> toReturn = new HashMap<Object, Object>(keyList.size());
	for (int i = 0, j = keyList.size(); i < j; i++) {
	Object key;
	if (isEncodedKey) {
	key = keyList.get(i);
	} else {
	key = decode(keyList.get(i), keyType).as();
	}

	Object value;
	if (valueList.isNull(i)) {
	value = null;
	} else if (isEncodedValue) {
	value = keyList.get(i);
	} else if (isValueValue) {
	value = decodeValue(valueType, keyList.get(i));
	} else {
	value = decode(valueList.get(i), valueType).as();
	}

	toReturn.put(key, value);
	}
	return toReturn;
	}

	private Object decodeValue(Class<?> type, Splittable propertyValue) {
	return decodeValue(type, propertyValue.asString());
	}

	private Object decodeValue(Class<?> type, String propertyValue) {
	Object object;
	if (type.isEnum() && bean.getFactory() instanceof EnumMap) {
	// The generics kind of get in the way here
	@SuppressWarnings({"unchecked", "rawtypes"})
	Class<Enum> enumType = (Class<Enum>) type;
	@SuppressWarnings("unchecked")
	Enum<?> e = ((EnumMap) bean.getFactory()).getEnum(enumType,
	propertyValue);
	object = e;
	} else {
	object = ValueCodex.decode(type, propertyValue);
	}
	return object;
	}

	private Map<?, ?> decodeValueKeyMap(Splittable map, Class<?> keyType,
	Class<?> valueType) {
	Map<Object, Object> toReturn = new HashMap<Object, Object>();

	boolean isEncodedValue = Splittable.class.equals(valueType);
	boolean isValueValue = ValueCodex.canDecode(valueType);
	for (String encodedKey : map.getPropertyKeys()) {
	Object key = decodeValue(keyType, encodedKey);
	Object value;
	if (map.isNull(encodedKey)) {
	value = null;
	} else if (isEncodedValue) {
	value = map.get(encodedKey);
	} else if (isValueValue) {
	value = decodeValue(valueType, map.get(encodedKey));
	} else {
	value = decode(map.get(encodedKey), valueType).as();
	}
	toReturn.put(key, value);
	}

	return toReturn;
	}

	private AutoBean<?> pop() {
	dataStack.pop();
	if (dataStack.isEmpty()) {
	data = null;
	} else {
	data = dataStack.peek();
	}
	AutoBean<?> toReturn = beanStack.pop();
	if (beanStack.isEmpty()) {
	bean = null;
	} else {
	bean = beanStack.peek();
	}
	return toReturn;
	}

	private void push(Splittable data, Class<?> type) {
	this.data = data;
	bean = factory.create(type);
	if (bean == null) {
	throw new IllegalArgumentException(
	"The AutoBeanFactory cannot create a " + type.getName());
	}
	dataStack.push(data);
	beanStack.push(bean);
	}
	}

	static class Encoder extends AutoBeanVisitor {
	private EnumMap enumMap;
	private Set<AutoBean<?>> seen = new HashSet<AutoBean<?>>();
	private Stack<StringBuilder> stack = new Stack<StringBuilder>();
	private StringBuilder sb;

	public Encoder(AutoBeanFactory factory) {
	if (factory instanceof EnumMap) {
	enumMap = (EnumMap) factory;
	}
	}

	@Override
	public void endVisit(AutoBean<?> bean, Context ctx) {
	if (sb.length() == 0) {
	// No properties
	sb.append("{");
	} else {
	sb.setCharAt(0, '{');
	}
	sb.append("}");
	}

	@Override
	public void endVisitReferenceProperty(String propertyName,
	AutoBean<?> value, PropertyContext ctx) {
	StringBuilder popped = pop();
	if (popped.length() > 0) {
	sb.append(",\"").append(propertyName).append("\":").append(
	popped.toString());
	}
	}

	@Override
	public boolean visitCollectionProperty(String propertyName,
	AutoBean<Collection<?>> value, CollectionPropertyContext ctx) {
	push(new StringBuilder());

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

	Collection<?> collection = value.as();
	if (collection.isEmpty()) {
	sb.append("[]");
	return false;
	}

	if (ValueCodex.canDecode(ctx.getElementType())) {
	for (Object element : collection) {
	sb.append(",").append(
	encodeValue(ctx.getElementType(), element).getPayload());
	}
	} else {
	boolean isEncoded = Splittable.class.equals(ctx.getElementType());
	for (Object element : collection) {
	sb.append(",");
	if (element == null) {
	sb.append("null");
	} else if (isEncoded) {
	sb.append(((Splittable) element).getPayload());
	} else {
	encodeToStringBuilder(sb, element);
	}
	}
	}
	sb.setCharAt(0, '[');
	sb.append("]");
	return false;
	}

	@Override
	public boolean visitMapProperty(String propertyName,
	AutoBean<Map<?, ?>> value, MapPropertyContext ctx) {
	push(new StringBuilder());

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

	Map<?, ?> map = value.as();
	if (map.isEmpty()) {
	sb.append("{}");
	return false;
	}

	Class<?> keyType = ctx.getKeyType();
	Class<?> valueType = ctx.getValueType();
	boolean isEncodedKey = Splittable.class.equals(keyType);
	boolean isEncodedValue = Splittable.class.equals(valueType);
	boolean isValueKey = ValueCodex.canDecode(keyType);
	boolean isValueValue = ValueCodex.canDecode(valueType);

	if (isValueKey) {
	writeValueKeyMap(map, keyType, valueType, isEncodedValue, isValueValue);
	} else {
	writeObjectKeyMap(map, valueType, isEncodedKey, isEncodedValue,
	isValueValue);
	}

	return false;
	}

	@Override
	public boolean visitReferenceProperty(String propertyName,
	AutoBean<?> value, PropertyContext ctx) {
	push(new StringBuilder());

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

	if (Splittable.class.equals(ctx.getType())) {
	sb.append(((Splittable) value.as()).getPayload());
	return false;
	}

	if (seen.contains(value)) {
	haltOnCycle();
	}

	return true;
	}

	@Override
	public boolean visitValueProperty(String propertyName, Object value,
	PropertyContext ctx) {
	// Skip primitive types whose values are uninteresting.
	Class<?> type = ctx.getType();
	Object blankValue = ValueCodex.getUninitializedFieldValue(type);
	if (value == blankValue \|\| value != null && value.equals(blankValue)) {
	return false;
	}

	// Special handling for enums if we have an obfuscation map
	Splittable split;
	split = encodeValue(type, value);
	sb.append(",\"").append(propertyName).append("\":").append(
	split.getPayload());
	return false;
	}

	StringBuilder pop() {
	StringBuilder toReturn = stack.pop();
	sb = stack.peek();
	return toReturn;
	}

	void push(StringBuilder sb) {
	stack.push(sb);
	this.sb = sb;
	}

	private void encodeToStringBuilder(StringBuilder accumulator, Object value) {
	push(new StringBuilder());
	AutoBean<?> bean = AutoBeanUtils.getAutoBean(value);
	if (!seen.add(bean)) {
	haltOnCycle();
	}
	bean.accept(this);
	accumulator.append(pop().toString());
	seen.remove(bean);
	}

	/**
	* Encodes a value, with special handling for enums to allow the field name
	* to be overridden.
	*/
	private Splittable encodeValue(Class<?> expectedType, Object value) {
	Splittable split;
	if (value instanceof Enum<?> && enumMap != null) {
	split = ValueCodex.encode(String.class,
	enumMap.getToken((Enum<?>) value));
	} else {
	split = ValueCodex.encode(expectedType, value);
	}
	return split;
	}

	private void haltOnCycle() {
	throw new HaltException(new UnsupportedOperationException(
	"Cycle detected"));
	}

	/**
	* Writes a map JSON literal where the keys are object types. This is
	* encoded as a list of two lists, since it's possible that two distinct
	* objects have the same encoded form.
	*/
	private void writeObjectKeyMap(Map<?, ?> map, Class<?> valueType,
	boolean isEncodedKey, boolean isEncodedValue, boolean isValueValue) {
	StringBuilder keys = new StringBuilder();
	StringBuilder values = new StringBuilder();

	for (Map.Entry<?, ?> entry : map.entrySet()) {
	if (isEncodedKey) {
	keys.append(",").append(((Splittable) entry.getKey()).getPayload());
	} else {
	encodeToStringBuilder(keys.append(","), entry.getKey());
	}

	if (isEncodedValue) {
	values.append(",").append(
	((Splittable) entry.getValue()).getPayload());
	} else if (isValueValue) {
	values.append(",").append(
	encodeValue(valueType, entry.getValue()).getPayload());
	} else {
	encodeToStringBuilder(values.append(","), entry.getValue());
	}
	}
	keys.setCharAt(0, '[');
	keys.append("]");
	values.setCharAt(0, '[');
	values.append("]");

	sb.append("[").append(keys.toString()).append(",").append(
	values.toString()).append("]");
	}

	/**
	* Writes a map JSON literal where the keys are value types.
	*/
	private void writeValueKeyMap(Map<?, ?> map, Class<?> keyType,
	Class<?> valueType, boolean isEncodedValue, boolean isValueValue) {
	for (Map.Entry<?, ?> entry : map.entrySet()) {
	sb.append(",").append(encodeValue(keyType, entry.getKey()).getPayload()).append(
	":");
	if (isEncodedValue) {
	sb.append(((Splittable) entry.getValue()).getPayload());
	} else if (isValueValue) {
	sb.append(encodeValue(valueType, entry.getValue()).getPayload());
	} else {
	encodeToStringBuilder(sb, entry.getValue());
	}
	}
	sb.setCharAt(0, '{');
	sb.append("}");
	}
	}

	/**
	* Used to stop processing.
	*/
	static class HaltException extends RuntimeException {
	public HaltException(RuntimeException cause) {
	super(cause);
	}

	@Override
	public RuntimeException getCause() {
	return (RuntimeException) super.getCause();
	}
	}

	public static <T> AutoBean<T> decode(AutoBeanFactory factory, Class<T> clazz,
	Splittable data) {
	return new Decoder(factory).decode(data, clazz);
	}

	/**
	* Decode an AutoBeanCodex payload.
	*
	* @param <T> the expected return type
	* @param factory an AutoBeanFactory capable of producing {@code AutoBean<T>}
	* @param clazz the expected return type
	* @param payload a payload string previously generated by
	* {@link #encode(AutoBean)}
	* @return an AutoBean containing the payload contents
	*/
	public static <T> AutoBean<T> decode(AutoBeanFactory factory, Class<T> clazz,
	String payload) {
	Splittable data = StringQuoter.split(payload);
	return decode(factory, clazz, data);
	}

	/**
	* Encodes an AutoBean. The actual payload contents can be retrieved through
	* {@link Splittable#getPayload()}.
	*
	* @param bean the bean to encode
	* @return a Splittable that encodes the state of the AutoBean
	*/
	public static Splittable encode(AutoBean<?> bean) {
	if (bean == null) {
	return LazySplittable.NULL;
	}

	StringBuilder sb = new StringBuilder();
	encodeForJsoPayload(sb, bean);
	return new LazySplittable(sb.toString());
	}

	// ["prop",value,"prop",value, ...]
	private static void encodeForJsoPayload(StringBuilder sb, AutoBean<?> bean) {
	Encoder e = new Encoder(bean.getFactory());
	e.push(sb);
	try {
	bean.accept(e);
	} catch (HaltException ex) {
	throw ex.getCause();
	}
	}

	private AutoBeanCodex() {
	}
	}