com.sun.codemodel.JMethod Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of codemodel Show documentation
The core functionality of the CodeModel Java source code generation library
The newest version!
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.codemodel;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.Collections;
import java.util.Collection;

import com.sun.codemodel.util.ClassNameComparator;

/**
 * Java method.
 */
public class JMethod extends JGenerifiableImpl implements JDeclaration, JAnnotatable, JDocCommentable {

	/**
	 * Modifiers for this method
	 */
	private JMods mods;

	/**
	 * Return type for this method
	 */
	private JType type = null;

	/**
	 * Name of this method
	 */
	private String name = null;

	/**
	 * List of parameters for this method's declaration
	 */
	private final List params = new ArrayList();

	/**
	 * Set of exceptions that this method may throw.
     * A set instance lazily created.
	 */
	private Set _throws;

	/**
	 * JBlock of statements that makes up the body this method
	 */
	private JBlock body = null;

	private JDefinedClass outer;

	/**
	 * javadoc comments for this JMethod
	 */
	private JDocComment jdoc = null;

	/**
	 * Variable parameter for this method's varargs declaration
	 * introduced in J2SE 1.5
	 */
	private JVar varParam = null;

    /**
     * Annotations on this variable. Lazily created.
     */
    private List annotations = null;


	private boolean isConstructor() {
		return type == null;
	}
    
    /** To set the default value for the
     *  annotation member
     */
    private JExpression defaultValue = null;
    

	/**
	 * JMethod constructor
	 *
	 * @param mods
	 *        Modifiers for this method's declaration
	 *
	 * @param type
	 *        Return type for the method
	 *
	 * @param name
	 *        Name of this method
	 */
	JMethod(JDefinedClass outer, int mods, JType type, String name) {
		this.mods = JMods.forMethod(mods);
		this.type = type;
		this.name = name;
		this.outer = outer;
	}

	/**
	 * Constructor constructor
	 *
	 * @param mods
	 *        Modifiers for this constructor's declaration
	 *
	 * @param _class
	 *        JClass containing this constructor
	 */
	JMethod(int mods, JDefinedClass _class) {
		this.mods = JMods.forMethod(mods);
		this.type = null;
		this.name = _class.name();
		this.outer = _class;
	}
    
    private Set getThrows() {
        if(_throws==null)
            _throws = new TreeSet(ClassNameComparator.theInstance);
        return _throws;
    }

	/**
	 * Add an exception to the list of exceptions that this
	 * method may throw.
	 *
	 * @param exception
	 *        Name of an exception that this method may throw
	 */
	public JMethod _throws(JClass exception) {
        getThrows().add(exception);
		return this;
	}

	public JMethod _throws(Class exception) {
		return _throws(outer.owner().ref(exception));
	}

	/**
	 * Returns the list of variable of this method.
	 *
	 * @return List of parameters of this method. This list is not modifiable.
	 */
	public List params() {
		return Collections.unmodifiableList(params);
	}
	
	/**
	 * Add the specified variable to the list of parameters
	 * for this method signature.
	 *
	 * @param type
	 *        JType of the parameter being added
	 *
	 * @param name
	 *        Name of the parameter being added
	 *
	 * @return New parameter variable
	 */
	public JVar param(int mods, JType type, String name) {
		JVar v = new JVar(JMods.forVar(mods), type, name, null);
		params.add(v);
		return v;
	}

	public JVar param(JType type, String name) {
		return param(JMod.NONE, type, name);
	}

	public JVar param(int mods, Class type, String name) {
		return param(mods, outer.owner()._ref(type), name);
	}

	public JVar param(Class type, String name) {
		return param(outer.owner()._ref(type), name);
	}

	/**
	 * @see #varParam(JType, String)
	 */
	public JVar varParam(Class type, String name) {
        return varParam(outer.owner()._ref(type),name);
    }

    /**
     * Add the specified variable argument to the list of parameters
     * for this method signature.
     *
     * @param type
     *      Type of the parameter being added.
     *
     * @param name
     *        Name of the parameter being added
     *
     * @return the variable parameter
     * 
     * @throws IllegalStateException
     *      If this method is called twice.
     *      varargs in J2SE 1.5 can appear only once in the 
     *      method signature.
     */
    public JVar varParam(JType type, String name) {
		return varParam(JMod.NONE, type, name);
	}

	/**
     * Add the specified variable argument to the list of parameters
     * for this method signature.
     *
	 * @param mods
	 * 		The modifiers for the variable.
	 *
     * @param type
     *      Type of the parameter being added.
     *
     * @param name
     *      Name of the parameter being added
     *
     * @return the variable parameter
     *
     * @throws IllegalStateException
     *      If this method is called twice.
     *      varargs in J2SE 1.5 can appear only once in the
     *      method signature.
     */
	public JVar varParam(int mods, JType type, String name) {
		if (!hasVarArgs()) {
            varParam = new JVar(JMods.forVar(mods), type.array(), name, null);
			return varParam;
		} else {
			throw new IllegalStateException(
				"Cannot have two varargs in a method,\n"
					+ "Check if varParam method of JMethod is"
					+ " invoked more than once");

		}

	}

