001 /*
002 * Created on Feb 20, 2008
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 *
014 * Copyright @2008-2009 the original author or authors.
015 */
016 package org.fest.reflect.method;
017
018 import static org.fest.reflect.method.Invoker.newInvoker;
019 import static org.fest.reflect.method.StaticMethodParameterTypes.newParameterTypes;
020 import static org.fest.reflect.method.StaticMethodReturnType.newReturnType;
021 import static org.fest.reflect.method.StaticMethodReturnTypeRef.newReturnTypeRef;
022 import static org.fest.util.Strings.isEmpty;
023
024 import org.fest.reflect.reference.TypeRef;
025
026 /**
027 * Understands the name of a static method to invoke using Java Reflection.
028 * <p>
029 * The following is an example of proper usage of this class:
030 * <pre>
031 * // Equivalent to call 'Jedi.setCommonPower("Jump")'
032 * {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("setCommonPower").{@link StaticMethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
033 * .{@link StaticMethodParameterTypes#in(Class) in}(Jedi.class)
034 * .{@link Invoker#invoke(Object...) invoke}("Jump");
035 *
036 * // Equivalent to call 'Jedi.addPadawan()'
037 * {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("addPadawan").{@link StaticMethodName#in(Class) in}(Jedi.class).{@link Invoker#invoke(Object...) invoke}();
038 *
039 * // Equivalent to call 'Jedi.commonPowerCount()'
040 * String name = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("commonPowerCount").{@link StaticMethodName#withReturnType(Class) withReturnType}(String.class)
041 * .{@link StaticMethodReturnType#in(Class) in}(Jedi.class)
042 * .{@link Invoker#invoke(Object...) invoke}();
043 *
044 * // Equivalent to call 'Jedi.getCommonPowers()'
045 * List<String> powers = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("getCommonPowers").{@link StaticMethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
046 * .{@link StaticMethodReturnTypeRef#in(Class) in}(Jedi.class)
047 * .{@link Invoker#invoke(Object...) invoke}();
048 * </pre>
049 * </p>
050 *
051 * @author Alex Ruiz
052 */
053 public final class StaticMethodName {
054
055 /**
056 * Creates a new </code>{@link StaticMethodName}</code>: the starting point of the fluent interface for accessing
057 * static methods using Java Reflection.
058 * @param name the name of the method to access using Java Reflection.
059 * @return the created <code>StaticMethodName</code>.
060 * @throws NullPointerException if the given name is <code>null</code>.
061 * @throws IllegalArgumentException if the given name is empty.
062 */
063 public static StaticMethodName startStaticMethodAccess(String name) {
064 validateIsNotNullOrEmpty(name);
065 return new StaticMethodName(name);
066 }
067
068 private static void validateIsNotNullOrEmpty(String name) {
069 if (name == null)
070 throw new NullPointerException("The name of the static method to access should not be null");
071 if (isEmpty(name))
072 throw new IllegalArgumentException("The name of the static method to access should not be empty");
073 }
074
075 private final String name;
076
077 private StaticMethodName(String name) {
078 this.name = name;
079 }
080
081 /**
082 * Specifies the return type of the static method to invoke. This method call is optional if the return type of the
083 * method to invoke is <code>void</code>.
084 * @param <T> the generic type of the method's return type.
085 * @param type the return type of the method to invoke.
086 * @return the created return type holder.
087 * @throws NullPointerException if the given type is <code>null</code>.
088 */
089 public <T> StaticMethodReturnType<T> withReturnType(Class<T> type) {
090 return newReturnType(name, type);
091 }
092
093 /**
094 * Specifies the return type reference of the static method to invoke. This method call is optional if the return type
095 * of the method to invoke is <code>void</code>.
096 * @param <T> the generic type of the method's return type.
097 * @param type the return type reference of the method to invoke.
098 * @return the created return type holder.
099 * @throws NullPointerException if the given type reference is <code>null</code>.
100 */
101 public <T> StaticMethodReturnTypeRef<T> withReturnType(TypeRef<T> type) {
102 return newReturnTypeRef(name, type);
103 }
104
105 /**
106 * Specifies the parameter types of the static method to invoke. This method call is optional if the method to invoke
107 * does not take arguments.
108 * @param parameterTypes the parameter types of the method to invoke.
109 * @return the created parameter types holder.
110 * @throws NullPointerException if the array of parameter types is <code>null</code>.
111 */
112 public StaticMethodParameterTypes<Void> withParameterTypes(Class<?>... parameterTypes) {
113 return newParameterTypes(name, parameterTypes);
114 }
115
116 /**
117 * Creates a new invoker for a static method that takes no parameters and return value <code>void</code>.
118 * @param target the object containing the method to invoke.
119 * @return the created method invoker.
120 * @throws NullPointerException if the given target is <code>null</code>.
121 */
122 public Invoker<Void> in(Class<?> target) {
123 return newInvoker(name, target);
124 }
125 }