/FileExtraction/Java_unseen/dlitz_resin/modules/resin/src/com/caucho/ejb/hessian/MarshalGenerator.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *   Free SoftwareFoundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.ejb.hessian;

import com.caucho.java.AbstractGenerator;
import com.caucho.loader.DynamicClassLoader;
import com.caucho.util.CharBuffer;
import com.caucho.util.IntMap;
import com.caucho.vfs.Path;

import java.io.IOException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * Base class for generating code to marshal and unmarshal sml-rpc calls.
 */
abstract class MarshalGenerator extends AbstractGenerator {
  // Classes which can be safely passed by reference because they're
  // immutable and part of the JDK
  static IntMap immutableClasses;
  
  protected static Class readerClass;
  protected static Class inputStreamClass;
  protected static Class remoteClass;
  protected static Class nodeClass;
  
  static {
    readerClass = java.io.Reader.class;
    inputStreamClass = java.io.InputStream.class;
    remoteClass = java.rmi.Remote.class;
    nodeClass = org.w3c.dom.Node.class;
  }
  
  protected Class _cl;
  String objClass;
  String fullName;
  String pkg;
  String className;

  protected int unique;
  
  protected ArrayList marshallClasses;
  protected ArrayList unmarshallClasses;
  
  protected ArrayList marshallArrays;
  protected ArrayList unmarshallArrays;

  /**
   * Initialize the generated classname.
   *
   * @param beanClass the bean which needs the stub/skeleton
   *
   * @return the path to the file to be generated
   */
  Path initClassNames(Class beanClass, String suffix)
    throws Exception
  {
    ClassLoader parentLoader = getParentLoader();
    
    if (parentLoader instanceof DynamicClassLoader) {
      DynamicClassLoader dcl = (DynamicClassLoader) parentLoader;

      dcl.make();
    }

    Path workPath = getClassDir();

    _cl = beanClass;

    fullName = _cl.getName() + suffix;

    objClass = _cl.getName();
    int p = objClass.lastIndexOf('.');
    if (p > 0)
      objClass = objClass.substring(p + 1);
    
    p = fullName.lastIndexOf('.');
    if (p > 0) {
      pkg = fullName.substring(0, p);
      className = fullName.substring(p + 1);
    }
    else
      className = fullName;

    Path path = workPath.lookup(fullName.replace('.', '/') + ".java");
    path.getParent().mkdirs();

    return path;
  }

  /**
   * Creates a unique mangled method name based on the method name and
   * the method parameters.
   *
   * @param name the base method name
   * @param method the method to mangle
   * @param isFull if true, mangle the full classname
   *
   * @return a mangled string.
   */
  protected String mangleMethodName(String name, Method method, boolean isFull)
  {
    CharBuffer cb = CharBuffer.allocate();
    
    cb.append(name);
    
    Class []params = method.getParameterTypes();
    for (int i = 0; i < params.length; i++) {
      cb.append('_');
      mangleClass(cb, params[i], isFull);
    }

    return cb.close();
  }

  /**
   * Creates a unique mangled method name based on the method name and
   * the method parameters.
   *
   * @param name the base method name
   * @param method the method to mangle
   * @param isFull if true, mangle the full classname
   *
   * @return a mangled string.
   */
  protected String mangleMethodName(String name, Class []param, boolean isFull)
  {
    CharBuffer cb = CharBuffer.allocate();
    
    cb.append(name);
    
    for (int i = 0; i < param.length; i++) {
      cb.append('_');
      mangleClass(cb, param[i], isFull);
    }

    return cb.close();
  }

  /**
   * Mangles a classname.
   */
  private void mangleClass(CharBuffer cb, Class cl, boolean isFull)
  {
    String name = cl.getName();

    if (name.equals("boolean"))
      cb.append("boolean");
    else if (name.equals("int") ||
             name.equals("short") ||
             name.equals("byte"))
      cb.append("int");
    else if (name.equals("long"))
      cb.append("long");
    else if (name.equals("double") || name.equals("float"))
      cb.append("double");
    else if (name.equals("java.lang.String") ||
             name.equals("com.caucho.util.CharBuffer") ||
             name.equals("char") ||
             name.equals("java.io.Reader"))
      cb.append("string");
    else if (name.equals("java.util.Date") ||
             name.equals("com.caucho.util.QDate"))
      cb.append("date");
    else if (inputStreamClass.isAssignableFrom(cl) ||
             name.equals("[B"))
      cb.append("binary");
    else if (cl.isArray()) {
      cb.append("[");
      mangleClass(cb, cl.getComponentType(), isFull);
    }
    else if (name.equals("org.w3c.dom.Node") ||
             name.equals("org.w3c.dom.Element") ||
             name.equals("org.w3c.dom.Document"))
      cb.append("xml");
    else if (isFull)
      cb.append(name);
    else {
      int p = name.lastIndexOf('.');
      if (p > 0)
        cb.append(name.substring(p + 1));
      else
        cb.append(name);
    }
  }

