/*
* Copyright 2011 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.web.bindery.autobean.shared.impl;
import com.google.web.bindery.autobean.shared.AutoBean;
import com.google.web.bindery.autobean.shared.AutoBeanFactory;
import com.google.web.bindery.autobean.shared.AutoBeanUtils;
import com.google.web.bindery.autobean.shared.AutoBeanVisitor;
import com.google.web.bindery.autobean.shared.AutoBeanVisitor.ParameterizationVisitor;
import com.google.web.bindery.autobean.shared.Splittable;
import com.google.web.bindery.autobean.shared.ValueCodex;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
/**
* Contains the implementation details of AutoBeanCodex. This type was factored
* out of AutoBeanCodex so that various implementation details can be accessed
* without polluting a public API.
*/
public class AutoBeanCodexImpl {
/**
* Describes a means of encoding or decoding a particular type of data to or
* from a wire format representation. Any given instance of a Coder should be
* stateless; any state required for operation must be maintained in an
* {@link EncodeState}.
*/
public interface Coder {
Object decode(EncodeState state, Splittable data);
void encode(EncodeState state, Object value);
Splittable extractSplittable(EncodeState state, Object value);
}
/**
* Contains transient state for Coder operation.
*/
public static class EncodeState {
/**
* Constructs a state object used for decoding payloads.
*/
public static EncodeState forDecode(AutoBeanFactory factory) {
return new EncodeState(factory, null);
}
/**
* Constructs a state object used for encoding payloads.
*/
public static EncodeState forEncode(AutoBeanFactory factory, StringBuilder sb) {
return new EncodeState(factory, sb);
}
/**
* Constructs a "stateless" state for testing Coders that do not require
* AutoBean implementation details.
*/
public static EncodeState forTesting() {
return new EncodeState(null, null);
}
final EnumMap enumMap;
final AutoBeanFactory factory;
final StringBuilder sb;
final Stack<AutoBean<?>> seen;
private EncodeState(AutoBeanFactory factory, StringBuilder sb) {
this.factory = factory;
enumMap = factory instanceof EnumMap ? (EnumMap) factory : null;
this.sb = sb;
this.seen = sb == null ? null : new Stack<AutoBean<?>>();
}
}
/**
* Dynamically creates a Coder that is capable of operating on a particular
* parameterization of a datastructure (e.g. {@code Map<String, List<String>>}
* ).
*/
static class CoderCreator extends ParameterizationVisitor {
private Stack<Coder> stack = new Stack<Coder>();
@Override
public void endVisitType(Class<?> type) {
if (List.class.equals(type) || Set.class.equals(type)) {
stack.push(collectionCoder(type, stack.pop()));
} else if (Map.class.equals(type)) {
// Note that the parameters are passed in reverse order
stack.push(mapCoder(stack.pop(), stack.pop()));
} else if (Splittable.class.equals(type)) {
stack.push(splittableCoder());
} else if (type.getEnumConstants() != null) {
@SuppressWarnings(value = {"unchecked"})
Class<Enum<?>> enumType = (Class<Enum<?>>) type;
stack.push(enumCoder(enumType));
} else if (ValueCodex.canDecode(type)) {
stack.push(valueCoder(type));
} else {
stack.push(objectCoder(type));
}
}
public Coder getCoder() {
assert stack.size() == 1 : "Incorrect size: " + stack.size();
return stack.pop();
}
}
/**
* Constructs one of the lightweight collection types.
*/
static class CollectionCoder implements Coder {
private final Coder elementDecoder;
private final Class<?> type;
public CollectionCoder(Class<?> type, Coder elementDecoder) {
this.elementDecoder = elementDecoder;
this.type = type;
}
public Object decode(EncodeState state, Splittable data) {
Collection<Object> collection;
if (List.class.equals(type)) {
collection = new SplittableList<Object>(data, elementDecoder, state);
} else if (Set.class.equals(type)) {
collection = new SplittableSet<Object>(data, elementDecoder, state);
} else {
// Should not reach here
throw new RuntimeException(type.getName());
}
return collection;
}
public void encode(EncodeState state, Object value) {
if (value == null) {
state.sb.append("null");
return;
}
Iterator<?> it = ((Collection<?>) value).iterator();
state.sb.append("[");
if (it.hasNext()) {
elementDecoder.encode(state, it.next());
while (it.hasNext()) {
state.sb.append(",");
elementDecoder.encode(state, it.next());
}
}
state.sb.append("]");
}
public Splittable extractSplittable(EncodeState state, Object value) {
return tryExtractSplittable(value);
}
}
/**
* Produces enums.
*
* @param <E>
*/
static class EnumCoder<E extends Enum<?>> implements Coder {
private final Class<E> type;
public EnumCoder(Class<E> type) {
this.type = type;
}
public Object decode(EncodeState state, Splittable data) {
return state.enumMap.getEnum(type, data.asString());
}
public void encode(EncodeState state, Object value) {
if (value == null) {
state.sb.append("null");
return;
}
state.sb.append(StringQuoter.quote(state.enumMap.getToken((Enum<?>) value)));
}
public Splittable extractSplittable(EncodeState state, Object value) {
return StringQuoter.split(StringQuoter.quote(state.enumMap.getToken((Enum<?>) value)));
}
}
/**
* Used to stop processing.
*/
static class HaltException extends RuntimeException {
public HaltException(RuntimeException cause) {
super(cause);
}
@Override
public RuntimeException getCause() {
return (RuntimeException) super.getCause();
}
}
/**
* Constructs one of the lightweight Map types, depending on the key type.
*/
static class MapCoder implements Coder {
private final Coder keyDecoder;
private final Coder valueDecoder;
/**
* Parameters in reversed order to accommodate stack-based setup.
*/
public MapCoder(Coder valueDecoder, Coder keyDecoder) {
this.keyDecoder = keyDecoder;
this.valueDecoder = valueDecoder;
}
public Object decode(EncodeState state, Splittable data) {
Map<Object, Object> toReturn;
if (data.isIndexed()) {
assert data.size() == 2 : "Wrong data size: " + data.size();
toReturn = new SplittableComplexMap<Object, Object>(data, keyDecoder, valueDecoder, state);
} else {
toReturn = new SplittableSimpleMap<Object, Object>(data, keyDecoder, valueDecoder, state);
}
return toReturn;
}
public void encode(EncodeState state, Object value) {
if (value == null) {
state.sb.append("null");
return;
}
Map<?, ?> map = (Map<?, ?>) value;
boolean isSimpleMap = keyDecoder instanceof ValueCoder;
if (isSimpleMap) {
boolean first = true;
state.sb.append("{");
for (Map.Entry<?, ?> entry : map.entrySet()) {
Object mapKey = entry.getKey();
if (mapKey == null) {
// A null key in a simple map is meaningless
continue;
}
Object mapValue = entry.getValue();
if (first) {
first = false;
} else {
state.sb.append(",");
}
keyDecoder.encode(state, mapKey);
state.sb.append(":");
if (mapValue == null) {
// Null values must be preserved
state.sb.append("null");
} else {
valueDecoder.encode(state, mapValue);
}
}
state.sb.append("}");
} else {
List<Object> keys = new ArrayList<Object>(map.size());
List<Object> values = new ArrayList<Object>(map.size());
for (Map.Entry<?, ?> entry : map.entrySet()) {
keys.add(entry.getKey());
values.add(entry.getValue());
}
state.sb.append("[");
collectionCoder(List.class, keyDecoder).encode(state, keys);
state.sb.append(",");
collectionCoder(List.class, valueDecoder).encode(state, values);
state.sb.append("]");
}
}
public Splittable extractSplittable(EncodeState state, Object value) {
return tryExtractSplittable(value);
}
}
/**
* Recurses into {@link AutoBeanCodexImpl}.
*/
static class ObjectCoder implements Coder {
private final Class<?> type;
public ObjectCoder(Class<?> type) {
this.type = type;
}
public Object decode(EncodeState state, Splittable data) {
AutoBean<?> bean = doDecode(state, type, data);
return bean == null ? null : bean.as();
}
public void encode(EncodeState state, Object value) {
if (value == null) {
state.sb.append("null");
return;
}
doEncode(state, AutoBeanUtils.getAutoBean(value));
}
public Splittable extractSplittable(EncodeState state, Object value) {
return tryExtractSplittable(value);
}
}
static class PropertyCoderCreator extends AutoBeanVisitor {
private AutoBean<?> bean;
@Override
public boolean visit(AutoBean<?> bean, Context ctx) {
this.bean = bean;
return true;
}
@Override
public boolean visitReferenceProperty(String propertyName, AutoBean<?> value,
PropertyContext ctx) {
maybeCreateCoder(propertyName, ctx);
return false;
}
@Override
public boolean visitValueProperty(String propertyName, Object value, PropertyContext ctx) {
maybeCreateCoder(propertyName, ctx);
return false;
}
private void maybeCreateCoder(String propertyName, PropertyContext ctx) {
CoderCreator creator = new CoderCreator();
ctx.accept(creator);
coderFor.put(key(bean, propertyName), creator.getCoder());
}
}
/**
* Extracts properties from a bean and turns them into JSON text.
*/
static class PropertyGetter extends AutoBeanVisitor {
private boolean first = true;
private final EncodeState state;
public PropertyGetter(EncodeState state) {
this.state = state;
}
@Override
public void endVisit(AutoBean<?> bean, Context ctx) {
state.sb.append("}");
state.seen.pop();
}
@Override
public boolean visit(AutoBean<?> bean, Context ctx) {
if (state.seen.contains(bean)) {
throw new HaltException(new UnsupportedOperationException("Cycles not supported"));
}
state.seen.push(bean);
state.sb.append("{");
return true;
}
@Override
public boolean visitReferenceProperty(String propertyName, AutoBean<?> value,
PropertyContext ctx) {
if (value != null) {
encodeProperty(propertyName, value.as(), ctx);
}
return false;
}
@Override
public boolean visitValueProperty(String propertyName, Object value, PropertyContext ctx) {
if (value != null && !value.equals(ValueCodex.getUninitializedFieldValue(ctx.getType()))) {
encodeProperty(propertyName, value, ctx);
}
return false;
}
private void encodeProperty(String propertyName, Object value, PropertyContext ctx) {
CoderCreator pd = new CoderCreator();
ctx.accept(pd);
Coder decoder = pd.getCoder();
if (first) {
first = false;
} else {
state.sb.append(",");
}
state.sb.append(StringQuoter.quote(propertyName));
state.sb.append(":");
decoder.encode(state, value);
}
}
/**
* Populates beans with data extracted from an evaluated JSON payload.
*/
static class PropertySetter extends AutoBeanVisitor {
private Splittable data;
private EncodeState state;
public void decodeInto(EncodeState state, Splittable data, AutoBean<?> bean) {
this.data = data;
this.state = state;
bean.accept(this);
}
@Override
public boolean visitReferenceProperty(String propertyName, AutoBean<?> value,
PropertyContext ctx) {
decodeProperty(propertyName, ctx);
return false;
}
@Override
public boolean visitValueProperty(String propertyName, Object value, PropertyContext ctx) {
decodeProperty(propertyName, ctx);
return false;
}
protected void decodeProperty(String propertyName, PropertyContext ctx) {
if (!data.isNull(propertyName)) {
CoderCreator pd = new CoderCreator();
ctx.accept(pd);
Coder decoder = pd.getCoder();
Object propertyValue = decoder.decode(state, data.get(propertyName));
ctx.set(propertyValue);
}
}
}
/**
* A passthrough Coder.
*/
static class SplittableCoder implements Coder {
static final Coder INSTANCE = new SplittableCoder();
public Object decode(EncodeState state, Splittable data) {
return data;
}
public void encode(EncodeState state, Object value) {
if (value == null) {
state.sb.append("null");
return;
}
state.sb.append(((Splittable) value).getPayload());
}
public Splittable extractSplittable(EncodeState state, Object value) {
return (Splittable) value;
}
}
/**
* Delegates to ValueCodex.
*/
static class ValueCoder implements Coder {
private final Class<?> type;
public ValueCoder(Class<?> type) {
assert type.getEnumConstants() == null : "Should use EnumTypeCodex";
this.type = type;
}
public Object decode(EncodeState state, Splittable propertyValue) {
if (propertyValue == null || propertyValue == Splittable.NULL) {
return ValueCodex.getUninitializedFieldValue(type);
}
return ValueCodex.decode(type, propertyValue);
}
public void encode(EncodeState state, Object value) {
state.sb.append(ValueCodex.encode(type, value).getPayload());
}
public Splittable extractSplittable(EncodeState state, Object value) {
return ValueCodex.encode(type, value);
}
}
/**
* A map of AutoBean interface+property names to the Coder for that property.
*/
private static final Map<String, Coder> coderFor = new HashMap<String, Coder>();
/**
* A map of types to a Coder that handles the type.
*/
private static final Map<Class<?>, Coder> coders = new HashMap<Class<?>, Coder>();
public static Coder collectionCoder(Class<?> type, Coder elementCoder) {
return new CollectionCoder(type, elementCoder);
}
public static Coder doCoderFor(AutoBean<?> bean, String propertyName) {
String key = key(bean, propertyName);
Coder toReturn = coderFor.get(key);
if (toReturn == null) {
bean.accept(new PropertyCoderCreator());
toReturn = coderFor.get(key);
if (toReturn == null) {
throw new IllegalArgumentException(propertyName);
}
}
return toReturn;
}
public static <T> AutoBean<T> doDecode(EncodeState state, Class<T> clazz, Splittable data) {
/*
* If we decode the same Splittable twice, re-use the ProxyAutoBean to
* maintain referential integrity. If we didn't do this, either facade would
* update the same backing data, yet not be the same object via ==
* comparison.
*/
@SuppressWarnings("unchecked")
AutoBean<T> toReturn = (AutoBean<T>) data.getReified(AutoBeanCodexImpl.class.getName());
if (toReturn != null) {
return toReturn;
}
toReturn = state.factory.create(clazz);
data.setReified(AutoBeanCodexImpl.class.getName(), toReturn);
if (toReturn == null) {
throw new IllegalArgumentException(clazz.getName());
}
((AbstractAutoBean<T>) toReturn).setData(data);
return toReturn;
}
public static void doDecodeInto(EncodeState state, Splittable data, AutoBean<?> bean) {
new PropertySetter().decodeInto(state, data, bean);
}
public static void doEncode(EncodeState state, AutoBean<?> bean) {
PropertyGetter e = new PropertyGetter(state);
try {
bean.accept(e);
} catch (HaltException ex) {
throw ex.getCause();
}
}
public static <E extends Enum<?>> Coder enumCoder(Class<E> type) {
Coder toReturn = coders.get(type);
if (toReturn == null) {
toReturn = new EnumCoder<E>(type);
coders.put(type, toReturn);
}
return toReturn;
}
public static Coder mapCoder(Coder valueCoder, Coder keyCoder) {
return new MapCoder(valueCoder, keyCoder);
}
public static Coder objectCoder(Class<?> type) {
Coder toReturn = coders.get(type);
if (toReturn == null) {
toReturn = new ObjectCoder(type);
coders.put(type, toReturn);
}
return toReturn;
}
public static Coder splittableCoder() {
return SplittableCoder.INSTANCE;
}
public static Coder valueCoder(Class<?> type) {
Coder toReturn = coders.get(type);
if (toReturn == null) {
toReturn = new ValueCoder(type);
coders.put(type, toReturn);
}
return toReturn;
}
static Splittable tryExtractSplittable(Object value) {
AutoBean<?> bean = AutoBeanUtils.getAutoBean(value);
if (bean != null) {
value = bean;
}
if (bean instanceof HasSplittable) {
return ((HasSplittable) bean).getSplittable();
}
return null;
}
private static String key(AutoBean<?> bean, String propertyName) {
return bean.getType().getName() + ":" + propertyName;
}
}