AsmHelper

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.myfaces.orchestra.dynaForm.metadata.impl.ejb;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.myfaces.orchestra.lib.OrchestraException;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;

/**
 * Reimplement the reflection facilities provided by Class.class, but preserving the order in which
 * the properties exist within the .class file.
 * <p>
 * Presumably the field order in the .class file is the same as the order they are declared within
 * the source file. And presumably the code author arranged those in some logical order.
 * <p>
 * This class uses the ASM library to inspect the class data.
 */
public class AsmHelper implements ClassHelper
{
    /**
     * Alas, the ASM project broke binary compatibility between the 2.x and 3.x
     * release for no good reason. In order to be compatible with either version
     * of ASM, we need to use reflection to invoke ClassReader.accept.
     * <p>
     * In 2.x releases, we must call ClassReader.accept(classVisitor, boolean).
     * In 3.x releases we must call ClassReader.accept(classVisitor, int).
     * <p>
     * In both cases, the second arg is a constant value (though of different type).
     * <p>
     * This class therefore supports checking what ASM version is in the classpath
     * and handles invoking the appropriate method variant.
     * <p>
     * The code below does not support ASM 1.x.
     */
    private static class AcceptMethodInfo
    {
        private final Method method;
        private final Object arg;

        AcceptMethodInfo(Method method, Object arg)
        {
            this.method = method;
            this.arg = arg;
        }

        private void invoke(ClassReader instance, Object visitor)
        throws IOException, IllegalAccessException, InvocationTargetException
        {
            Object[] args = new Object[2];
            args[0] = visitor;
            args[1] = arg;
            method.invoke(instance, args);
        }

        private static AcceptMethodInfo getInstance() throws ExceptionInInitializerError
        {
            // signature for ASM 3.x
            Class[] argsForm2 = new Class[] { ClassVisitor.class, Integer.TYPE };
            try
            {
                Method m = ClassReader.class.getMethod("accept", argsForm2);
                // ok, we are running with asm 3.0.x, 3.1.x or compatible
                // flags=SKIP_DEBUG|SKIP_CODE|SKIP_FRAMES
                Integer flags = Integer.valueOf(1 | 2 | 4);
                return new AcceptMethodInfo(m, flags);
            }
            catch (NoSuchMethodException e)
            {
                // ok
            }

            // signature for ASM 1.x and 2.x
            Class[] argsForm1 = new Class[] { ClassVisitor.class, Boolean.TYPE };
            try
            {
                Method m = ClassReader.class.getMethod("accept", argsForm1);
                // ok, we are running with asm 1.x or 2.x
                // skipDebug=true
                return new AcceptMethodInfo(m, Boolean.TRUE);
            }
            catch (NoSuchMethodException e)
            {
                // ok
            }

            throw new ExceptionInInitializerError(
                    "AsmHelper cannot find compatible ClassReader.access method");
        }
    }

    private final Log log = LogFactory.getLog(AsmHelper.class);
    private static final Field[] FIELDS_TYPE = new Field[0];
    private static final Method[] METHODS_TYPE = new Method[0];
    private static final AcceptMethodInfo ACCEPT_METHOD_INFO = AcceptMethodInfo.getInstance();

    private void applyVisitorToClass(Class clazz, ClassVisitor visitor)
    {
        // Note: Simply using the constructor ClassReader(clazz.getName())
        // does not allow control over which classloader the class is loaded
        // from.
        String className = clazz.getName().replace('.', '/') + ".class";
        ClassReader cr = null;
        InputStream is = null;
        try
        {
            is = this.getClass().getClassLoader().getResourceAsStream(className);
            cr = new ClassReader(is);

            // Invoke ClassReader.accept(ClassVisitor, ?).
            // See method initAsm for further details...
            ACCEPT_METHOD_INFO.invoke(cr, visitor);
        }
        catch (IOException e)
        {
            throw new OrchestraException("Unable to read class " + className, e);
        }
        catch(InvocationTargetException e)
        {
            // should never happen
            throw new OrchestraException("Unable to read class " + className, e);
        }
        catch(IllegalAccessException e)
        {
            // should never happen
            throw new OrchestraException("Unable to read class " + className, e);
        }
        finally
        {
            if (is != null)
            {
                try
                {
                    is.close();
                }
                catch (IOException e2)
                {
                    // Not likely to occur, and nothing can be done about it.
                    log.error("Unable to close input stream", e2);
                }
            }
        }
    }

    /**
     * Return a list of all the static and non-static fields of the specified class, regardless of
     * their accessability.
     * <p>
     * The array order matches the order in which the fields were declared within the original
     * source file.
     */
    public Field[] getFields(final Class<?> clazz)
    {
        final List<Field> fields = new ArrayList<Field>(50);
        ClassVisitor fv = new EmptyClassVisitor()
        {
            @Override
            public FieldVisitor visitField(int access, String name, String desc, String signature,
                    Object value)
            {
                try
                {
                    // Note: no two fields can have the same name, so we don't need to check
                    // whether the found field is already in the fields list.
                    Field f = clazz.getDeclaredField(name);
                    fields.add(f);
                }
                catch (NoSuchFieldException e)
                {
                    log.warn("Cannot find Field object for " + name);
                }
                return super.visitField(access, name, desc, signature, value);
            }
        };
        applyVisitorToClass(clazz, fv);
        return fields.toArray(FIELDS_TYPE);
    }

    /**
     * Given an ASM method descriptor, find the associated java.lang.reflect.Method object.
     * <p>
     * Returns null if no such method is found.
     */
    private Method getMethod(Class<?> clazz, String methodName, String descriptor)
    {
        // TODO: this looping through all methods and calling getMethodDescriptor
        // on each one is not very efficient. It might be nice to build all the
        // descriptor->Method mappings once and cache them in a map. The question
        // then is how long to hold onto that cached data though. And where to
        // store it, as keeping the cache in a parent classloader will prevent unloading
        // of any of the classes that those Method objects are on, unless weak
        // references are used. For now, keep things simple..
        Method[] methods = clazz.getDeclaredMethods();
        for (Method m : methods)
        {
            if (m.getName().equals(methodName))
            {
                String thisMethodDesc = org.objectweb.asm.Type.getMethodDescriptor(m);
                if (thisMethodDesc.equals(descriptor))
                {
                    return m;
                }
            }
        }

        return null;
    }

    /**
     * Return a list of all the get*, set* and is* method on the specified class, regardless of
     * their accessability.
     * <p>
     * The array order matches the order in which the methods were declared within the original
     * source file.
     */
    public Method[] getMethods(final Class<?> clazz)
    {
        final List<Method> methods = new ArrayList<Method>(50);
        ClassVisitor fv = new EmptyClassVisitor()
        {
            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor,
                    String signature, String[] exceptions)
            {
                // Note that "descriptor" is like signature, except without any info about
                // java15 generic type params. When a visited method has no generic types
                // in its prototype, then param signature=null.
                //
                // As there can never be two methods with the same "descriptor", we just
                // use that to locate the real Method object.
                if (name.startsWith("set") || name.startsWith("get") || name.startsWith("is"))
                {
                    Method m = getMethod(clazz, name, descriptor);
                    if ((m != null) && !methods.contains(m))
                    {
                        methods.add(m);
                    }
                }
                return super.visitMethod(access, name, descriptor, signature, exceptions);
            }

        };
        applyVisitorToClass(clazz, fv);
        return methods.toArray(METHODS_TYPE);
    }
}