/*
* 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() {
}
}