MonoRail/Castle.MonoRail.Framework/Services/DefaultControllerTree.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.Services
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20
  21         /// <summary>
  22         /// Default implementation of <see cref="IControllerTree"/>.
  23         /// Represents an binary tree of registered controllers.
  24         /// <para>
  25         /// It is used by the controller factory to resolve a controller instance
  26         /// based on the specified area (which is optional) and controller name
  27         /// </para>
  28         /// <seealso cref="IControllerTree"/>
  29         /// <seealso cref="Castle.MonoRail.Framework.Services.AbstractControllerFactory"/>
  30         /// </summary>
  31         public sealed class DefaultControllerTree : IControllerTree
  32         {
  33                 /// <summary>
  34                 /// The area the controller belongs to.
  35                 /// The default area is <c>String.Empty</c>
  36                 /// </summary>
  37                 private readonly String area;
  38
  39                 /// <summary>
  40                 /// A dictionary of controllers that belongs to this node (area)
  41                 /// </summary>
  42                 private readonly IDictionary controllers;
  43
  44                 /// <summary>
  45                 /// The controllers node on the left
  46                 /// </summary>
  47                 private DefaultControllerTree left;
  48
  49                 /// <summary>
  50                 /// The controllers node on the right
  51                 /// </summary>
  52                 private DefaultControllerTree right;
  53
  54                 /// <summary>
  55                 /// Occurs when a controller is added to the controller tree.
  56                 /// </summary>
  57                 public event EventHandler<ControllerAddedEventArgs> ControllerAdded;
  58
  59                 /// <summary>
  60                 /// Constructs a <c>ControllerTree</c> with an empty area
  61                 /// </summary>
  62                 public DefaultControllerTree() : this(String.Empty)
  63                 {
  64                 }
  65
  66                 /// <summary>
  67                 /// Constructs a <c>ControllerTree</c> specifying an area
  68                 /// </summary>
  69                 public DefaultControllerTree(String areaName)
  70                 {
  71                         if (areaName == null) throw new ArgumentNullException("areaName");
  72
  73                         area = areaName;
  74                         controllers = new HybridDictionary(true);
  75                 }
  76
  77                 private void OnControllerAdded(String area, String controllerName, Type controller)
  78                 {
  79                         if (ControllerAdded != null)
  80                         {
  81                                 ControllerAddedEventArgs args = new ControllerAddedEventArgs(area, controllerName, controller);
  82                                 ControllerAdded(this, args);
  83                         }
  84                 }
  85
  86                 /// <summary>
  87                 /// Register a controller on the tree. If the specified
  88                 /// area name matches the current node, the controller is
  89                 /// register on the node itself, otherwise on the right or
  90                 /// on the left node.
  91                 /// </summary>
  92                 /// <remarks>
  93                 /// Note that the controller is an <c>object</c>. That allows
  94                 /// different implementation of a controller factory to register
  95                 /// different representation of what a controller is (a name, a descriptor etc)
  96                 /// </remarks>
  97                 /// <param name="areaName">The area name, or <c>String.Empty</c></param>
  98                 /// <param name="controllerName">The controller name</param>
  99                 /// <param name="controller">The controller representation</param>
 100                 public void AddController(String areaName, String controllerName, Type controller)
 101                 {
 102                         if (areaName == null) throw new ArgumentNullException("areaName");
 103                         if (controllerName == null) throw new ArgumentNullException("controllerName");
 104                         if (controller == null) throw new ArgumentNullException("controller");
 105
 106                         int cmp = String.Compare(areaName, area, true);
 107
 108                         if (cmp == 0)
 109                         {
 110                                 // If it's the same area, register the controller
 111                                 controllers[controllerName] = controller;
 112                         }
 113                         else
 114                         {
 115                                 // Otherwise, check if the controller should be registered
 116                                 // on the left or on the right
 117
 118                                 DefaultControllerTree node;
 119
 120                                 if (cmp < 0)
 121                                 {
 122                                         if (left == null)
 123                                         {
 124                                                 left = new DefaultControllerTree(areaName);
 125                                         }
 126                                         node = left;
 127                                 }
 128                                 else
 129                                 {
 130                                         if (right == null)
 131                                         {
 132                                                 right = new DefaultControllerTree(areaName);
 133                                         }
 134                                         node = right;
 135                                 }
 136
 137                                 node.AddController(areaName, controllerName, controller);
 138                                 OnControllerAdded(areaName, controllerName, controller);
 139                         }
 140                 }
 141
 142                 /// <summary>
 143                 /// Returns a controller previously registered.
 144                 /// </summary>
 145                 /// <param name="areaName">The area name, or <c>String.Empty</c></param>
 146                 /// <param name="controllerName">The controller name</param>
 147                 /// <returns>The controller representation or null</returns>
 148                 public Type GetController(String areaName, String controllerName)
 149                 {
 150                         if (areaName == null) throw new ArgumentNullException("areaName");
 151                         if (controllerName == null) throw new ArgumentNullException("controllerName");
 152
 153                         int cmp = String.Compare(areaName, area, true);
 154
 155                         if (cmp == 0)
 156                         {
 157                                 return (Type) controllers[controllerName];
 158                         }
 159                         else
 160                         {
 161                                 DefaultControllerTree node;
 162
 163                                 if (cmp < 0)
 164                                 {
 165                                         node = left;
 166                                 }
 167                                 else
 168                                 {
 169                                         node = right;
 170                                 }
 171
 172                                 if (node != null)
 173                                 {
 174                                         return node.GetController(areaName, controllerName);
 175                                 }
 176                         }
 177
 178                         return null;
 179                 }
 180         }
 181
 182         /// <summary>
 183         /// Event class that represents details of the controller added
 184         /// to the controller tree
 185         /// </summary>
 186         public sealed class ControllerAddedEventArgs : System.EventArgs
 187         {
 188                 private readonly String area;
 189                 private readonly String controllerName;
 190                 private readonly Type controllerType;
 191
 192                 /// <summary>
 193                 /// Initializes a new instance of the <see cref="ControllerAddedEventArgs"/> class.
 194                 /// </summary>
 195                 /// <param name="area">The area.</param>
 196                 /// <param name="controllerName">Name of the controller.</param>
 197                 /// <param name="controllerType">Type of the controller.</param>
 198                 public ControllerAddedEventArgs(string area, string controllerName, Type controllerType)
 199                 {
 200                         this.area = area;
 201                         this.controllerName = controllerName;
 202                         this.controllerType = controllerType;
 203                 }
 204
 205                 /// <summary>
 206                 /// Gets the area.
 207                 /// </summary>
 208                 /// <value>The area.</value>
 209                 public string Area
 210                 {
 211                         get { return area; }
 212                 }
 213
 214                 /// <summary>
 215                 /// Gets the name of the controller.
 216                 /// </summary>
 217                 /// <value>The name of the controller.</value>
 218                 public string ControllerName
 219                 {
 220                         get { return controllerName; }
 221                 }
 222
 223                 /// <summary>
 224                 /// Gets the type of the controller.
 225                 /// </summary>
 226                 /// <value>The type of the controller.</value>
 227                 public Type ControllerType
 228                 {
 229                         get { return controllerType; }
 230                 }
 231         }
 232 }