/FileExtraction/Java_unseen/dlitz_resin/modules/kernel/src/com/caucho/config/bytecode/SerializationAdapter.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 Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.config.bytecode;

import java.io.ByteArrayOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;

import com.caucho.bytecode.CodeWriterAttribute;
import com.caucho.bytecode.ConstantPool;
import com.caucho.bytecode.JavaClass;
import com.caucho.bytecode.JavaClassLoader;
import com.caucho.bytecode.JavaField;
import com.caucho.bytecode.JavaMethod;
import com.caucho.config.ConfigException;
import com.caucho.config.inject.HandleAware;
import com.caucho.inject.Module;
import com.caucho.loader.ProxyClassLoader;
import com.caucho.vfs.Vfs;
import com.caucho.vfs.WriteStream;

/**
 * interceptor generation
 */
@Module
public class SerializationAdapter<X> {
  private final Class<X> _cl;
  
  private Class<X> _proxyClass;

  private SerializationAdapter(Class<X> cl)
  {
    _cl = cl;
  }

  public static <X> Class<X> gen(Class<X> cl)
  {
    if (Modifier.isFinal(cl.getModifiers()))
      return cl;
    if (HandleAware.class.isAssignableFrom(cl))
      return cl;

    SerializationAdapter<X> gen = new SerializationAdapter<X>(cl);

    Class<X> proxyClass = gen.generateProxy();

    return proxyClass;
  }

  public static void setHandle(Object obj, Object handle)
  {
    if (obj instanceof HandleAware) {
      ((HandleAware) obj).setSerializationHandle(handle);
    }
    else {
      try {
        Class cl = obj.getClass();

        for (Field field : cl.getDeclaredFields()) {
          if (field.getName().equals("__caucho_handle")) {
            field.setAccessible(true);
            field.set(obj, handle);
          }
        }
      } catch (Exception e) {
        throw ConfigException.create(e);
      }
    }
  }

  private Class generateProxy()
  {
    try {
      JavaClassLoader jLoader = new JavaClassLoader(_cl.getClassLoader());
      
      JavaClass jClass = new JavaClass(jLoader);
      jClass.setAccessFlags(Modifier.PUBLIC);
      ConstantPool cp = jClass.getConstantPool();

      jClass.setWrite(true);
      
      jClass.setMajor(49);
      jClass.setMinor(0);

      String superClassName = _cl.getName().replace('.', '/');
      String thisClassName = superClassName + "$BeanProxy";

      jClass.setSuperClass(superClassName);
      jClass.setThisClass(thisClassName);

      jClass.addInterface("java/io/Serializable");
      jClass.addInterface("com/caucho/config/inject/HandleAware");

      generateConstructors(jClass, superClassName);
      
      generateWriteReplace(jClass);
      generateSetHandle(jClass);

      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      WriteStream out = Vfs.openWrite(bos);

      jClass.write(out);
    
      out.close();

      byte []buffer = bos.toByteArray();

      if (false) {
        String userName = System.getProperty("user.name");
        
        out = Vfs.lookup("file:/tmp/" + userName + "/qa/temp.class").openWrite();
        out.write(buffer, 0, buffer.length);
        out.close();
      }
      
      String cleanName = thisClassName.replace('/', '.');
      _proxyClass = (Class<X>) new ProxyClassLoader().loadClass(cleanName, buffer);
    } catch (RuntimeException e) {
      throw e;
    } catch (Exception e) {
      throw new RuntimeException(e);
    }

    return _proxyClass;
  }

  private void generateConstructors(JavaClass jClass, String superClassName)
  {
    for (Constructor baseCtor : _cl.getDeclaredConstructors()) {
      if (Modifier.isPrivate(baseCtor.getModifiers()))
        continue;

      generateConstructor(jClass, superClassName, baseCtor);
    }
  }

  public static void generateConstructor(JavaClass jClass,
                                         String superClassName,
                                         Constructor baseCtor)
  {
    Class []types = baseCtor.getParameterTypes();

    StringBuilder sb = new StringBuilder();
    createDescriptor(sb, types);
    sb.append("V");

    String descriptor = sb.toString();
      
    JavaMethod ctor = jClass.createMethod("<init>", descriptor);
      
    ctor.setAccessFlags(Modifier.PUBLIC);
      
    CodeWriterAttribute code = ctor.createCodeWriter();
    code.setMaxLocals(5 + 2 * types.length);
    code.setMaxStack(5 + 2 * types.length);

    code.pushObjectVar(0);

    marshal(code, types);

    code.invokespecial(superClassName, "<init>", descriptor, 1, 0);
    code.addReturn();
    code.close();
  }

