Factor.java

/*
    Copyright 1996-2008 Ariba, 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.

    $Id: //ariba/platform/ui/awreload/ariba/awreload/Factor.java#9 $
*/

package ariba.awreload;

import org.apache.bcel.Constants;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.ConstantClass;
import org.apache.bcel.classfile.ConstantUtf8;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.ClassFormatException;
import org.apache.bcel.generic.ClassGen;
import org.apache.bcel.generic.ConstantPoolGen;

import java.io.File;
import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.io.InputStream;

import ariba.util.fieldvalue.CompiledAccessorFactory;

/**
    A simple class renamer.  Used to take class (typically a non-page-level AWComponent) that have runtime changes that
    cannot be reloaded directly by the VM (e.g. additions of methods or fields) and create a renamed version of that
    class that can be loaded along side the original.
*/
public class Factor implements Constants
{
    protected static String Suffix = "_ver";
    protected static int VerSeq = 0;

    protected String      _destDir;
    protected JavaClass   _javaClass;

    protected ClassGen    _derivedClassGen;
    protected String      _derivedName;

    public static Class renameAndReload(Class origClass, String className, byte[] byteCode, String destPath)
    {
        Factor instance = new Factor();
        return instance._renameAndReload(origClass, className, byteCode, destPath);
    }

    protected Class _renameAndReload(Class origClass, String className, byte[] byteCode, String destPath)
    {
        _destDir = destPath;
        String newName = null;
        InputStream is = new ByteArrayInputStream(byteCode);
        Class cls = null;

        try {
            _javaClass = new ClassParser(is, className).parse();

            _derivedClassGen = new ClassGen(_javaClass.copy());

            String oldClassName = _derivedClassGen.getClassName();
            newName = getDerivedName();

                //set the class name and the name for the member field references all at once.
            changeClassName(_derivedClassGen, newName);

                // workaround to reset cache
            _derivedClassGen.setConstantPool(
                new ConstantPoolGen(_derivedClassGen.getConstantPool().getFinalConstantPool()));

                //call this or the cached value remains old
            _derivedClassGen.setClassName(newName);

            byte[] bytecode =_derivedClassGen.getJavaClass().getBytes();

            // In case our build root is in the class path, try to write out
            // the bytes, then load it
            try {
                String dest = new File(destPath, newName.replace('.','/') +  ".class").toString();
                _derivedClassGen.getJavaClass().dump(dest);
                cls =  JavaReloadClassLoader._classForName(newName);
            } catch (Throwable t) {
            }

            // we probably couldn't find it.  Load it with our own class loader
            if (cls == null) {
                try {
                    cls = CompiledAccessorFactory.ByteArrayClassLoader.loadClass(newName, bytecode, origClass.getProtectionDomain());
                } catch (Exception e) {
                    Console.println("Exception loading transformed class: " + newName);
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassFormatException e) {
            e.printStackTrace();
        }
        return cls;
    }

    public static String getOriginalClassName (String alteredName)
    {
        int i = alteredName.indexOf(Suffix);
        return (i==-1) ? alteredName : alteredName.substring(0,i);
    }

    public JavaClass getDerivedClass ()
    {
        return _derivedClassGen.getJavaClass();
    }

    public String getDerivedName ()
    {
        if (_derivedName != null) return _derivedName;

        return _derivedClassGen.getClassName() + Suffix + VerSeq++;
    }

    /**
        Change class name to <old_name>suffix
        @param cg The ClassGen of the class to rename
        @param className New name for the class
    */
    protected void changeClassName (ClassGen cg, String className)
    {
        int index = cg.getClassNameIndex();

        ConstantPoolGen cp = cg.getConstantPool();
        index = ((ConstantClass)cp.getConstant(index)).getNameIndex();
        cp.setConstant(index, new ConstantUtf8(className.replace('.', '/')));
    }


    /**
        @param warning The warning message.
    */
    public static void warn (String warning)
    {
        System.out.println(warning);
    }
}