MonoRail/Castle.MonoRail.Framework/Providers/DefaultControllerDescriptorProvider.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.Providers
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Reflection;
  20         using System.Threading;
  21         using Castle.Core.Logging;
  22         using Castle.MonoRail.Framework.Services.Utils;
  23         using Descriptors;
  24         using Providers;
  25
  26         /// <summary>
  27         /// Constructs and caches all collected information
  28         /// about a <see cref="IController"/> and its actions.
  29         /// <seealso cref="ControllerMetaDescriptor"/>
  30         /// </summary>
  31         public class DefaultControllerDescriptorProvider : IControllerDescriptorProvider
  32         {
  33                 /// <summary>
  34                 /// The logger instance
  35                 /// </summary>
  36                 private ILogger logger = NullLogger.Instance;
  37
  38                 /// <summary>
  39                 /// Used to lock the cache
  40                 /// </summary>
  41                 private ReaderWriterLock locker = new ReaderWriterLock();
  42
  43                 private Hashtable descriptorRepository = new Hashtable();
  44                 private IHelperDescriptorProvider helperDescriptorProvider;
  45                 private IFilterDescriptorProvider filterDescriptorProvider;
  46                 private ILayoutDescriptorProvider layoutDescriptorProvider;
  47                 private IRescueDescriptorProvider rescueDescriptorProvider;
  48                 private IResourceDescriptorProvider resourceDescriptorProvider;
  49                 private ITransformFilterDescriptorProvider transformFilterDescriptorProvider;
  50                 private IReturnBinderDescriptorProvider returnBinderDescriptorProvider;
  51
  52                 /// <summary>
  53                 /// Initializes a new instance of the <see cref="DefaultControllerDescriptorProvider"/> class.
  54                 /// </summary>
  55                 public DefaultControllerDescriptorProvider()
  56                 {
  57                 }
  58
  59                 /// <summary>
  60                 /// Initializes a new instance of the <see cref="DefaultControllerDescriptorProvider"/> class.
  61                 /// </summary>
  62                 /// <param name="helperDescriptorProvider">The helper descriptor provider.</param>
  63                 /// <param name="filterDescriptorProvider">The filter descriptor provider.</param>
  64                 /// <param name="layoutDescriptorProvider">The layout descriptor provider.</param>
  65                 /// <param name="rescueDescriptorProvider">The rescue descriptor provider.</param>
  66                 /// <param name="resourceDescriptorProvider">The resource descriptor provider.</param>
  67                 /// <param name="transformFilterDescriptorProvider">The transform filter descriptor provider.</param>
  68                 /// <param name="returnBinderDescriptorProvider">The return binder descriptor provider.</param>
  69                 public DefaultControllerDescriptorProvider(IHelperDescriptorProvider helperDescriptorProvider,
  70                                                            IFilterDescriptorProvider filterDescriptorProvider,
  71                                                            ILayoutDescriptorProvider layoutDescriptorProvider,
  72                                                            IRescueDescriptorProvider rescueDescriptorProvider,
  73                                                            IResourceDescriptorProvider resourceDescriptorProvider,
  74                                                            ITransformFilterDescriptorProvider transformFilterDescriptorProvider,
  75                                                            IReturnBinderDescriptorProvider returnBinderDescriptorProvider)
  76                 {
  77                         this.helperDescriptorProvider = helperDescriptorProvider;
  78                         this.filterDescriptorProvider = filterDescriptorProvider;
  79                         this.layoutDescriptorProvider = layoutDescriptorProvider;
  80                         this.rescueDescriptorProvider = rescueDescriptorProvider;
  81                         this.resourceDescriptorProvider = resourceDescriptorProvider;
  82                         this.transformFilterDescriptorProvider = transformFilterDescriptorProvider;
  83                         this.returnBinderDescriptorProvider = returnBinderDescriptorProvider;
  84                 }
  85
  86                 #region IMRServiceEnabled implementation
  87
  88                 /// <summary>
  89                 /// Services the specified service provider.
  90                 /// </summary>
  91                 /// <param name="serviceProvider">The service provider.</param>
  92                 public void Service(IMonoRailServices serviceProvider)
  93                 {
  94                         ILoggerFactory loggerFactory = (ILoggerFactory) serviceProvider.GetService(typeof(ILoggerFactory));
  95
  96                         if (loggerFactory != null)
  97                         {
  98                                 logger = loggerFactory.Create(typeof(DefaultControllerDescriptorProvider));
  99                         }
 100
 101                         helperDescriptorProvider = serviceProvider.GetService<IHelperDescriptorProvider>();
 102                         filterDescriptorProvider = serviceProvider.GetService<IFilterDescriptorProvider>();
 103                         layoutDescriptorProvider = serviceProvider.GetService<ILayoutDescriptorProvider>();
 104                         rescueDescriptorProvider = serviceProvider.GetService<IRescueDescriptorProvider>();
 105                         resourceDescriptorProvider = serviceProvider.GetService<IResourceDescriptorProvider>();
 106                         transformFilterDescriptorProvider = serviceProvider.GetService<ITransformFilterDescriptorProvider>();
 107                         returnBinderDescriptorProvider = serviceProvider.GetService<IReturnBinderDescriptorProvider>();
 108                 }
 109
 110                 #endregion
 111
 112                 /// <summary>
 113                 /// Occurs when the providers needs to create a <see cref="ControllerMetaDescriptor"/>.
 114                 /// </summary>
 115                 public event MetaCreatorHandler Create;
 116
 117                 /// <summary>
 118                 /// Occurs when the meta descriptor is about to the returned to the caller.
 119                 /// </summary>
 120                 public event ControllerMetaDescriptorHandler AfterProcess;
 121
 122                 /// <summary>
 123                 /// Occurs when the providers needs to create a <see cref="ActionMetaDescriptor"/>.
 124                 /// </summary>
 125                 public event ActionMetaCreatorHandler ActionCreate;
 126
 127                 /// <summary>
 128                 /// Occurs when the meta descriptor is about to be included on the <see cref="ControllerMetaDescriptor"/>.
 129                 /// </summary>
 130                 public event ActionMetaDescriptorHandler AfterActionProcess;
 131
 132                 /// <summary>
 133                 /// Constructs and populates a <see cref="ControllerMetaDescriptor"/>.
 134                 /// </summary>
 135                 /// <remarks>
 136                 /// This implementation is also responsible for caching
 137                 /// constructed meta descriptors.
 138                 /// </remarks>
 139                 public ControllerMetaDescriptor BuildDescriptor(IController controller)
 140                 {
 141                         Type controllerType = controller.GetType();
 142
 143                         return BuildDescriptor(controllerType);
 144                 }
 145
 146                 /// <summary>
 147                 /// Constructs and populates a <see cref="ControllerMetaDescriptor"/>.
 148                 /// </summary>
 149                 /// <remarks>
 150                 /// This implementation is also responsible for caching
 151                 /// constructed meta descriptors.
 152                 /// </remarks>
 153                 public ControllerMetaDescriptor BuildDescriptor(Type controllerType)
 154                 {
 155                         ControllerMetaDescriptor desc;
 156
 157                         locker.AcquireReaderLock(-1);
 158
 159                         desc = (ControllerMetaDescriptor) descriptorRepository[controllerType];
 160
 161                         if (desc != null)
 162                         {
 163                                 locker.ReleaseReaderLock();
 164                                 return desc;
 165                         }
 166
 167                         try
 168                         {
 169                                 locker.UpgradeToWriterLock(-1);
 170
 171                                 // We need to recheck after getting the writer lock
 172                                 desc = (ControllerMetaDescriptor) descriptorRepository[controllerType];
 173
 174                                 if (desc != null)
 175                                 {
 176                                         return desc;
 177                                 }
 178
 179                                 desc = InternalBuildDescriptor(controllerType);
 180
 181                                 descriptorRepository[controllerType] = desc;
 182                         }
 183                         finally
 184                         {
 185                                 locker.ReleaseWriterLock();
 186                         }
 187
 188                         return desc;
 189                 }
 190
 191                 /// <summary>
 192                 /// Builds the <see cref="ControllerMetaDescriptor"/> for the specified controller type
 193                 /// </summary>
 194                 /// <param name="controllerType">Type of the controller.</param>
 195                 /// <returns></returns>
 196                 private ControllerMetaDescriptor InternalBuildDescriptor(Type controllerType)
 197                 {
 198                         if (logger.IsDebugEnabled)
 199                         {
 200                                 logger.DebugFormat("Building controller descriptor for {0}", controllerType);
 201                         }
 202
 203                         ControllerMetaDescriptor descriptor = CreateMetaDescriptor();
 204
 205                         descriptor.ControllerDescriptor = ControllerInspectionUtil.Inspect(controllerType);
 206
 207                         CollectClassLevelAttributes(controllerType, descriptor);
 208
 209                         CollectActions(controllerType, descriptor);
 210
 211                         CollectActionLevelAttributes(descriptor);
 212
 213                         if (AfterProcess != null)
 214                         {
 215                                 AfterProcess(descriptor);
 216                         }
 217
 218                         return descriptor;
 219                 }
 220
 221                 #region Action data
 222
 223                 /// <summary>
 224                 /// Collects the actions.
 225                 /// </summary>
 226                 /// <param name="controllerType">Type of the controller.</param>
 227                 /// <param name="desc">The desc.</param>
 228                 private void CollectActions(Type controllerType, ControllerMetaDescriptor desc)
 229                 {
 230                         // HACK: GetRealControllerType is a workaround for DYNPROXY-14 bug
 231                         // see: http://support.castleproject.org/browse/DYNPROXY-14
 232                         controllerType = GetRealControllerType(controllerType);
 233
 234                         MethodInfo[] methods = controllerType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
 235
 236                         foreach(MethodInfo method in methods)
 237                         {
 238                                 Type declaringType = method.DeclaringType;
 239
 240                                 if (method.IsSpecialName)
 241                                 {
 242                                         continue;
 243                                 }
 244
 245                                 if (declaringType == typeof(Object) ||
 246                                     declaringType == typeof(IController) || declaringType == typeof(Controller))
 247                                         // || declaringType == typeof(SmartDispatcherController))
 248                                 {
 249                                         continue;
 250                                 }
 251
 252                                 if (desc.Actions.Contains(method.Name))
 253                                 {
 254                                         ArrayList list = desc.Actions[method.Name] as ArrayList;
 255
 256                                         if (list == null)
 257                                         {
 258                                                 list = new ArrayList();
 259                                                 list.Add(desc.Actions[method.Name]);
 260
 261                                                 desc.Actions[method.Name] = list;
 262                                         }
 263
 264                                         list.Add(method);
 265                                 }
 266                                 else
 267                                 {
 268                                         desc.Actions[method.Name] = method;
 269                                 }
 270                         }
 271                 }
 272
 273                 /// <summary>
 274                 /// Collects the action level attributes.
 275                 /// </summary>
 276                 /// <param name="descriptor">The descriptor.</param>
 277                 private void CollectActionLevelAttributes(ControllerMetaDescriptor descriptor)
 278                 {
 279                         foreach(object action in descriptor.Actions.Values)
 280                         {
 281                                 if (action is IList)
 282                                 {
 283                                         foreach(MethodInfo overloadedAction in (action as IList))
 284                                         {
 285                                                 CollectActionAttributes(overloadedAction, descriptor);
 286                                         }
 287
 288                                         continue;
 289                                 }
 290
 291                                 CollectActionAttributes(action as MethodInfo, descriptor);
 292                         }
 293                 }
 294
 295                 /// <summary>
 296                 /// Collects the action attributes.
 297                 /// </summary>
 298                 /// <param name="method">The method.</param>
 299                 /// <param name="descriptor">The descriptor.</param>
 300                 private void CollectActionAttributes(MethodInfo method, ControllerMetaDescriptor descriptor)
 301                 {
 302                         if (logger.IsDebugEnabled)
 303                         {
 304                                 logger.DebugFormat("Collection attributes for action {0}", method.Name);
 305                         }
 306
 307                         ActionMetaDescriptor actionDescriptor = descriptor.GetAction(method);
 308
 309                         if (actionDescriptor == null)
 310                         {
 311                                 actionDescriptor = CreateActionDescriptor();
 312
 313                                 descriptor.AddAction(method, actionDescriptor);
 314                         }
 315
 316                         CollectResources(actionDescriptor, method);
 317                         CollectSkipFilter(actionDescriptor, method);
 318                         CollectRescues(actionDescriptor, method);
 319                         CollectAccessibleThrough(actionDescriptor, method);
 320                         CollectSkipRescue(actionDescriptor, method);
 321                         CollectLayout(actionDescriptor, method);
 322                         CollectCacheConfigure(actionDescriptor, method);
 323                         CollectTransformFilter(actionDescriptor, method);
 324                         CollectReturnTypeBinder(actionDescriptor, method);
 325
 326                         if (method.IsDefined(typeof(AjaxActionAttribute), true))
 327                         {
 328                                 descriptor.AjaxActions.Add(method);
 329                         }
 330
 331                         if (method.IsDefined(typeof(DefaultActionAttribute), true))
 332                         {
 333                                 if (descriptor.DefaultAction != null)
 334                                 {
 335                                         throw new MonoRailException(
 336                                                 "Cannot resolve a default action for {0}, DefaultActionAttribute was declared more than once.",
 337                                                 method.DeclaringType.FullName);
 338                                 }
 339                                 descriptor.DefaultAction = new DefaultActionAttribute(method.Name);
 340                         }
 341
 342                         if (AfterActionProcess != null)
 343                         {
 344                                 AfterActionProcess(actionDescriptor);
 345                         }
 346                 }
 347
 348                 /// <summary>
 349                 /// Collects the skip rescue.
 350                 /// </summary>
 351                 /// <param name="actionDescriptor">The action descriptor.</param>
 352                 /// <param name="method">The method.</param>
 353                 private void CollectSkipRescue(ActionMetaDescriptor actionDescriptor, MethodInfo method)
 354                 {
 355                         object[] attributes = method.GetCustomAttributes(typeof(SkipRescueAttribute), true);
 356
 357                         if (attributes.Length != 0)
 358                         {
 359                                 actionDescriptor.SkipRescue = (SkipRescueAttribute) attributes[0];
 360                         }
 361                 }
 362
 363                 /// <summary>
 364                 /// Collects the accessible through.
 365                 /// </summary>
 366                 /// <param name="actionDescriptor">The action descriptor.</param>
 367                 /// <param name="method">The method.</param>
 368                 private void CollectAccessibleThrough(ActionMetaDescriptor actionDescriptor, MethodInfo method)
 369                 {
 370                         object[] attributes = method.GetCustomAttributes(typeof(AccessibleThroughAttribute), true);
 371
 372                         if (attributes.Length != 0)
 373                         {
 374                                 actionDescriptor.AccessibleThrough = (AccessibleThroughAttribute) attributes[0];
 375                         }
 376                 }
 377
 378                 /// <summary>
 379                 /// Collects the skip filter.
 380                 /// </summary>
 381                 /// <param name="actionDescriptor">The action descriptor.</param>
 382                 /// <param name="method">The method.</param>
 383                 private void CollectSkipFilter(ActionMetaDescriptor actionDescriptor, MethodInfo method)
 384                 {
 385                         object[] attributes = method.GetCustomAttributes(typeof(SkipFilterAttribute), true);
 386
 387                         foreach(SkipFilterAttribute attr in attributes)
 388                         {
 389                                 actionDescriptor.SkipFilters.Add(attr);
 390                         }
 391                 }
 392
 393                 /// <summary>
 394                 /// Collects the resources.
 395                 /// </summary>
 396                 /// <param name="desc">The desc.</param>
 397                 /// <param name="memberInfo">The member info.</param>
 398                 private void CollectResources(BaseMetaDescriptor desc, MemberInfo memberInfo)
 399                 {
 400                         desc.Resources = resourceDescriptorProvider.CollectResources(memberInfo);
 401                 }
 402
 403                 /// <summary>
 404                 /// Collects the transform filter.
 405                 /// </summary>
 406                 /// <param name="actionDescriptor">The action descriptor.</param>
 407                 /// <param name="method">The method.</param>
 408                 private void CollectTransformFilter(ActionMetaDescriptor actionDescriptor, MethodInfo method)
 409                 {
 410                         actionDescriptor.TransformFilters = transformFilterDescriptorProvider.CollectFilters((method));
 411                         Array.Sort(actionDescriptor.TransformFilters, TransformFilterDescriptorComparer.Instance);
 412                 }
 413
 414                 /// <summary>
 415                 /// Collects the return type binder.
 416                 /// </summary>
 417                 /// <param name="actionDescriptor">The action descriptor.</param>
 418                 /// <param name="method">The method.</param>
 419                 private void CollectReturnTypeBinder(ActionMetaDescriptor actionDescriptor, MethodInfo method)
 420                 {
 421                         actionDescriptor.ReturnDescriptor = returnBinderDescriptorProvider.Collect(method);
 422                 }
 423
 424                 /// <summary>
 425                 /// Gets the real controller type, instead of the proxy type.
 426                 /// </summary>
 427                 /// <remarks>
 428                 /// Workaround for DYNPROXY-14 bug. See: http://support.castleproject.org/browse/DYNPROXY-14
 429                 /// </remarks>
 430                 private Type GetRealControllerType(Type controllerType)
 431                 {
 432                         Type prev = controllerType;
 433
 434                         // try to get the first non-proxy type
 435                         while(controllerType.Assembly.FullName.StartsWith("DynamicProxyGenAssembly2") ||
 436                               controllerType.Assembly.FullName.StartsWith("DynamicAssemblyProxyGen"))
 437                         {
 438                                 controllerType = controllerType.BaseType;
 439
 440                                 if ( // controllerType == typeof(SmartDispatcherController) ||
 441                                         controllerType == typeof(IController))
 442                                 {
 443                                         // oops, it's a pure-proxy controller. just let it go.
 444                                         controllerType = prev;
 445                                         break;
 446                                 }
 447                         }
 448
 449                         return controllerType;
 450                 }
 451
 452                 #endregion
 453
 454                 #region Controller data
 455
 456                 /// <summary>
 457                 /// Collects the class level attributes.
 458                 /// </summary>
 459                 /// <param name="controllerType">Type of the controller.</param>
 460                 /// <param name="descriptor">The descriptor.</param>
 461                 private void CollectClassLevelAttributes(Type controllerType, ControllerMetaDescriptor descriptor)
 462                 {
 463                         CollectHelpers(descriptor, controllerType);
 464                         CollectResources(descriptor, controllerType);
 465                         CollectFilters(descriptor, controllerType);
 466                         CollectLayout(descriptor, controllerType);
 467                         CollectRescues(descriptor, controllerType);
 468                         CollectDefaultAction(descriptor, controllerType);
 469                         CollectScaffolding(descriptor, controllerType);
 470                         CollectDynamicAction(descriptor, controllerType);
 471                         CollectCacheConfigure(descriptor, controllerType);
 472                 }
 473
 474                 /// <summary>
 475                 /// Collects the default action.
 476                 /// </summary>
 477                 /// <param name="descriptor">The descriptor.</param>
 478                 /// <param name="controllerType">Type of the controller.</param>
 479                 private void CollectDefaultAction(ControllerMetaDescriptor descriptor, Type controllerType)
 480                 {
 481                         object[] attributes = controllerType.GetCustomAttributes(typeof(DefaultActionAttribute), true);
 482
 483                         if (attributes.Length != 0)
 484                         {
 485                                 descriptor.DefaultAction = (DefaultActionAttribute) attributes[0];
 486                         }
 487                 }
 488
 489                 /// <summary>
 490                 /// Collects the scaffolding.
 491                 /// </summary>
 492                 /// <param name="descriptor">The descriptor.</param>
 493                 /// <param name="controllerType">Type of the controller.</param>
 494                 private void CollectScaffolding(ControllerMetaDescriptor descriptor, Type controllerType)
 495                 {
 496                         object[] attributes = controllerType.GetCustomAttributes(typeof(ScaffoldingAttribute), false);
 497
 498                         if (attributes.Length != 0)
 499                         {
 500                                 foreach(ScaffoldingAttribute scaffolding in attributes)
 501                                 {
 502                                         descriptor.Scaffoldings.Add(scaffolding);
 503                                 }
 504                         }
 505                 }
 506
 507                 /// <summary>
 508                 /// Collects the dynamic action.
 509                 /// </summary>
 510                 /// <param name="descriptor">The descriptor.</param>
 511                 /// <param name="controllerType">Type of the controller.</param>
 512                 private void CollectDynamicAction(ControllerMetaDescriptor descriptor, Type controllerType)
 513                 {
 514                         object[] attributes = controllerType.GetCustomAttributes(typeof(DynamicActionProviderAttribute), true);
 515
 516                         if (attributes.Length != 0)
 517                         {
 518                                 foreach(DynamicActionProviderAttribute attr in attributes)
 519                                 {
 520                                         descriptor.ActionProviders.Add(attr.ProviderType);
 521                                 }
 522                         }
 523                 }
 524
 525                 /// <summary>
 526                 /// Collects the helpers.
 527                 /// </summary>
 528                 /// <param name="descriptor">The descriptor.</param>
 529                 /// <param name="controllerType">Type of the controller.</param>
 530                 private void CollectHelpers(ControllerMetaDescriptor descriptor, Type controllerType)
 531                 {
 532                         descriptor.Helpers = helperDescriptorProvider.CollectHelpers(controllerType);
 533                 }
 534
 535                 /// <summary>
 536                 /// Collects the filters.
 537                 /// </summary>
 538                 /// <param name="descriptor">The descriptor.</param>
 539                 /// <param name="controllerType">Type of the controller.</param>
 540                 private void CollectFilters(ControllerMetaDescriptor descriptor, Type controllerType)
 541                 {
 542                         descriptor.Filters = filterDescriptorProvider.CollectFilters(controllerType);
 543
 544                         Array.Sort(descriptor.Filters, FilterDescriptorComparer.Instance);
 545                 }
 546
 547                 /// <summary>
 548                 /// Collects the layout.
 549                 /// </summary>
 550                 /// <param name="descriptor">The descriptor.</param>
 551                 /// <param name="memberInfo">The member info.</param>
 552                 private void CollectLayout(BaseMetaDescriptor descriptor, MemberInfo memberInfo)
 553                 {
 554                         descriptor.Layout = layoutDescriptorProvider.CollectLayout(memberInfo);
 555                 }
 556
 557                 /// <summary>
 558                 /// Collects the rescues.
 559                 /// </summary>
 560                 /// <param name="descriptor">The descriptor.</param>
 561                 /// <param name="memberInfo">The member info.</param>
 562                 private void CollectRescues(BaseMetaDescriptor descriptor, MethodInfo memberInfo)
 563                 {
 564                         descriptor.Rescues = rescueDescriptorProvider.CollectRescues(memberInfo);
 565                 }
 566
 567                 /// <summary>
 568                 /// Collects the rescues.
 569                 /// </summary>
 570                 /// <param name="descriptor">The descriptor.</param>
 571                 /// <param name="type">The type.</param>
 572                 private void CollectRescues(BaseMetaDescriptor descriptor, Type type)
 573                 {
 574                         descriptor.Rescues = rescueDescriptorProvider.CollectRescues(type);
 575                 }
 576
 577                 /// <summary>
 578                 /// Collects the cache configures.
 579                 /// </summary>
 580                 /// <param name="descriptor">The descriptor.</param>
 581                 /// <param name="memberInfo">The member info.</param>
 582                 private void CollectCacheConfigure(BaseMetaDescriptor descriptor, MemberInfo memberInfo)
 583                 {
 584                         object[] configurers = memberInfo.GetCustomAttributes(typeof(ICachePolicyConfigurer), true);
 585
 586                         if (configurers.Length != 0)
 587                         {
 588                                 descriptor.CacheConfigurer = (ICachePolicyConfigurer) configurers[0];
 589                         }
 590                 }
 591
 592                 #endregion
 593
 594                 private ControllerMetaDescriptor CreateMetaDescriptor()
 595                 {
 596                         if (Create != null)
 597                         {
 598                                 return Create();
 599                         }
 600                         else
 601                         {
 602                                 return new ControllerMetaDescriptor();
 603                         }
 604                 }
 605
 606                 private ActionMetaDescriptor CreateActionDescriptor()
 607                 {
 608                         if (ActionCreate != null)
 609                         {
 610                                 return ActionCreate();
 611                         }
 612                         else
 613                         {
 614                                 return new ActionMetaDescriptor();
 615                         }
 616                 }
 617
 618                 /// <summary>
 619                 /// This <see cref="IComparer"/> implementation
 620                 /// is used to sort the filters based on their Execution Order.
 621                 /// </summary>
 622                 private class FilterDescriptorComparer : IComparer
 623                 {
 624                         private static readonly FilterDescriptorComparer instance = new FilterDescriptorComparer();
 625
 626                         /// <summary>
 627                         /// Initializes a new instance of the <see cref="FilterDescriptorComparer"/> class.
 628                         /// </summary>
 629                         private FilterDescriptorComparer()
 630                         {
 631                         }
 632
 633                         /// <summary>
 634                         /// Gets the instance.
 635                         /// </summary>
 636                         /// <value>The instance.</value>
 637                         public static FilterDescriptorComparer Instance
 638                         {
 639                                 get { return instance; }
 640                         }
 641
 642                         /// <summary>
 643                         /// Compares the specified left.
 644                         /// </summary>
 645                         /// <param name="left">The left.</param>
 646                         /// <param name="right">The right.</param>
 647                         /// <returns></returns>
 648                         public int Compare(object left, object right)
 649                         {
 650                                 return ((FilterDescriptor) left).ExecutionOrder - ((FilterDescriptor) right).ExecutionOrder;
 651                         }
 652                 }
 653
 654                 /// <summary>
 655                 /// This <see cref="IComparer"/> implementation
 656                 /// is used to sort the transformfilters based on their Execution Order.
 657                 /// </summary>
 658                 private class TransformFilterDescriptorComparer : IComparer
 659                 {
 660                         private static readonly TransformFilterDescriptorComparer instance = new TransformFilterDescriptorComparer();
 661
 662                         /// <summary>
 663                         /// Initializes a new instance of the <see cref="TransformFilterDescriptorComparer"/> class.
 664                         /// </summary>
 665                         private TransformFilterDescriptorComparer()
 666                         {
 667                         }
 668
 669                         /// <summary>
 670                         /// Gets the instance.
 671                         /// </summary>
 672                         /// <value>The instance.</value>
 673                         public static TransformFilterDescriptorComparer Instance
 674                         {
 675                                 get { return instance; }
 676                         }
 677
 678                         /// <summary>
 679                         /// Compares the specified left.
 680                         /// </summary>
 681                         /// <param name="left">The left.</param>
 682                         /// <param name="right">The right.</param>
 683                         /// <returns></returns>
 684                         public int Compare(object left, object right)
 685                         {
 686                                 return ((TransformFilterDescriptor) right).ExecutionOrder - ((TransformFilterDescriptor) left).ExecutionOrder;
 687                         }
 688                 }
 689         }
 690 }