MonoRail/Castle.MonoRail.Framework/Routing/BaseRoutingRuleContainer.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.Routing
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.Threading;
  21         using Core;
  22
  23         /// <summary>
  24         /// Pendent
  25         /// </summary>
  26         public class RoutingRuleContainer : IRoutingRuleContainer
  27         {
  28                 private readonly List<DecoratedRule> rules = new List<DecoratedRule>();
  29                 private readonly Dictionary<string, IRoutingRule> name2Rule = new Dictionary<string, IRoutingRule>();
  30                 private readonly ReaderWriterLock locker = new ReaderWriterLock();
  31
  32                 /// <summary>
  33                 /// Adds the specified rule.
  34                 /// </summary>
  35                 /// <param name="rule">The rule.</param>
  36                 public void Add(IRoutingRule rule)
  37                 {
  38                         // Lock for writing
  39                         rules.Add(new DecoratedRule(rule));
  40
  41                         // For really fast access
  42                         if (rule.RouteName != null)
  43                         {
  44                                 if (name2Rule.ContainsKey(rule.RouteName))
  45                                 {
  46                                         throw new InvalidOperationException("Attempt to register route with duplicated name: " + rule.RouteName);
  47                                 }
  48
  49                                 name2Rule[rule.RouteName] = rule;
  50                         }
  51                 }
  52
  53                 /// <summary>
  54                 /// Pendent
  55                 /// </summary>
  56                 public void Add(IRoutingRule rule, RouteAction action)
  57                 {
  58                         // Lock for writing
  59                         rules.Add(new DecoratedRule(rule, action));
  60                 }
  61
  62                 /// <summary>
  63                 /// Creates the URL.
  64                 /// </summary>
  65                 /// <param name="routeName">Name of the route.</param>
  66                 /// <param name="hostname">The hostname.</param>
  67                 /// <param name="virtualPath">The virtual path.</param>
  68                 /// <param name="parameters">The parameters.</param>
  69                 /// <returns></returns>
  70                 public string CreateUrl(string routeName, string hostname, string virtualPath, IDictionary parameters)
  71                 {
  72                         // lock for reading
  73
  74                         IRoutingRule rule;
  75
  76                         if (!name2Rule.TryGetValue(routeName, out rule))
  77                         {
  78                                 throw new MonoRailException("Could not find named route: " + routeName);
  79                         }
  80
  81                         int points;
  82                         return rule.CreateUrl(hostname, virtualPath, parameters, out points);
  83                 }
  84
  85                 /// <summary>
  86                 /// Pendent
  87                 /// </summary>
  88                 /// <param name="hostname">The hostname.</param>
  89                 /// <param name="virtualPath">The virtual path.</param>
  90                 /// <param name="parameters">The parameters.</param>
  91                 /// <returns></returns>
  92                 public string CreateUrl(string hostname, string virtualPath, IDictionary parameters)
  93                 {
  94                         int winnerPoints = 0;
  95                         string winnerUrl = null;
  96
  97                         foreach(IRoutingRule rule in rules)
  98                         {
  99                                 int points;
 100
 101                                 string url = rule.CreateUrl(hostname, virtualPath, parameters, out points);
 102
 103                                 if (url != null && points > winnerPoints)
 104                                 {
 105                                         winnerUrl = url;
 106                                         winnerPoints = points;
 107                                 }
 108                         }
 109
 110                         return winnerUrl;
 111                 }
 112
 113                 /// <summary>
 114                 /// Pendent
 115                 /// </summary>
 116                 /// <param name="hostname">The hostname.</param>
 117                 /// <param name="virtualPath">The virtual path.</param>
 118                 /// <param name="parameters">The parameters.</param>
 119                 /// <returns></returns>
 120                 public string CreateUrl(string hostname, string virtualPath, object parameters)
 121                 {
 122                         return CreateUrl(hostname, virtualPath, new ReflectionBasedDictionaryAdapter(parameters));
 123                 }
 124
 125                 /// <summary>
 126                 /// Finds the match.
 127                 /// </summary>
 128                 /// <param name="url">The URL.</param>
 129                 /// <param name="context">The context.</param>
 130                 /// <returns></returns>
 131                 public RouteMatch FindMatch(string url, IRouteContext context)
 132                 {
 133                         // lock for reading
 134
 135                         int winnerPoints = 0;
 136                         RouteMatch winner = null;
 137                         DecoratedRule winnerule = null;
 138
 139                         foreach(DecoratedRule rule in rules)
 140                         {
 141                                 RouteMatch match = new RouteMatch();
 142
 143                                 int points = rule.Matches(url, context, match);
 144
 145                                 if (points != 0 && points > winnerPoints)
 146                                 {
 147                                         winnerPoints = points;
 148                                         winner = match;
 149                                         winnerule = rule;
 150                                 }
 151                         }
 152
 153                         if (winner != null && winnerule.SelectionAction != null)
 154                         {
 155                                 winnerule.SelectionAction(context, winner);
 156                         }
 157
 158                         return winner;
 159                 }
 160
 161                 /// <summary>
 162                 /// Gets a value indicating whether this container is empty.
 163                 /// </summary>
 164                 /// <value><c>true</c> if this instance is empty; otherwise, <c>false</c>.</value>
 165                 public bool IsEmpty
 166                 {
 167                         get { return rules.Count == 0; }
 168                 }
 169
 170                 class DecoratedRule : IRoutingRule
 171                 {
 172                         private readonly IRoutingRule inner;
 173                         private RouteAction selectionAction;
 174
 175                         public DecoratedRule(IRoutingRule inner)
 176                         {
 177                                 this.inner = inner;
 178                         }
 179
 180                         public DecoratedRule(IRoutingRule inner, RouteAction selectionAction) : this(inner)
 181                         {
 182                                 this.selectionAction = selectionAction;
 183                         }
 184
 185                         public string CreateUrl(string hostname, string virtualPath, IDictionary parameters, out int points)
 186                         {
 187                                 return inner.CreateUrl(hostname, virtualPath, parameters, out points);
 188                         }
 189
 190                         public int Matches(string url, IRouteContext context, RouteMatch match)
 191                         {
 192                                 return inner.Matches(url, context, match);
 193                         }
 194
 195                         public string RouteName
 196                         {
 197                                 get { return inner.RouteName; }
 198                         }
 199
 200                         public RouteAction SelectionAction
 201                         {
 202                                 get { return selectionAction; }
 203                         }
 204                 }
 205         }
 206 }