package org.astrogrid.samp.xmlrpc;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import org.astrogrid.samp.DataException;
/**
* Utility class to facilitate constructing a SampXmlRpcHandler which handles
* particular named methods.
* You supply at construction time an interface which defines the methods
* to be handled and an object which implements that interface.
* This object then uses reflection to invoke the correct methods on the
* implementation object as they are required from incoming XML-RPC
* execute requests. This insulates the implementation object
* from having to worry about any XML-RPC specifics.
*
* @author Mark Taylor
* @since 15 Jul 2008
*/
public abstract class ActorHandler implements SampXmlRpcHandler {
private final String prefix_;
private final Object actor_;
private final Map methodMap_;
private final Logger logger_ =
Logger.getLogger( ActorHandler.class.getName() );
/**
* Constructor.
*
* @param prefix string prepended to every method name in the
* actorType interface to form the XML-RPC
* methodName element
* @param actorType interface defining the XML-RPC methods
* @param actor object implementing actorType
*/
public ActorHandler( String prefix, Class actorType, Object actor ) {
prefix_ = prefix;
actor_ = actor;
methodMap_ = new HashMap();
// Construct a map keyed by method signature of the known methods.
Method[] methods = actorType.getDeclaredMethods();
for ( int im = 0; im < methods.length; im++ ) {
Method method = methods[ im ];
if ( Modifier.isPublic( method.getModifiers() ) ) {
String name = method.getName();
Class[] clazzes = method.getParameterTypes();
SampType[] types = new SampType[ clazzes.length ];
for ( int ic = 0; ic < clazzes.length; ic++ ) {
types[ ic ] = SampType.getClassType( clazzes[ ic ] );
}
Signature sig = new Signature( prefix_ + name, types );
methodMap_.put( sig, method );
}
}
}
public boolean canHandleCall( String fqName ) {
return fqName.startsWith( prefix_ );
}
public Object handleCall( String fqName, List params, Object reqInfo )
throws Exception {
if ( ! canHandleCall( fqName ) ) {
throw new IllegalArgumentException( "No I can't" );
}
// Work out the signature for this method and see if it is recognised.
String name = fqName.substring( prefix_.length() );
List typeList = new ArrayList();
for ( Iterator it = params.iterator(); it.hasNext(); ) {
typeList.add( SampType.getParamType( it.next() ) );
}
SampType[] types = (SampType[]) typeList.toArray( new SampType[ 0 ] );
Signature sig = new Signature( fqName, types );
Method method = (Method) methodMap_.get( sig );
// If the signature is recognised, invoke the relevant method
// on the implementation object.
if ( method != null ) {
Object result;
Throwable error;
try {
result = invokeMethod( method, actor_, params.toArray() );
}
catch ( InvocationTargetException e ) {
Throwable e2 = e.getCause();
if ( e2 instanceof Error ) {
throw (Error) e2;
}
else {
throw (Exception) e2;
}
}
catch ( Exception e ) {
throw e;
}
catch ( Error e ) {
throw e;
}
return result == null ? "" : result;
}
// If the signature is not recognised, but the method name is,
// try to make a helpful comment.
else {
for ( Iterator it = methodMap_.keySet().iterator();
it.hasNext(); ) {
Signature foundSig = (Signature) it.next();
if ( foundSig.name_.equals( fqName ) ) {
throw new IllegalArgumentException(
"Bad arguments: " + foundSig + " got "
+ sig.typeList_ );
}
}
throw new UnsupportedOperationException( "Unknown method "
+ fqName );
}
}
/**
* Returns the implementation object for this handler.
*
* @return implementation object
*/
public Object getActor() {
return actor_;
}
/**
* Invokes a method reflectively on an object.
* This method should be implemented in the obvious way, that is
* return method.invoke(obj,params).
*
*
If the implementation is effectively prescribed, why is this
* abstract method here? It's tricky.
* The reason is so that reflective method invocation from this class
* is done by code within the actor implementation class itself
* rather than by code in the superclass, ActorHandler.
* That in turn means that the actorType class specified
* in the constructor does not need to be visible from
* ActorHandler's package, only from the package where
* the implementation class lives.
*
* @param method method to invoke
* @param obj object to invoke the method on
* @param args arguments for the method call
* @see java.lang.reflect.Method#invoke
*/
protected abstract Object invokeMethod( Method method, Object obj,
Object[] args )
throws IllegalAccessException, InvocationTargetException;
/**
* Enumeration of permitted types within a SAMP data structure.
*/
private static class SampType {
/** String type. */
public static final SampType STRING =
new SampType( String.class, "string" );
/** List type. */
public static final SampType LIST =
new SampType( List.class, "list" );
/** Map type. */
public static final SampType MAP =
new SampType( Map.class, "map" );
private final Class clazz_;
private final String name_;
/**
* Constructor.
*
* @param clazz java class
* @param name name of SAMP type
*/
private SampType( Class clazz, String name ) {
clazz_ = clazz;
name_ = name;
}
/**
* Returns the java class corresponding to this type.
*
* @return class
*/
public Class getTypeClass() {
return clazz_;
}
/**
* Returns the SAMP name for this type.
*
* @return name
*/
public String toString() {
return name_;
}
/**
* Returns the SampType corresponding to a given java class.
*
* @param clazz class
* @return SAMP type
*/
public static SampType getClassType( Class clazz ) {
if ( String.class.equals( clazz ) ) {
return STRING;
}
else if ( List.class.equals( clazz ) ) {
return LIST;
}
else if ( Map.class.equals( clazz ) ) {
return MAP;
}
else {
throw new IllegalArgumentException( "Illegal type "
+ clazz.getName() );
}
}
/**
* Returns the SampType corresponding to a given object.
*
* @param param object
* return SAMP type
*/
public static SampType getParamType( Object param ) {
if ( param instanceof String ) {
return STRING;
}
else if ( param instanceof List ) {
return LIST;
}
else if ( param instanceof Map ) {
return MAP;
}
else {
throw new DataException( "Param is not a SAMP type" );
}
}
}
/**
* Characterises a method signature.
* The equals and hashCode methods are
* implemented sensibly.
*/
private static class Signature {
private final String name_;
private final List typeList_;
/**
* Constructor.
*
* @param name method name
* @param types types of method arguments
*/
Signature( String name, SampType[] types ) {
name_ = name;
typeList_ = new ArrayList( Arrays.asList( types ) );
}
public boolean equals( Object o ) {
if ( o instanceof Signature ) {
Signature other = (Signature) o;
return this.name_.equals( other.name_ )
&& this.typeList_.equals( other.typeList_ );
}
else {
return false;
}
}
public int hashCode() {
int code = 999;
code = 23 * code + name_.hashCode();
code = 23 * code + typeList_.hashCode();
return code;
}
public String toString() {
return name_ + typeList_;
}
}
}