/**
* Copyright (C) 2012 FuseSource, Inc.
* http://fusesource.com
*
* Licensed 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.fusesource.hawtdispatch.internal.util;
import java.beans.PropertyEditor;
import java.beans.PropertyEditorManager;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
public final class IntrospectionSupport {
static {
// Add Spring and ActiveMQ specific property editors
String[] additionalPath = new String[] {
"org.springframework.beans.propertyeditors",
"org.apache.activemq.util" };
String[] searchPath = (String[]) Array.newInstance(String.class,
PropertyEditorManager.getEditorSearchPath().length
+ additionalPath.length);
System.arraycopy(PropertyEditorManager.getEditorSearchPath(), 0,
searchPath, 0,
PropertyEditorManager.getEditorSearchPath().length);
System.arraycopy(additionalPath, 0, searchPath, PropertyEditorManager
.getEditorSearchPath().length, additionalPath.length);
PropertyEditorManager.setEditorSearchPath(searchPath);
}
private IntrospectionSupport() {
}
public static boolean getProperties(Object target, Map props, String optionPrefix) {
boolean rc = false;
if (target == null) {
throw new IllegalArgumentException("target was null.");
}
if (props == null) {
throw new IllegalArgumentException("props was null.");
}
if (optionPrefix == null) {
optionPrefix = "";
}
Class<?> clazz = target.getClass();
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
String name = method.getName();
Class<?> type = method.getReturnType();
Class<?> params[] = method.getParameterTypes();
if ((name.startsWith("is") || name.startsWith("get")) && params.length == 0 && type != null && isSettableType(type)) {
try {
Object value = method.invoke(target, new Object[] {});
if (value == null) {
continue;
}
String strValue = convertToString(value, type);
if (strValue == null) {
continue;
}
if (name.startsWith("get")) {
name = name.substring(3, 4).toLowerCase()
+ name.substring(4);
} else {
name = name.substring(2, 3).toLowerCase()
+ name.substring(3);
}
props.put(optionPrefix + name, strValue);
rc = true;
} catch (Throwable ignore) {
}
}
}
return rc;
}
public static boolean setProperties(Object target, Map<String, ?> props, String optionPrefix) {
boolean rc = false;
if (target == null) {
throw new IllegalArgumentException("target was null.");
}
if (props == null) {
throw new IllegalArgumentException("props was null.");
}
for (Iterator<String> iter = props.keySet().iterator(); iter.hasNext();) {
String name = iter.next();
if (name.startsWith(optionPrefix)) {
Object value = props.get(name);
name = name.substring(optionPrefix.length());
if (setProperty(target, name, value)) {
iter.remove();
rc = true;
}
}
}
return rc;
}
public static Map<String, Object> extractProperties(Map props, String optionPrefix) {
if (props == null) {
throw new IllegalArgumentException("props was null.");
}
HashMap<String, Object> rc = new HashMap<String, Object>(props.size());
for (Iterator iter = props.keySet().iterator(); iter.hasNext();) {
String name = (String)iter.next();
if (name.startsWith(optionPrefix)) {
Object value = props.get(name);
name = name.substring(optionPrefix.length());
rc.put(name, value);
iter.remove();
}
}
return rc;
}
public static boolean setProperties(Object target, Map props) {
boolean rc = false;
if (target == null) {
throw new IllegalArgumentException("target was null.");
}
if (props == null) {
throw new IllegalArgumentException("props was null.");
}
for (Iterator iter = props.entrySet().iterator(); iter.hasNext();) {
Map.Entry entry = (Entry)iter.next();
if (setProperty(target, (String)entry.getKey(), entry.getValue())) {
iter.remove();
rc = true;
}
}
return rc;
}
public static Class<?> getPropertyType(Object target, String name) {
Class<?> clazz = target.getClass();
Method setter = findSetterMethod(clazz, name);
if (setter == null) {
return null;
}
return setter.getParameterTypes()[0];
}
public static boolean setProperty(Object target, String name, Object value) {
try {
Class<?> clazz = target.getClass();
Method setter = findSetterMethod(clazz, name);
if (setter == null) {
return false;
}
// If the type is null or it matches the needed type, just use the
// value directly
if (value == null || value.getClass() == setter.getParameterTypes()[0]) {
setter.invoke(target, new Object[] {value});
} else {
// We need to convert it
setter.invoke(target, new Object[] {convert(value, setter.getParameterTypes()[0])});
}
return true;
} catch (Throwable ignore) {
return false;
}
}
private static Object convert(Object value, Class<?> type) {
if( type.isArray() ) {
if( value.getClass().isArray() ) {
int length = Array.getLength(value);
Class<?> componentType = type.getComponentType();
Object rc = Array.newInstance(componentType, length);
for (int i = 0; i < length; i++) {
Object o = Array.get(value, i);
Array.set(rc, i, convert(o, componentType));
}
return rc;
}
}
PropertyEditor editor = PropertyEditorManager.findEditor(type);
if (editor != null) {
editor.setAsText(value.toString());
return editor.getValue();
}
return null;
}
public static String convertToString(Object value, Class<?> type) {
PropertyEditor editor = PropertyEditorManager.findEditor(type);
if (editor != null) {
editor.setValue(value);
return editor.getAsText();
}
return null;
}
private static Method findSetterMethod(Class<?> clazz, String name) {
// Build the method name.
name = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
Class<?> params[] = method.getParameterTypes();
if (method.getName().equals(name) && params.length == 1 ) {
return method;
}
}
return null;
}
private static boolean isSettableType(Class<?> clazz) {
if (PropertyEditorManager.findEditor(clazz) != null) {
return true;
}
return false;
}
public static String toString(Object target) {
return toString(target, Object.class, null, null);
}
public static String toString(Object target, String...fields) {
return toString(target, Object.class, null, fields);
}
public static String toString(Object target, Class<?> stopClass) {
return toString(target, stopClass, null, null);
}
public static String toString(Object target, Map<String, Object> overrideFields, String...fields) {
return toString(target, Object.class, overrideFields, fields);
}
public static String toString(Object target, Class<?> stopClass, Map<String, Object> overrideFields, String fields[]) {
try {
LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
addFields(target, target.getClass(), stopClass, map);
if (overrideFields != null) {
for(String key : overrideFields.keySet()) {
Object value = overrideFields.get(key);
map.put(key, value);
}
}
if( fields!=null ) {
map.keySet().retainAll(Arrays.asList(fields));
}
boolean useMultiLine=false;
LinkedHashMap<String, String> props = new LinkedHashMap<String, String>();
for (Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
String value = null;
if( entry.getValue() !=null ) {
value = entry.getValue().toString();
if( value!=null && ( value.indexOf('\n')>=0 || (key.length()+value.length())>70 ) ) {
useMultiLine=true;
}
}
props.put(key, value);
}
StringBuffer buffer = new StringBuffer();
if( useMultiLine) {
buffer.append("{\n");
boolean first = true;
for (Entry<String, String> entry : props.entrySet()) {
if (first) {
first = false;
} else {
buffer.append(",\n");
}
buffer.append(" ");
buffer.append(entry.getKey());
buffer.append(": ");
buffer.append(StringSupport.indent(entry.getValue(), 2));
}
buffer.append("\n}");
} else {
buffer.append("{");
boolean first = true;
for (Entry<String, String> entry : props.entrySet()) {
if (first) {
first = false;
} else {
buffer.append(", ");
}
buffer.append(entry.getKey());
buffer.append(": ");
String value = entry.getValue();
buffer.append(value);
}
buffer.append("}");
}
return buffer.toString();
} catch (Throwable e) {
Thread thread = Thread.currentThread();
thread.getUncaughtExceptionHandler().uncaughtException(thread, e);
return "Could not toString: "+e.toString();
}
}
public static String simpleName(Class<?> clazz) {
String name = clazz.getName();
int p = name.lastIndexOf(".");
if (p >= 0) {
name = name.substring(p + 1);
}
return name;
}
private static void addFields(Object target, Class<?> startClass, Class<?> stopClass, LinkedHashMap<String, Object> map) {
if (startClass != stopClass) {
addFields(target, startClass.getSuperclass(), stopClass, map);
}
Field[] fields = startClass.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (Modifier.isStatic(field.getModifiers())) {
continue;
}
try {
field.setAccessible(true);
Object o = field.get(target);
if (o != null && o.getClass().isArray()) {
try {
o = Arrays.asList((Object[])o);
} catch (Throwable e) {
}
}
map.put(field.getName(), o);
} catch (Throwable e) {
Thread thread = Thread.currentThread();
thread.getUncaughtExceptionHandler().uncaughtException(thread, e);
}
}
}
}