2 * Copyright 2008 the original author or authors.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.wamblee.system.adapters;
18 import java.awt.CompositeContext;
19 import java.lang.reflect.InvocationTargetException;
20 import java.lang.reflect.Method;
21 import java.lang.reflect.Modifier;
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.HashMap;
25 import java.util.List;
29 import org.wamblee.collections.CollectionFilter;
30 import org.wamblee.conditions.Condition;
31 import org.wamblee.conditions.FixedCondition;
32 import org.wamblee.general.Pair;
33 import org.wamblee.reflection.ReflectionUtils;
34 import org.wamblee.system.core.DefaultProvidedInterface;
35 import org.wamblee.system.core.DefaultRequiredInterface;
36 import org.wamblee.system.core.ProvidedInterface;
37 import org.wamblee.system.core.RequiredInterface;
38 import org.wamblee.system.core.Scope;
39 import org.wamblee.system.core.SystemAssemblyException;
42 * Represents the configuration for exposing the setters of a class as required
45 * @author Erik Brakkee
47 public class SetterConfiguration {
50 private boolean _publicOnly;
52 private Map<Method, ParameterValues> _setters;
55 * Constructs the setter configuration. By default no setters are added.
58 * Class which is being configured.
60 public SetterConfiguration(Class aClass) {
63 _setters = new HashMap<Method, ParameterValues>();
67 * Makes sure that all available setters are used.
69 public SetterConfiguration initAllSetters() {
71 for (Method method: getAllSetters(_class, _publicOnly) ) {
72 _setters.put(method, createParameterValues(method));
78 * Called to set whether non-public setters are also used. By default only
79 * public setters are used. The currently selected setters remain chosen.
84 public SetterConfiguration setNonPublic(boolean aIsNonPublic) {
85 _publicOnly = !aIsNonPublic;
90 * Removes all setters.
92 * @return Reference to the current object to allow call chaining.
94 public SetterConfiguration clear() {
100 * Removes a setter from the set of methods.
103 * Name of the setter to remove.
104 * @return Reference to the current object to allow call chaining.
106 public SetterConfiguration remove(String aName) {
107 for (Method method : _setters.keySet()) {
108 if (method.getName().equals(aName)) {
109 _setters.remove(method);
113 throw new IllegalArgumentException(
114 "No method configured by the name of '" + aName + "'");
118 * Removes the method from the set of methods.
119 * @param aMethod Method to remove.
122 public SetterConfiguration remove(Method aMethod) {
123 if ( !aMethod.getDeclaringClass().isAssignableFrom(_class) ) {
124 throw new RuntimeException("Method " + aMethod + " not found in class " + _class + " or its superclasses");
126 for (Method method : _setters.keySet()) {
127 if (method.equals(aMethod)) {
128 _setters.remove(method);
132 throw new IllegalArgumentException(
133 "Method '" + aMethod + "' was not configured. ");
139 * Creates the name of a setter based on the name of the setter without the
144 * @return Setter name.
146 private String createxSetterName(String aName) {
147 return "set" + aName.substring(0, 1).toUpperCase() + aName.substring(1);
151 * Adds a given setter name to the setters.
153 * @param aName Name of a setter method.
154 * @return Reference to the current object to allow call chaining.
156 public SetterConfiguration add(final String aName) {
157 int oldlen = _setters.size();
158 List<Method> methods = new ArrayList<Method>();
159 CollectionFilter.filter(getAllSetters(_class, _publicOnly), methods,
160 new Condition<Method>() {
162 public boolean matches(Method aObject) {
163 return aObject.getName().equals(aName);
167 if (methods.size() == 0 ) {
168 throw new IllegalArgumentException("Method '" + aName
169 + "' not found in " + _class.getName());
171 // TODO is it possible to get more than one setter here in case the subclass overrides
172 // the baseclass method?
173 _setters.put(methods.get(0), createParameterValues(methods.get(0)));
178 * Adds a given setter identified by the type it accepts to the list of
182 * Type to look for. Note that this must be the exact type as
183 * autoboxing and autounboxing is not used.
184 * @return Reference to the current object to allow call chaining.
185 * @throws IllegalArgumentException
186 * In case no setter is found or multiple setters are found.
188 public SetterConfiguration add(final Class aType) {
189 List<Method> result = new ArrayList<Method>();
190 CollectionFilter.filter(getAllSetters(_class, _publicOnly), result,
191 new Condition<Method>() {
193 public boolean matches(Method aObject) {
194 Class type = aObject.getParameterTypes()[0];
195 return type.equals(aType);
199 if (result.size() == 0) {
200 throw new IllegalArgumentException("No setter found in class '"
202 + "' that has a setter with argument type '"
203 + aType.getName() + "'");
205 if (result.size() > 1) {
207 for (Method method : result) {
208 setters += method.getName() + " ";
210 throw new IllegalArgumentException(
211 "Multiple setters found in class '" + _class.getName()
212 + " that accept type '" + aType.getName() + "': "
215 Method method = result.get(0);
216 _setters.put(method, createParameterValues(method));
221 * Gets all setters for the current class.
223 * @return List of all setters.
225 public static List<Method> getAllSetters(Class aClass,
226 boolean aPublicOnly) {
227 List<Method> result = new ArrayList<Method>();
228 for (Method method : getAllMethods(aClass)) {
229 if (!aPublicOnly || Modifier.isPublic(method.getModifiers())) {
230 if (method.getName().startsWith("set")
231 && method.getParameterTypes().length == 1) {
232 method.setAccessible(true);
240 private static ParameterValues createParameterValues(Method method) {
241 // TODO generalize to multiple parameters.
242 return new ParameterValues(
243 new String[] { method.getName() }, new Class[] { method
244 .getParameterTypes()[0] });
247 private static final List<Method> getAllMethods(Class aClass) {
248 return ReflectionUtils.getAllMethods(aClass);
252 * Gets the required interfaces based on the configured setteres.
254 * @return List of required interfaces.
256 public List<RequiredInterface> getRequiredInterfaces() {
257 List<RequiredInterface> result = new ArrayList<RequiredInterface>();
258 for (Method method : _setters.keySet()) {
259 result.addAll(_setters.get(method).getRequiredInterfaces());
265 * Invokes all configured setters with the appropriate values.
268 * Scope within which invocation takes place.
270 * Object on which the invocation takes place.
272 public void inject(Scope aScope, Object aObject) {
273 if (!_class.isInstance(aObject)) {
274 throw new IllegalArgumentException("Object '" + aObject
275 + "' is not an instance of " + _class.getName());
277 for (Method method : _setters.keySet()) {
278 ParameterValues values = _setters.get(method);
281 method.invoke(aObject, values.values(aScope));
282 } catch (IllegalAccessException e) {
283 throw new SystemAssemblyException("Problem invoking " + method
284 + " with " + values, e);
285 } catch (InvocationTargetException e) {
286 throw new SystemAssemblyException("Problem invoking " + method
287 + " with " + values, e);
293 * Returns the parameter values for allowing detailed configuration of how
294 * parameter values are set.
297 * Setter name without the "set" prefix with the first character
298 * converted to lower case.
299 * @return Parameter values.
301 public ParameterValues values(String aMethod) {
302 for (Method method : _setters.keySet()) {
303 if (method.getName().equals(aMethod)) {
304 return _setters.get(method);
307 throw new IllegalArgumentException("No setter method '" + aMethod
312 * Gets the setter name for a given setter method. This is the name of the
313 * setter without the "set" prefix and with the first character converted to
318 * @return Setter name.
320 private static String getxSetterName(Method aMethod) {
321 String result = aMethod.getName().substring(3);
322 return result.substring(0, 1).toLowerCase() + result.substring(1);
325 public List<Method> getSetters() {
326 return new ArrayList<Method>(_setters.keySet());