  private void generateWriteReplace(JavaClass jClass)
  {
    JavaField jField
      = jClass.createField("__caucho_handle", "Ljava/lang/Object;");
    jField.setAccessFlags(Modifier.PRIVATE);
    
    JavaMethod jMethod
      = jClass.createMethod("writeReplace", "()Ljava/lang/Object;");
    
    jMethod.setAccessFlags(Modifier.PRIVATE);
      
    CodeWriterAttribute code = jMethod.createCodeWriter();
    code.setMaxLocals(5);
    code.setMaxStack(5);

    code.pushObjectVar(0);
    code.getField(jClass.getThisClass(), "__caucho_handle",
                   "Ljava/lang/Object;");

    code.addObjectReturn();
    
    code.close();
  }

  private void generateSetHandle(JavaClass jClass)
  {
    /*
    JavaField jField
      = jClass.createField("__caucho_handle", "Ljava/lang/Object;");
    jField.setAccessFlags(Modifier.PRIVATE);
    */
    
    JavaMethod jMethod
      = jClass.createMethod("setSerializationHandle", "(Ljava/lang/Object;)V");
    
    jMethod.setAccessFlags(Modifier.PUBLIC);
      
    CodeWriterAttribute code = jMethod.createCodeWriter();
    code.setMaxLocals(5);
    code.setMaxStack(5);

    code.pushObjectVar(0);
    code.pushObjectVar(1);
    code.putField(jClass.getThisClass(), "__caucho_handle",
                  "Ljava/lang/Object;");

    code.addReturn();
    
    code.close();
  }

  public static void marshal(CodeWriterAttribute code, Class []param)
  {
    int stack = 1;
    int index = 1;
    
    for (int i = 0; i < param.length; i++) {
      Class type = param[i];
      
      if (boolean.class.equals(type)
          || byte.class.equals(type)
          || short.class.equals(type)
          || int.class.equals(type)) {
        code.pushIntVar(index);
        index += 1;
        stack += 1;
      }
      else if (long.class.equals(type)) {
        code.pushLongVar(index);
        index += 2;
        stack += 2;
      }
      else if (float.class.equals(type)) {
        code.pushFloatVar(index);
        index += 1;
        stack += 1;
      }
      else if (double.class.equals(type)) {
        code.pushDoubleVar(index);
        index += 2;
        stack += 2;
      }
      else {
        code.pushObjectVar(index);
        index += 1;
        stack += 1;
      }
    }
  }

  private int parameterCount(Class []parameters)
  {
    int count = 0;

    for (Class param : parameters) {
      if (long.class.equals(param) || double.class.equals(param))
        count += 2;
      else
        count += 1;
    }

    return count;
  }

  public static void createDescriptor(StringBuilder sb, Class []params)
  {
    sb.append("(");
    
    for (Class param : params) {
      sb.append(createDescriptor(param));
    }
    
    sb.append(")");
  }

  public static String createDescriptor(Class cl)
  {
    if (cl.isArray())
      return "[" + createDescriptor(cl.getComponentType());

    String primValue = _prim.get(cl);

    if (primValue != null)
      return primValue;

    return "L" + cl.getName().replace('.', '/') + ";";
  }

  private static HashMap<Class,String> _prim = new HashMap<Class,String>();
  private static HashMap<Class,String> _boxClass = new HashMap<Class,String>();

  static {
    _prim.put(boolean.class, "Z");
    _prim.put(byte.class, "B");
    _prim.put(char.class, "C");
    _prim.put(short.class, "S");
    _prim.put(int.class, "I");
    _prim.put(long.class, "J");
    _prim.put(float.class, "F");
    _prim.put(double.class, "D");
    _prim.put(void.class, "V");
    
    _boxClass.put(boolean.class, "java/lang/Boolean");
    _boxClass.put(byte.class, "java/lang/Byte");
    _boxClass.put(char.class, "java/lang/Character");
    _boxClass.put(short.class, "java/lang/Short");
    _boxClass.put(int.class, "java/lang/Integer");
    _boxClass.put(long.class, "java/lang/Long");
    _boxClass.put(float.class, "java/lang/Float");
    _boxClass.put(double.class, "java/lang/Double");
  }
}
