/*
* 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.web.bindery.autobean.shared.impl;
import com.google.gwt.core.client.impl.WeakMapping;
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.Context;
import com.google.web.bindery.autobean.shared.Splittable;
import com.google.web.bindery.autobean.shared.impl.AutoBeanCodexImpl.Coder;
import com.google.web.bindery.autobean.shared.impl.AutoBeanCodexImpl.EncodeState;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* Basic implementation.
*
* @param <T> the wrapper type
*/
public abstract class AbstractAutoBean<T> implements AutoBean<T>, HasSplittable {
/**
* Used to avoid cycles when visiting.
*/
public static class OneShotContext implements Context {
private final Set<AbstractAutoBean<?>> seen = new HashSet<AbstractAutoBean<?>>();
public boolean hasSeen(AbstractAutoBean<?> bean) {
return !seen.add(bean);
}
}
public static final String UNSPLITTABLE_VALUES_KEY = "__unsplittableValues";
protected static final Object[] EMPTY_OBJECT = new Object[0];
/**
* Used by {@link #createSimplePeer()}.
*/
protected Splittable data;
protected T wrapped;
private final AutoBeanFactory factory;
private boolean frozen;
/**
* Lazily initialized by {@link #setTag(String, Object)} because not all
* instances will make use of tags.
*/
private Map<String, Object> tags;
private final boolean usingSimplePeer;
/**
* Constructor that will use a generated simple peer.
*/
protected AbstractAutoBean(AutoBeanFactory factory) {
this(factory, StringQuoter.createSplittable());
}
/**
* Constructor that will use a generated simple peer, backed with existing
* data.
*/
protected AbstractAutoBean(AutoBeanFactory factory, Splittable data) {
this.data = data;
this.factory = factory;
usingSimplePeer = true;
wrapped = createSimplePeer();
}
/**
* Constructor that wraps an existing object. The parameters on this method
* are reversed to avoid conflicting with the other two-arg constructor for
* {@code AutoBean<Splittable>} instances.
*/
protected AbstractAutoBean(T wrapped, AutoBeanFactory factory) {
this.factory = factory;
usingSimplePeer = false;
data = null;
this.wrapped = wrapped;
// Used by AutoBeanUtils
WeakMapping.setWeak(wrapped, AutoBean.class.getName(), this);
}
public void accept(AutoBeanVisitor visitor) {
traverse(visitor, new OneShotContext());
}
public abstract T as();
public AutoBean<T> clone(boolean deep) {
throw new UnsupportedOperationException();
}
public AutoBeanFactory getFactory() {
return factory;
}
public Splittable getSplittable() {
return data;
}
@SuppressWarnings("unchecked")
public <Q> Q getTag(String tagName) {
return tags == null ? null : (Q) tags.get(tagName);
}
/**
* Indicates that the value returned from {@link #getSplittable()} may not
* contain all of the data encapsulated by the AutoBean.
*/
public boolean hasUnsplittableValues() {
return data.isReified(UNSPLITTABLE_VALUES_KEY);
}
public boolean isFrozen() {
return frozen;
}
public boolean isWrapper() {
return !usingSimplePeer;
}
public void setData(Splittable data) {
assert data != null : "null data";
this.data = data;
/*
* The simple peer aliases the data object from the enclosing bean to avoid
* needing to call up the this.this$0 chain.
*/
wrapped = createSimplePeer();
}
public void setFrozen(boolean frozen) {
this.frozen = frozen;
}
public void setTag(String tagName, Object value) {
if (tags == null) {
tags = new HashMap<String, Object>();
}
tags.put(tagName, value);
}
public void traverse(AutoBeanVisitor visitor, OneShotContext ctx) {
// Avoid cycles
if (ctx.hasSeen(this)) {
return;
}
if (visitor.visit(this, ctx)) {
traverseProperties(visitor, ctx);
}
visitor.endVisit(this, ctx);
}
public T unwrap() {
if (usingSimplePeer) {
throw new IllegalStateException();
}
try {
WeakMapping.set(wrapped, AutoBean.class.getName(), null);
return wrapped;
} finally {
wrapped = null;
}
}
/**
* No-op. Used as a debugger hook point for generated code.
*
* @param method the method name
* @param returned the returned object
* @param parameters the parameter list
*/
protected void call(String method, Object returned, Object... parameters) {
}
protected void checkFrozen() {
if (frozen) {
throw new IllegalStateException("The AutoBean has been frozen");
}
}
protected void checkWrapped() {
if (wrapped == null && !usingSimplePeer) {
throw new IllegalStateException("The AutoBean has been unwrapped");
}
}
protected T createSimplePeer() {
throw new UnsupportedOperationException();
}
/**
* No-op. Used as a debugger hook point for generated code.
*
* @param method the method name
* @param toReturn the value to return
*/
protected <V> V get(String method, V toReturn) {
return toReturn;
}
protected <W> W getFromWrapper(W obj) {
// Some versions of javac have problem inferring the generics here
return AutoBeanUtils.<W, W> getAutoBean(obj).as();
}
/**
* Native getters and setters for primitive properties are generated for each
* type to ensure inlining.
*/
protected <Q> Q getOrReify(String propertyName) {
checkWrapped();
if (data.isReified(propertyName)) {
@SuppressWarnings("unchecked")
Q temp = (Q) data.getReified(propertyName);
return temp;
}
if (data.isNull(propertyName)) {
return null;
}
data.setReified(propertyName, null);
Coder coder = AutoBeanCodexImpl.doCoderFor(this, propertyName);
@SuppressWarnings("unchecked")
Q toReturn = (Q) coder.decode(EncodeState.forDecode(factory), data.get(propertyName));
data.setReified(propertyName, toReturn);
return toReturn;
}
protected T getWrapped() {
checkWrapped();
return wrapped;
}
protected boolean isUsingSimplePeer() {
return usingSimplePeer;
}
protected boolean isWrapped(Object obj) {
return AutoBeanUtils.getAutoBean(obj) != null;
}
/**
* No-op. Used as a debugger hook point for generated code.
*
* @param method the method name
* @param value the Object value to be set
*/
protected void set(String method, Object value) {
}
protected void setProperty(String propertyName, Object value) {
checkWrapped();
checkFrozen();
data.setReified(propertyName, value);
if (value == null) {
Splittable.NULL.assign(data, propertyName);
return;
}
Coder coder = AutoBeanCodexImpl.doCoderFor(this, propertyName);
Splittable backing = coder.extractSplittable(EncodeState.forDecode(factory), value);
if (backing == null) {
/*
* External data type, such as an ArrayList or a concrete implementation
* of a setter's interface type. This means that a slow serialization pass
* is necessary.
*/
data.setReified(UNSPLITTABLE_VALUES_KEY, true);
} else {
backing.assign(data, propertyName);
}
}
protected abstract void traverseProperties(AutoBeanVisitor visitor, OneShotContext ctx);
}