InversionOfControl/Castle.MicroKernel/ModelBuilder/Inspectors/MethodMetaInspector.cs

   1 // Copyright 2004-2007 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.MicroKernel.ModelBuilder.Inspectors
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Configuration;
  20         using System.Reflection;
  21
  22         using Castle.Core;
  23         using Castle.Core.Configuration;
  24
  25         using Castle.MicroKernel.SubSystems.Conversion;
  26
  27
  28         /// <summary>
  29         /// Base for inspectors that want configuration associated with methods.
  30         /// For each child a <see cref="MethodMetaModel"/> is created
  31         /// and added to ComponentModel's methods collection
  32         /// </summary>
  33         /// <remarks>
  34         /// Implementors should override the <see cref="ObtainNodeName"/> return
  35         /// the name of the node to be inspected. For example:
  36         /// <code>
  37         /// <pre>
  38         ///   <transactions>
  39         ///     <method name="Save" transaction="requires" />
  40         ///   </transactions>
  41         /// </pre>
  42         /// </code>
  43         /// </remarks>
  44         public abstract class MethodMetaInspector : IContributeComponentModelConstruction
  45         {
  46                 private static readonly BindingFlags AllMethods =
  47                         BindingFlags.Public|BindingFlags.NonPublic|
  48                         BindingFlags.Instance|BindingFlags.Static|
  49                         BindingFlags.IgnoreCase|BindingFlags.IgnoreReturn;
  50
  51                 private ITypeConverter converter;
  52
  53                 public virtual void ProcessModel(IKernel kernel, ComponentModel model)
  54                 {
  55                         if (model == null) throw new ArgumentNullException("model");
  56
  57                         if (model.Configuration == null || model.Implementation == null) return;
  58
  59                         IConfiguration methodsNode = model.Configuration.Children[ObtainNodeName()];
  60
  61                         if (methodsNode == null) return;
  62
  63                         EnsureHasReferenceToConverter(kernel);
  64
  65                         foreach(IConfiguration methodNode in methodsNode.Children)
  66                         {
  67                                 String name = methodNode.Name;
  68
  69                                 if ("method".Equals(name))
  70                                 {
  71                                         name = methodNode.Attributes["name"];
  72                                 }
  73
  74                                 AssertNameIsNotNull(name, model);
  75
  76                                 MethodMetaModel metaModel = new MethodMetaModel(methodNode);
  77
  78                                 if (IsValidMeta(model, metaModel))
  79                                 {
  80                                         if (ShouldUseMetaModel)
  81                                         {
  82                                                 // model.MethodMetaModels.Add( metaModel );
  83                                         }
  84
  85                                         String signature = methodNode.Attributes["signature"];
  86
  87                                         MethodInfo[] methods = GetMethods(model.Implementation, name, signature);
  88
  89                                         if (methods.Length == 0)
  90                                         {
  91                                                 String message = String.Format( "The class {0} has tried to expose configuration for " +
  92                                                         "a method named {1} which could not be found.", model.Implementation.FullName, name );
  93
  94                                                 throw new ConfigurationErrorsException(message);
  95                                         }
  96
  97                                         ProcessMeta(model, methods, metaModel);
  98
  99                                         if (ShouldUseMetaModel)
 100                                         {
 101                                                 // RegisterMethodsForFastAccess(methods, signature, metaModel, model);
 102                                         }
 103                                 }
 104                         }
 105                 }
 106
 107                 protected virtual void ProcessMeta(ComponentModel model, MethodInfo[] methods, MethodMetaModel metaModel)
 108                 {
 109                 }
 110
 111                 protected virtual bool IsValidMeta(ComponentModel model, MethodMetaModel metaModel)
 112                 {
 113                         return true;
 114                 }
 115
 116                 protected virtual bool ShouldUseMetaModel
 117                 {
 118                         get { return false; }
 119                 }
 120
 121                 protected abstract String ObtainNodeName();
 122
 123 //              private void RegisterMethodsForFastAccess(MethodInfo[] methods,
 124 //                      String signature, MethodMetaModel metaModel, ComponentModel model)
 125 //              {
 126 //                      foreach(MethodInfo method in methods)
 127 //                      {
 128 //                              if (signature != null && signature.Length != 0)
 129 //                              {
 130 //                                      model.MethodMetaModels.MethodInfo2Model[method] = metaModel;
 131 //                              }
 132 //                              else
 133 //                              {
 134 //                                      if (!model.MethodMetaModels.MethodInfo2Model.Contains(method))
 135 //                                      {
 136 //                                              model.MethodMetaModels.MethodInfo2Model[method] = metaModel;
 137 //                                      }
 138 //                              }
 139 //                      }
 140 //              }
 141
 142                 private void AssertNameIsNotNull(string name, ComponentModel model)
 143                 {
 144                         if (name == null)
 145                         {
 146                                 String message = String.Format("The configuration nodes within 'methods' " +
 147                                         "for the component '{0}' does not have a name. You can either name " +
 148                                         "the node as the method name or provide an attribute 'name'", model.Name);
 149
 150                                 throw new ConfigurationErrorsException(message);
 151                         }
 152                 }
 153
 154                 private void EnsureHasReferenceToConverter(IKernel kernel)
 155                 {
 156                         if (converter != null) return;
 157
 158                         converter = (ITypeConverter)
 159                                 kernel.GetSubSystem( SubSystemConstants.ConversionManagerKey );
 160                 }
 161
 162                 private MethodInfo[] GetMethods(Type implementation, String name, String signature)
 163                 {
 164                         if (signature == null || signature.Length == 0)
 165                         {
 166                                 MethodInfo[] allmethods = implementation.GetMethods(AllMethods);
 167
 168                                 ArrayList methods = new ArrayList();
 169
 170                                 foreach(MethodInfo method in allmethods)
 171                                 {
 172                                         if (String.Compare(method.Name, name, true) == 0)
 173                                         {
 174                                                 methods.Add(method);
 175                                         }
 176                                 }
 177
 178                                 return (MethodInfo[]) methods.ToArray( typeof(MethodInfo) );
 179                         }
 180                         else
 181                         {
 182                                 MethodInfo methodInfo = implementation.GetMethod(name, AllMethods, null, ConvertSignature(signature), null );
 183
 184                                 if (methodInfo == null) return new MethodInfo[0];
 185
 186                                 return new MethodInfo[] { methodInfo };
 187                         }
 188                 }
 189
 190                 private Type[] ConvertSignature(string signature)
 191                 {
 192                         String[] parameters = signature.Split(';');
 193
 194                         ArrayList types = new ArrayList();
 195
 196                         foreach(String param in parameters)
 197                         {
 198                                 try
 199                                 {
 200                                         types.Add( converter.PerformConversion( param, typeof(Type) ) );
 201                                 }
 202                                 catch(Exception)
 203                                 {
 204                                         String message = String.Format("The signature {0} contains an entry type {1} " +
 205                                                 "that could not be converted to System.Type. Check the inner exception for " +
 206                                                 "details", signature, param);
 207
 208                                         throw new ConfigurationErrorsException(message);
 209                                 }
 210                         }
 211
 212                         return (Type[]) types.ToArray( typeof(Type) );
 213                 }
 214         }
 215 }