user/src/com/google/web/bindery/autobean/shared/impl/AbstractAutoBean.java

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