package org.astrogrid.samp.web; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import org.astrogrid.samp.Message; import org.astrogrid.samp.Response; import org.astrogrid.samp.client.CallableClient; /** * Represents one of the possible callbacks which may be invoked on a * CallableClient. The {@link #invoke} static method arranges for a Callback * acquired from the hub to be dispatched to a CallableClient. * * @author Mark Taylor * @since 3 Feb 2011 */ abstract class ClientCallbackOperation { private final String fqName_; private final Class[] sampSig_; private static final Map OPERATION_MAP = createOperationMap(); /** * Constructor. * * @param unqualified callback method name * @param signature of callback; an array of SAMP-friendly classes, * one for each argument */ private ClientCallbackOperation( String methodName, Class[] sampSig ) { fqName_ = WebClientProfile.WEBSAMP_CLIENT_PREFIX + methodName; sampSig_ = sampSig; } /** * Makes a call to a callable client of the method represented by * this operation with a given list of parameters. * No checking is performed on the parameter list. * *
This method should be private really, but abstract private is
* not permitted.
*
* @param client target callable client
* @param paramList parameters for call, assumed to be valid
*/
abstract void dispatch( CallableClient client, List paramList )
throws Exception;
/**
* Dispatches a callback to a CallableClient.
*
* @param callback callback acquired from the hub
* @param client client which should execute callback
*/
public static void invoke( Callback callback, CallableClient client )
throws Exception {
callback.check();
String methodName = callback.getMethodName();
List paramList = callback.getParams();
ClientCallbackOperation op =
(ClientCallbackOperation) OPERATION_MAP.get( methodName );
if ( op == null ) {
throw new UnsupportedOperationException(
"Unknown callback operation " + methodName );
}
else {
boolean sigOk = op.sampSig_.length == paramList.size();
for ( int i = 0; sigOk && i < op.sampSig_.length; i++ ) {
sigOk = sigOk
&& op.sampSig_[ i ]
.isAssignableFrom( paramList.get( i ).getClass() );
}
if ( ! sigOk ) {
throw new IllegalArgumentException(
methodName + " callback signature mismatch" );
}
else {
op.dispatch( client, paramList );
}
}
}
/**
* Returns a map, keyed by unqualified operation name,
* of known callback operations.
*
* @param String->ClientCallbackOperation map
*/
private static Map createOperationMap() {
// First assemble an array of known callback operations.
// It would be possible to assemble this array using reflection
// on the CallableClient interface, but more trouble than it's
// worth for three methods.
ClientCallbackOperation[] operations = new ClientCallbackOperation[] {
new ClientCallbackOperation( "receiveNotification",
new Class[] { String.class,
Map.class } ) {
public void dispatch( CallableClient client, List params )
throws Exception {
client.receiveNotification(
(String) params.get( 0 ),
new Message( (Map) params.get( 1 ) ) );
}
},
new ClientCallbackOperation( "receiveCall",
new Class[] { String.class,
String.class,
Map.class } ) {
public void dispatch( CallableClient client, List params )
throws Exception {
client.receiveCall(
(String) params.get( 0 ),
(String) params.get( 1 ),
new Message( (Map) params.get( 2 ) ) );
}
},
new ClientCallbackOperation( "receiveResponse",
new Class[] { String.class,
String.class,
Map.class } ) {
public void dispatch( CallableClient client, List params )
throws Exception {
client.receiveResponse(
(String) params.get( 0 ),
(String) params.get( 1 ),
new Response( (Map) params.get( 2 ) ) );
}
},
};
// Turn it into a map keyed by operation name, and return.
Map opMap = new HashMap();
for ( int i = 0; i < operations.length; i++ ) {
ClientCallbackOperation op = operations[ i ];
opMap.put( op.fqName_, op );
}
return Collections.unmodifiableMap( opMap );
}
}