type.java

jboss规则引擎

/***
 * ASM: a very small and fast Java bytecode manipulation framework
 * Copyright (c) 2000-2005 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.drools.asm;

import java.lang.reflect.Method;

/**
 * A Java type. This class can be used to make it easier to manipulate type and
 * method descriptors.
 * 
 * @author Eric Bruneton
 * @author Chris Nokleberg
 */
public class Type {

    /**
     * The sort of the <tt>void</tt> type. See {@link #getSort getSort}.
     */
    public final static int  VOID         = 0;

    /**
     * The sort of the <tt>boolean</tt> type. See {@link #getSort getSort}.
     */
    public final static int  BOOLEAN      = 1;

    /**
     * The sort of the <tt>char</tt> type. See {@link #getSort getSort}.
     */
    public final static int  CHAR         = 2;

    /**
     * The sort of the <tt>byte</tt> type. See {@link #getSort getSort}.
     */
    public final static int  BYTE         = 3;

    /**
     * The sort of the <tt>short</tt> type. See {@link #getSort getSort}.
     */
    public final static int  SHORT        = 4;

    /**
     * The sort of the <tt>int</tt> type. See {@link #getSort getSort}.
     */
    public final static int  INT          = 5;

    /**
     * The sort of the <tt>float</tt> type. See {@link #getSort getSort}.
     */
    public final static int  FLOAT        = 6;

    /**
     * The sort of the <tt>long</tt> type. See {@link #getSort getSort}.
     */
    public final static int  LONG         = 7;

    /**
     * The sort of the <tt>double</tt> type. See {@link #getSort getSort}.
     */
    public final static int  DOUBLE       = 8;

    /**
     * The sort of array reference types. See {@link #getSort getSort}.
     */
    public final static int  ARRAY        = 9;

    /**
     * The sort of object reference type. See {@link #getSort getSort}.
     */
    public final static int  OBJECT       = 10;

    /**
     * The <tt>void</tt> type.
     */
    public final static Type VOID_TYPE    = new Type( Type.VOID );

    /**
     * The <tt>boolean</tt> type.
     */
    public final static Type BOOLEAN_TYPE = new Type( Type.BOOLEAN );

    /**
     * The <tt>char</tt> type.
     */
    public final static Type CHAR_TYPE    = new Type( Type.CHAR );

    /**
     * The <tt>byte</tt> type.
     */
    public final static Type BYTE_TYPE    = new Type( Type.BYTE );

    /**
     * The <tt>short</tt> type.
     */
    public final static Type SHORT_TYPE   = new Type( Type.SHORT );

    /**
     * The <tt>int</tt> type.
     */
    public final static Type INT_TYPE     = new Type( Type.INT );

    /**
     * The <tt>float</tt> type.
     */
    public final static Type FLOAT_TYPE   = new Type( Type.FLOAT );

    /**
     * The <tt>long</tt> type.
     */
    public final static Type LONG_TYPE    = new Type( Type.LONG );

    /**
     * The <tt>double</tt> type.
     */
    public final static Type DOUBLE_TYPE  = new Type( Type.DOUBLE );

    // ------------------------------------------------------------------------
    // Fields
    // ------------------------------------------------------------------------

    /**
     * The sort of this Java type.
     */
    private final int        sort;

    /**
     * A buffer containing the descriptor of this Java type. This field is only
     * used for reference types.
     */
    private char[]           buf;

    /**
     * The offset of the descriptor of this Java type in {@link #buf buf}. This
     * field is only used for reference types.
     */
    private int              off;

    /**
     * The length of the descriptor of this Java type.
     */
    private int              len;

    // ------------------------------------------------------------------------
    // Constructors
    // ------------------------------------------------------------------------

    /**
     * Constructs a primitive type.
     * 
     * @param sort the sort of the primitive type to be constructed.
     */
    private Type(final int sort) {
        this.sort = sort;
        this.len = 1;
    }

    /**
     * Constructs a reference type.
     * 
     * @param sort the sort of the reference type to be constructed.
     * @param buf a buffer containing the descriptor of the previous type.
     * @param off the offset of this descriptor in the previous buffer.
     * @param len the length of this descriptor.
     */
    private Type(final int sort,
                 final char[] buf,
                 final int off,
                 final int len) {
        this.sort = sort;
        this.buf = buf;
        this.off = off;
        this.len = len;
    }

    /**
     * Returns the Java type corresponding to the given type descriptor.
     * 
     * @param typeDescriptor a type descriptor.
     * @return the Java type corresponding to the given type descriptor.
     */
    public static Type getType(final String typeDescriptor) {
        return getType( typeDescriptor.toCharArray(),
                        0 );
    }

