com.google.gwt.user.client.rpc.impl.AbstractSerializationStreamWriter Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of gwt-user Show documentation
The newest version!
/*
 * Copyright 2008 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.user.client.rpc.impl;

import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.client.rpc.SerializationStreamWriter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;

/**
 * Base class for the client and server serialization streams. This class
 * handles the basic serialization and deserialization formatting for primitive
 * types since these are common between the client and the server. It also
 * handles Object- and String-tracking for building graph references.
 */
public abstract class AbstractSerializationStreamWriter extends
    AbstractSerializationStream implements SerializationStreamWriter {

  private static final double TWO_PWR_16_DBL = 0x10000;
  private static final double TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;

  /**
   * Return a pair of doubles { low, high } that add up to the given number,
   * such that "low" is always between 0 and 2^32-1 inclusive and "high" is
   * always between -2^63 and 2^63-2^32 inclusive and is a multiple of 2^32.
   */
  public static double[] getAsDoubleArray(long value) {
    int lowBits = (int) (value & 0xffffffff);
    int highBits = (int) (value >> 32);
    return makeLongComponents(lowBits, highBits);
  }
  
  // Equivalent to getAsDoubleArray((long) highBits << 32 | lowBits);
  protected static double[] makeLongComponents(int lowBits, int highBits) {
    double high = highBits * TWO_PWR_32_DBL;
    double low = lowBits;
    if (lowBits < 0) {
      low += TWO_PWR_32_DBL;
    }
    return new double[] {low, high};
  }

  private int objectCount;

  private Map objectMap = new IdentityHashMap();

  private Map stringMap = new HashMap();

  private List stringTable = new ArrayList();

  public void prepareToWrite() {
    objectCount = 0;
    objectMap.clear();
    stringMap.clear();
    stringTable.clear();
  }

  @Override
  public abstract String toString();

  public void writeBoolean(boolean fieldValue) {
    append(fieldValue ? "1" : "0");
  }

  public void writeByte(byte fieldValue) {
    append(String.valueOf(fieldValue));
  }

  public void writeChar(char ch) {
    // just use an int, it's more foolproof
    append(String.valueOf((int) ch));
  }

  public void writeDouble(double fieldValue) {
    append(String.valueOf(fieldValue));
  }

  public void writeFloat(float fieldValue) {
    writeDouble(fieldValue);
  }

  public void writeInt(int fieldValue) {
    append(String.valueOf(fieldValue));
  }
  
  public abstract void writeLong(long value);

  public void writeObject(Object instance) throws SerializationException {
    if (instance == null) {
      // write a null string
      writeString(null);
      return;
    }

    int objIndex = getIndexForObject(instance);
    if (objIndex >= 0) {
      // We've already encoded this object, make a backref
      // Transform 0-based to negative 1-based
      writeInt(-(objIndex + 1));
      return;
    }

    saveIndexForObject(instance);

    // Serialize the type signature
    String typeSignature = getObjectTypeSignature(instance);
    if (typeSignature == null) {
      throw new SerializationException(
          "could not get type signature for " + instance.getClass());
    }
    writeString(typeSignature);
    // Now serialize the rest of the object
    serialize(instance, typeSignature);
  }

  public void writeShort(short value) {
    append(String.valueOf(value));
  }

  public void writeString(String value) {
    writeInt(addString(value));
  }

  /**
   * Add a string to the string table and return its index.
   * 
   * @param string the string to add
   * @return the index to the string
   */
  protected int addString(String string) {
    if (string == null) {
      return 0;
    }
    Integer o = stringMap.get(string);
    if (o != null) {
      return o;
    }
    stringTable.add(string);
    // index is 1-based
    int index = stringTable.size();
    stringMap.put(string, index);
    return index;
  }

  /**
   * Append a token to the underlying output buffer.
   * 
   * @param token the token to append
   */
  protected abstract void append(String token);

  /**
   * Get the index for an object that may have previously been saved via
   * {@link #saveIndexForObject(Object)}.
   * 
   * @param instance the object to save
   * @return the index associated with this object, or -1 if this object hasn't
   *         been seen before
   */
  protected int getIndexForObject(Object instance) {
    return objectMap.containsKey(instance) ? objectMap.get(instance) : -1;
  }

  /**
   * Compute and return the type signature for an object.
   * 
   * @param instance the instance to inspect
   * @return the type signature of the instance
   */
  protected abstract String getObjectTypeSignature(Object instance)
      throws SerializationException;

  /**
   * Gets the string table.
   */
  protected List getStringTable() {
    return stringTable;
  }

  /**
   * Remember this object as having been seen before.
   * 
   * @param instance the object to remember
   */
  protected void saveIndexForObject(Object instance) {
    objectMap.put(instance, objectCount++);
  }

  /**
   * Serialize an object into the stream.
   * 
   * @param instance the object to serialize
   * @param typeSignature the type signature of the object
   * @throws SerializationException
   */
  protected abstract void serialize(Object instance, String typeSignature)
      throws SerializationException;
}