private void AddMethod(Control parent, IRpcMethodDescriptor method)
{
JsonRpcObsoleteAttribute obsoleteAttribute = JsonRpcObsoleteAttribute.Get(method.AttributeProvider);
Control methodSpan = AddSpan(parent,
obsoleteAttribute == null ? "method" : "method obsolete-method", null);
HyperLink link = new HyperLink();
link.CssClass = "method-name";
link.Text = Server.HtmlEncode(method.Name);
methodSpan.Controls.Add(link);
AddSignature(methodSpan, method);
string summary = JsonRpcHelpAttribute.GetText(method.AttributeProvider);
if (summary.Length > 0)
{
AddSpan(parent, "method-summary-sep", " - ");
AddSpan(parent, "method-summary", summary);
}
if (obsoleteAttribute != null)
{
AddSpan(parent, "obsolete-message", " This method has been obsoleted. " + obsoleteAttribute.Message);
}
}
/// <summary>
/// Takes an array of arguments that are designated for a method and
/// transposes them if the target method supports variable arguments (in
/// other words, the last parameter is annotated with the JsonRpcParams
/// attribute). If the method does not support variable arguments then
/// the input array is returned verbatim.
/// </summary>
// TODO: Allow args to be null to represent empty arguments.
// TODO: Allow parameter conversions
public static object[] TransposeVariableArguments(IRpcMethodDescriptor method, object[] args)
{
if (method == null)
throw new ArgumentNullException("method");
//
// If the method does not have take variable arguments then just
// return the arguments array verbatim.
//
if (!HasMethodVariableArguments(method))
return args;
int parameterCount = method.GetParameters().Length;
object[] varArgs = null;
if (args.Length >= parameterCount)
{
object lastArg = args[args.Length - 1];
if (lastArg != null)
{
varArgs = lastArg as object[];
if (varArgs == null)
{
ICollection collection = lastArg as ICollection;
if (collection != null)
{
varArgs = new object[collection.Count];
collection.CopyTo(varArgs, 0);
}
}
}
}
//
// Copy out the extra arguments into a new array that represents
// the variable parts.
//
if (varArgs == null)
{
varArgs = new object[(args.Length - parameterCount) + 1];
Array.Copy(args, parameterCount - 1, varArgs, 0, varArgs.Length);
}
//
// Setup a new array of arguments that has a copy of the fixed
// arguments followed by the variable arguments array setup above.
//
object[] transposedArgs = new object[parameterCount];
Array.Copy(args, transposedArgs, parameterCount - 1);
transposedArgs[transposedArgs.Length - 1] = varArgs;
return transposedArgs;
}
public RpcParameterDescriptor(IRpcMethodDescriptor method, ParameterInfo parameter)
{
if (method == null)
throw new ArgumentNullException("method");
if (parameter == null)
throw new ArgumentNullException("parameter");
_method = method;
_parameter = parameter;
// TODO: Parameter validation, e.g. cannot be by-reference.
}
private void AddMethod(Control parent, IRpcMethodDescriptor method)
{
JsonRpcObsoleteAttribute obsoleteAttribute = JsonRpcObsoleteAttribute.Get(method.AttributeProvider);
Control methodTerm = AddGeneric(parent, "dt", obsoleteAttribute == null ? "method" : "method obsolete-method");
AddSpan(methodTerm, "method-name", method.Name);
AddSignature(methodTerm, method);
string summary = JsonRpcHelpAttribute.GetText(method.AttributeProvider);
if (summary.Length > 0 || obsoleteAttribute != null)
{
AddGeneric(parent, "dd", "method-summary", summary);
if (obsoleteAttribute != null)
AddSpan(parent, "obsolete-message", " This method has been obsoleted. " + obsoleteAttribute.Message);
}
}
private static void AddSignature(Control parent, IRpcMethodDescriptor method)
{
Control methodSignatureSpan = AddSpan(parent, "method-sig", null);
AddSpan(methodSignatureSpan, "method-param-open", "(");
IRpcParameterDescriptor[] parameters = method.GetParameters();
foreach (IRpcParameterDescriptor parameter in parameters)
{
if (parameter.Position > 0)
AddSpan(methodSignatureSpan, "method-param-delim", ", ");
AddSpan(methodSignatureSpan, "method-param", parameter.Name);
}
AddSpan(methodSignatureSpan, "method-param-close", ")");
}
/// <summary>
/// Determines if the method accepts variable number of arguments or
/// not. A method is designated as accepting variable arguments by
/// annotating the last parameter of the method with the JsonRpcParams
/// attribute.
/// </summary>
public static bool HasMethodVariableArguments(IRpcMethodDescriptor method)
{
if (method == null)
throw new ArgumentNullException("method");
IRpcParameterDescriptor[] parameters = method.GetParameters();
int parameterCount = parameters.Length;
if (parameterCount == 0)
return false;
IRpcParameterDescriptor lastParameter = parameters[parameterCount - 1];
return JsonRpcParamsAttribute.IsDefined(lastParameter.AttributeProvider);
}
public static object[] MapArguments(IRpcMethodDescriptor method, object argsObject)
{
object[] args;
IDictionary argsMap = argsObject as IDictionary;
if (argsMap != null)
{
JObject namedArgs = new JObject(argsMap);
IRpcParameterDescriptor[] parameters = method.GetParameters();
args = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
args[i] = namedArgs[parameters[i].Name];
namedArgs.Remove(parameters[i].Name);
}
foreach (DictionaryEntry entry in namedArgs)
{
if (entry.Key == null)
continue;
string key = entry.Key.ToString();
char ch1;
char ch2;
if (key.Length == 2)
{
ch1 = key[0];
ch2 = key[1];
}
else if (key.Length == 1)
{
ch1 = '0';
ch2 = key[0];
}
else
{
continue;
}
if (ch1 >= '0' && ch1 < '9' &&
ch2 >= '0' && ch2 < '9')
{
int index = int.Parse(key, NumberStyles.Number, CultureInfo.InvariantCulture);
if (index < parameters.Length)
args[index] = entry.Value;
}
}
return args;
}
else
{
args = CollectionHelper.ToArray((ICollection) argsObject);
}
return JsonRpcServices.TransposeVariableArguments(method, args);
}
protected object Invoke(IRpcMethodDescriptor method, object[] args)
{
return ((RpcMethodDescriptor) method).Invoke(this, args);
}