    /**
     * Returns the Java type corresponding to the given class.
     * 
     * @param c a class.
     * @return the Java type corresponding to the given class.
     */
    public static Type getType(final Class c) {
        if ( c.isPrimitive() ) {
            if ( c == Integer.TYPE ) {
                return Type.INT_TYPE;
            } else if ( c == Void.TYPE ) {
                return Type.VOID_TYPE;
            } else if ( c == Boolean.TYPE ) {
                return Type.BOOLEAN_TYPE;
            } else if ( c == Byte.TYPE ) {
                return Type.BYTE_TYPE;
            } else if ( c == Character.TYPE ) {
                return Type.CHAR_TYPE;
            } else if ( c == Short.TYPE ) {
                return Type.SHORT_TYPE;
            } else if ( c == Double.TYPE ) {
                return Type.DOUBLE_TYPE;
            } else if ( c == Float.TYPE ) {
                return Type.FLOAT_TYPE;
            } else /* if (c == Long.TYPE) */{
                return Type.LONG_TYPE;
            }
        } else {
            return getType( getDescriptor( c ) );
        }
    }

    /**
     * Returns the Java types corresponding to the argument types of the given
     * method descriptor.
     * 
     * @param methodDescriptor a method descriptor.
     * @return the Java types corresponding to the argument types of the given
     *         method descriptor.
     */
    public static Type[] getArgumentTypes(final String methodDescriptor) {
        final char[] buf = methodDescriptor.toCharArray();
        int off = 1;
        int size = 0;
        while ( true ) {
            final char car = buf[off++];
            if ( car == ')' ) {
                break;
            } else if ( car == 'L' ) {
                while ( buf[off++] != ';' ) {
                }
                ++size;
            } else if ( car != '[' ) {
                ++size;
            }
        }
        final Type[] args = new Type[size];
        off = 1;
        size = 0;
        while ( buf[off] != ')' ) {
            args[size] = getType( buf,
                                  off );
            off += args[size].len;
            size += 1;
        }
        return args;
    }

    /**
     * Returns the Java types corresponding to the argument types of the given
     * method.
     * 
     * @param method a method.
     * @return the Java types corresponding to the argument types of the given
     *         method.
     */
    public static Type[] getArgumentTypes(final Method method) {
        final Class[] classes = method.getParameterTypes();
        final Type[] types = new Type[classes.length];
        for ( int i = classes.length - 1; i >= 0; --i ) {
            types[i] = getType( classes[i] );
        }
        return types;
    }

    /**
     * Returns the Java type corresponding to the return type of the given
     * method descriptor.
     * 
     * @param methodDescriptor a method descriptor.
     * @return the Java type corresponding to the return type of the given
     *         method descriptor.
     */
    public static Type getReturnType(final String methodDescriptor) {
        final char[] buf = methodDescriptor.toCharArray();
        return getType( buf,
                        methodDescriptor.indexOf( ')' ) + 1 );
    }

    /**
     * Returns the Java type corresponding to the return type of the given
     * method.
     * 
     * @param method a method.
     * @return the Java type corresponding to the return type of the given
     *         method.
     */
    public static Type getReturnType(final Method method) {
        return getType( method.getReturnType() );
    }

    /**
     * Returns the Java type corresponding to the given type descriptor.
     * 
     * @param buf a buffer containing a type descriptor.
     * @param off the offset of this descriptor in the previous buffer.
     * @return the Java type corresponding to the given type descriptor.
     */
    private static Type getType(final char[] buf,
                                final int off) {
        int len;
        switch ( buf[off] ) {
            case 'V' :
                return Type.VOID_TYPE;
            case 'Z' :
                return Type.BOOLEAN_TYPE;
            case 'C' :
                return Type.CHAR_TYPE;
            case 'B' :
                return Type.BYTE_TYPE;
            case 'S' :
                return Type.SHORT_TYPE;
            case 'I' :
                return Type.INT_TYPE;
            case 'F' :
                return Type.FLOAT_TYPE;
            case 'J' :
                return Type.LONG_TYPE;
            case 'D' :
                return Type.DOUBLE_TYPE;
            case '[' :
                len = 1;
                while ( buf[off + len] == '[' ) {
                    ++len;
                }
                if ( buf[off + len] == 'L' ) {
                    ++len;
                    while ( buf[off + len] != ';' ) {
                        ++len;
                    }
                }
                return new Type( Type.ARRAY,
                                 buf,
                                 off,
                                 len + 1 );
                // case 'L':
            default :
                len = 1;
                while ( buf[off + len] != ';' ) {
                    ++len;
                }
                return new Type( Type.OBJECT,
                                 buf,
                                 off,
                                 len + 1 );
        }
    }

    // ------------------------------------------------------------------------
    // Accessors
    // ------------------------------------------------------------------------

    /**
     * Returns the sort of this Java type.
     * 
     * @return {@link #VOID VOID}, {@link #BOOLEAN BOOLEAN},
     *         {@link #CHAR CHAR}, {@link #BYTE BYTE}, {@link #SHORT SHORT},
     *         {@link #INT INT}, {@link #FLOAT FLOAT}, {@link #LONG LONG},
     *         {@link #DOUBLE DOUBLE}, {@link #ARRAY ARRAY} or
     *         {@link #OBJECT OBJECT}.
     */