    /**
     * Adds an annotation to this variable.
     * @param clazz
     *          The annotation class to annotate the field with
     */
    public JAnnotationUse annotate(JClass clazz){
        if(annotations==null)
           annotations = new ArrayList();
        JAnnotationUse a = new JAnnotationUse(clazz);
        annotations.add(a);
        return a;
    }

    /**
     * Adds an annotation to this variable.
     *
     * @param clazz
     *          The annotation class to annotate the field with
     */
    public JAnnotationUse annotate(Class  clazz){
        return annotate(owner().ref(clazz));
    }

    public  W annotate2(Class clazz) {
        return TypedAnnotationWriter.create(clazz,this);
    }

    public Collection annotations() {
        if (annotations == null)
            annotations = new ArrayList();
        return Collections.unmodifiableList(annotations);
    }

    /**
	 * Check if there are any varargs declared
	 * for this method signature.
	 */
	public boolean hasVarArgs() {
		return this.varParam!=null;
	}

	public String name() {
		return name;
	}

    /**
     * Changes the name of the method.
     */
    public void name(String n) {
        this.name = n;
    }

    /**
	 * Returns the return type.
	 */
	public JType type() {
		return type;
	}

    /**
     * Overrides the return type.
     */
    public void type(JType t) {
        this.type = t;
    }

    /**
	 * Returns all the parameter types in an array.
	 * @return
	 *      If there's no parameter, an empty array will be returned.
	 */
	public JType[] listParamTypes() {
		JType[] r = new JType[params.size()];
		for (int i = 0; i < r.length; i++)
			r[i] = params.get(i).type();
		return r;
	}

	/**
	 * Returns  the varags parameter type.
	 * @return
	 * If there's no vararg parameter type, null will be returned.
	 */
	public JType listVarParamType() {
		if (varParam != null)
			return varParam.type();
		else
			return null;
	}

	/**
	 * Returns all the parameters in an array.
	 * @return
	 *      If there's no parameter, an empty array will be returned.
	 */
	public JVar[] listParams() {
		return params.toArray(new JVar[params.size()]);
	}

	/**
	 * Returns the variable parameter
	 * @return
	 *      If there's no parameter, null will be returned.
	 */
	public JVar listVarParam() {
		return varParam;
	}

	/**
	 * Returns true if the method has the specified signature.
	 */
	public boolean hasSignature(JType[] argTypes) {
		JVar[] p = listParams();
		if (p.length != argTypes.length)
			return false;

		for (int i = 0; i < p.length; i++)
			if (!p[i].type().equals(argTypes[i]))
				return false;

		return true;
	}

	/**
	 * Get the block that makes up body of this method
	 *
	 * @return Body of method
	 */
	public JBlock body() {
		if (body == null)
			body = new JBlock();
		return body;
	}
    
    /**
     * Specify the default value for this annotation member
     * @param value 
     *           Default value for the annotation member
     * 
     */
    public void declareDefaultValue(JExpression value){
        this.defaultValue = value;
    }

	/**
	 * Creates, if necessary, and returns the class javadoc for this
	 * JDefinedClass
	 *
	 * @return JDocComment containing javadocs for this class
	 */
	public JDocComment javadoc() {
		if (jdoc == null)
			jdoc = new JDocComment(owner());
		return jdoc;
	}

	public void declare(JFormatter f) {
		if (jdoc != null)
			f.g(jdoc);

        if (annotations != null){
            for (JAnnotationUse a : annotations)
                f.g(a).nl();
        }

        f.g(mods);
        
        // declare the generics parameters
		super.declare(f);

		if (!isConstructor()) {
			f.g(type);
		}
		f.id(name).p('(').i();

        // when parameters are printed in new lines, we want them to be indented.
        // there's a good chance no newlines happen, too, but just in case it does.
		boolean first = true;
        for (JVar var : params) {
            if (!first) {
                f.p(',');
			}
            if(var.isAnnotated()) {
                f.nl();
			}
            f.b(var);
            first = false;
        }
		if (hasVarArgs()) {
			if (!first) {
				f.p(',');
			}

			f.g(varParam.mods());
			f.g(varParam.type().elementType());
			f.p("... ");
			f.id(varParam.name());
		}

		f.o().p(')');
		if (_throws!=null && !_throws.isEmpty()) {
			f.nl().i().p("throws").g(_throws).nl().o();
		}
        
        if (defaultValue != null) {
            f.p("default ");
            f.g(defaultValue);
        }
		if (body != null) {
			f.s(body);
		} else if (
			!outer.isInterface() && !outer.isAnnotationTypeDeclaration() && !mods.isAbstract() && !mods.isNative()) {
			// Print an empty body for non-native, non-abstract methods
			f.s(new JBlock());
		} else {
			f.p(';').nl();
		}
	}

    /**
     * @return
     *      the current modifiers of this method.
     *      Always return non-null valid object.
     */
    public JMods mods() {
        return mods;
    }

    /**
     * @deprecated use {@link #mods()} 
     */
    public JMods getMods() {
		return mods;
	}

	protected JCodeModel owner() {
		return outer.owner();
	}
}