  /**
   * Prints a method declaration with a given name.
   *
   * @param name the name to use for the generated method
   * @param method the method to override
   */
  protected void printMethodDeclaration(String name, Method method)
    throws IOException
  {
    Class ret = method.getReturnType();
    Class []params = method.getParameterTypes();

    Class []exns = method.getExceptionTypes();

    println();
    print("public ");
    printClass(ret);
    print(" " + name + "(");
    for (int i = 0; i < params.length; i++) {
      if (i != 0)
        print(", ");
      printClass(params[i]);
      print(" _arg" + i);
    }
    println(")");
    if (exns.length > 0)
      print("  throws ");
    for (int i = 0; i < exns.length; i++) {
      if (i != 0)
        print(", ");
      printClass(exns[i]);
    }
    if (exns.length > 0)
      println();
  }

  /**
   * Unmarshal the reading of a single variable, knowing the result
   * type.
   *
   * @param var the generated java variable which will receive the data.
   * @param cl the class of the target variable.
   */
  protected void printUnmarshalType(Class cl)
    throws IOException
  {
    String name = cl.getName();

    if (cl.equals(boolean.class)) {
      println("in.readBoolean();");
    }
    else if (cl.equals(int.class)) {
      println("in.readInt();");
    }
    else if (cl.equals(short.class) ||
             cl.equals(char.class) ||
             cl.equals(byte.class)) {
      println("(" + name + ") in.readInt();");
    }
    else if (cl.equals(long.class)) {
      println("in.readLong();");
    }
    else if (cl.equals(double.class)) {
      println("in.readDouble();");
    }
    else if (cl.equals(float.class)) {
      println("(" + name + ") in.readDouble();");
    }
    else if (cl.equals(String.class))
      println("in.readString();");
    else if (cl.equals(java.util.Date.class)) {
      println("new java.util.Date(in.readUTCDate());");
    }
    else if (cl.equals(byte[].class)) {
      println("in.readBytes();");
    }
    else if (org.w3c.dom.Node.class.isAssignableFrom(cl)) {
      println("in.readNode();");
    }
    else if (cl.equals(java.lang.Object.class)) {
      println("in.readObject();");
    }
    else {
      print("(");
      printClass(cl);
      print(") in.readObject(");
      printClass(cl);
      println(".class);");
    }
  }

  protected void printMarshalType(Class cl, String var)
    throws IOException
  {
    String name = cl.getName();

    if (cl.equals(void.class)) {
      println("out.writeNull();");
    }
    else if (cl.equals(boolean.class)) {
      println("out.writeBoolean(" + var + ");");
    }
    else if (cl.equals(int.class) ||
             cl.equals(short.class) ||
             cl.equals(char.class) ||
             cl.equals(byte.class)) {
      println("out.writeInt(" + var + ");");
    }
    else if (cl.equals(long.class)) {
      println("out.writeLong(" + var + ");");
    }
    else if (cl.equals(double.class) || cl.equals(float.class)) {
      println("out.writeDouble(" + var + ");");
    }
    else if (cl.equals(String.class)) {
      println("out.writeString(" + var + ");");
    }
    else if (cl.equals(java.util.Date.class)) {
      println("out.writeUTCDate(" + var + " == null ? 0 : " + var + ".getTime());");
    }
    else if (org.w3c.dom.Node.class.isAssignableFrom(cl)) {
      println("out.writeXml(" + var + ");");
    }
    else if (cl.equals(byte[].class)) {
      println("out.writeBytes(" + var + ");");
    }
    else {
      println("out.writeObject(" + var + ");");
    }
  }

  /**
   * Returns true if the class needs serialization.
   *
   * @param cl the class to test.
   *
   * @return true if the class needs serialization
   */
  boolean needsSerialization(Class cl)
  {
    if (cl.isPrimitive())
      return false;
    else
      return immutableClasses.get(cl) < 0;
  }

  public void printClass(Class cl)
    throws IOException
  {
    if (! cl.isArray())
      print(cl.getName());
    else {
      printClass(cl.getComponentType());
      print("[]");
    }
  }

  protected void printNewArray(Class cl)
    throws IOException
  {
    if (! cl.isArray()) {
      print(cl.getName());
      print("[length]");
    }
    else {
      printNewArray(cl.getComponentType());
      print("[]");
    }
  }

  static {
    immutableClasses = new IntMap();
    immutableClasses.put(String.class, 1);
    immutableClasses.put(Byte.class, 1);
    immutableClasses.put(Character.class, 1);
    immutableClasses.put(Short.class, 1);
    immutableClasses.put(Integer.class, 1);
    immutableClasses.put(Long.class, 1);
    immutableClasses.put(Float.class, 1);
    immutableClasses.put(Double.class, 1);
    immutableClasses.put(Class.class, 1);
  }
}
