MonoRail/Castle.MonoRail.Framework/JSGeneration/DynamicDispatching/DynamicDispatcher.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MonoRail.Framework.JSGeneration.DynamicDispatching
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.Reflection;
  20
  21         /// <summary>
  22         /// The DynamicDispatcher has the ability of late bound and dispatch method invocation
  23         /// to several targets. The intention is mimic what you can achieve with dynamic languages
  24         /// and mixins.
  25         /// </summary>
  26         public class DynamicDispatcher
  27         {
  28                 private readonly Dictionary<string, MethodTarget> method2Target;
  29
  30                 /// <summary>
  31                 /// Initializes a new instance of the <see cref="DynamicDispatcher"/> class.
  32                 /// </summary>
  33                 /// <param name="mainTarget">The main target.</param>
  34                 /// <param name="extensions">The extensions.</param>
  35                 public DynamicDispatcher(object mainTarget, params object[] extensions)
  36                 {
  37                         method2Target = new Dictionary<string, MethodTarget>(StringComparer.InvariantCultureIgnoreCase);
  38
  39                         // We can create a cache of operations per type here as inspecting types over and over is very time consuming
  40
  41                         CollectOperations(mainTarget);
  42
  43                         foreach(object extension in extensions)
  44                         {
  45                                 CollectOperations(extension);
  46                         }
  47                 }
  48
  49                 /// <summary>
  50                 /// Determines whether the specified instance has the method.
  51                 /// </summary>
  52                 /// <param name="methodName">Name of the method.</param>
  53                 /// <returns>
  54                 ///     <c>true</c> if the method was registered; otherwise, <c>false</c>.
  55                 /// </returns>
  56                 public bool HasMethod(string methodName)
  57                 {
  58                         return method2Target.ContainsKey(methodName);
  59                 }
  60
  61                 /// <summary>
  62                 /// Dispatches the specified method.
  63                 /// </summary>
  64                 /// <param name="method">The method.</param>
  65                 /// <param name="args">The args.</param>
  66                 /// <returns></returns>
  67                 public object Dispatch(string method, params object[] args)
  68                 {
  69                         MethodTarget target;
  70                         if (!method2Target.TryGetValue(method, out target))
  71                         {
  72                                 throw new InvalidOperationException("Method " + method + " not found for dynamic dispatching");
  73                         }
  74
  75                         MethodInfo methodInfo = target.Method;
  76
  77                         ParameterInfo[] parameters = methodInfo.GetParameters();
  78
  79                         int paramArrayIndex = -1;
  80
  81                         for (int i = 0; i < parameters.Length; i++)
  82                         {
  83                                 ParameterInfo paramInfo = parameters[i];
  84
  85                                 if (paramInfo.IsDefined(typeof(ParamArrayAttribute), true))
  86                                 {
  87                                         paramArrayIndex = i;
  88                                 }
  89                         }
  90
  91                         try
  92                         {
  93                                 return methodInfo.Invoke(target.Target, BuildMethodArgs(methodInfo, args, paramArrayIndex));
  94                         }
  95                         catch(MonoRailException)
  96                         {
  97                                 throw;
  98                         }
  99                         catch(Exception ex)
 100                         {
 101                                 throw new Exception("Error invoking method on generator. " +
 102                                                     "Method invoked [" + method + "] with " + args.Length + " argument(s)", ex);
 103                         }
 104                 }
 105
 106                 private void CollectOperations(object target)
 107                 {
 108                         foreach (MethodInfo method in target.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance))
 109                         {
 110                                 if (!method.IsDefined(typeof(DynamicOperationAttribute), true))
 111                                 {
 112                                         continue;
 113                                 }
 114
 115                                 method2Target[method.Name] = new MethodTarget(target, method);
 116                         }
 117                 }
 118
 119                 private object[] BuildMethodArgs(MethodInfo method, object[] methodArguments, int paramArrayIndex)
 120                 {
 121                         if (methodArguments == null) return new object[0];
 122
 123                         ParameterInfo[] methodArgs = method.GetParameters();
 124
 125                         if (paramArrayIndex != -1)
 126                         {
 127                                 Type arrayParamType = methodArgs[paramArrayIndex].ParameterType;
 128
 129                                 object[] newParams = new object[methodArgs.Length];
 130
 131                                 Array.Copy(methodArguments, newParams, methodArgs.Length - 1);
 132
 133                                 if (methodArguments.Length < (paramArrayIndex + 1))
 134                                 {
 135                                         newParams[paramArrayIndex] = Array.CreateInstance(
 136                                                 arrayParamType.GetElementType(), 0);
 137                                 }
 138                                 else
 139                                 {
 140                                         Array args = Array.CreateInstance(arrayParamType.GetElementType(), (methodArguments.Length + 1) - newParams.Length);
 141
 142                                         Array.Copy(methodArguments, methodArgs.Length - 1, args, 0, args.Length);
 143
 144                                         newParams[paramArrayIndex] = args;
 145                                 }
 146
 147                                 methodArguments = newParams;
 148                         }
 149                         else
 150                         {
 151                                 int expectedParameterCount = methodArgs.Length;
 152
 153                                 if (methodArguments.Length < expectedParameterCount)
 154                                 {
 155                                         // Complete with nulls, assuming that parameters are optional
 156
 157                                         object[] newArgs = new object[expectedParameterCount];
 158
 159                                         Array.Copy(methodArguments, newArgs, methodArguments.Length);
 160
 161                                         methodArguments = newArgs;
 162                                 }
 163                         }
 164
 165                         return methodArguments;
 166                 }
 167
 168                 private class MethodTarget
 169                 {
 170                         private readonly object target;
 171                         private readonly MethodInfo method;
 172
 173                         public MethodTarget(object target, MethodInfo method)
 174                         {
 175                                 this.target = target;
 176                                 this.method = method;
 177                         }
 178
 179                         public object Target
 180                         {
 181                                 get { return target; }
 182                         }
 183
 184                         public MethodInfo Method
 185                         {
 186                                 get { return method; }
 187                         }
 188                 }
 189         }
 190 }