Components/General/Validator/Castle.Components.Validator/ValidatorRunner.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.Components.Validator
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Reflection;
  20
  21         /// <summary>
  22         /// Coordinates the gathering and execution of validators.
  23         /// <seealso cref="IValidatorRegistry"/>
  24         /// </summary>
  25         /// <example>
  26         /// ValidatorRunner runner = new ValidatorRunner(new CachedValidationRegistry());
  27         ///
  28         /// if (!runner.IsValid(customer))
  29         /// {
  30         ///             // do something as the Customer instance is not valid
  31         /// }
  32         /// </example>
  33         public class ValidatorRunner
  34         {
  35                 private readonly static IDictionary type2Validator;
  36             private readonly IDictionary extendedProperties = new Hashtable();
  37                 private readonly bool inferValidators;
  38                 private readonly IDictionary errorPerInstance;
  39                 private readonly IValidatorRegistry registry;
  40
  41                 static ValidatorRunner()
  42                 {
  43                         type2Validator = new Hashtable();
  44                         type2Validator[typeof(Int16)] = typeof(IntegerValidator);
  45                         type2Validator[typeof(Int32)] = typeof(IntegerValidator);
  46                         type2Validator[typeof(Int64)] = typeof(IntegerValidator);
  47                         type2Validator[typeof(decimal)] = typeof(DecimalValidator);
  48                         type2Validator[typeof(Single)] = typeof(SingleValidator);
  49                         type2Validator[typeof(double)] = typeof(DoubleValidator);
  50                         type2Validator[typeof(DateTime)] = typeof(DateTimeValidator);
  51                 }
  52
  53             public IDictionary ExtendedProperties
  54             {
  55                 get { return extendedProperties; }
  56             }
  57
  58             /// <summary>
  59                 /// Initializes a new instance of the <see cref="ValidatorRunner"/> class.
  60                 /// </summary>
  61                 /// <param name="registry">The instance registry.</param>
  62                 public ValidatorRunner(IValidatorRegistry registry) : this(true, registry)
  63                 {
  64                 }
  65
  66                 /// <summary>
  67                 /// Initializes a new instance of the <see cref="ValidatorRunner"/> class.
  68                 /// </summary>
  69                 /// <param name="inferValidators">if <c>true</c>, the runner will try
  70                 /// to infer un-declared validators based on property types</param>
  71                 /// <param name="registry">The registry.</param>
  72                 public ValidatorRunner(bool inferValidators, IValidatorRegistry registry)
  73                 {
  74                         if (registry == null) throw new ArgumentNullException("registry");
  75
  76                         errorPerInstance = new Hashtable();
  77
  78                         this.inferValidators = inferValidators;
  79                         this.registry = registry;
  80                 }
  81
  82                 /// <summary>
  83                 /// Determines whether the specified instance is valid.
  84                 /// <para>
  85                 /// All validators are run.
  86                 /// </para>
  87                 /// </summary>
  88                 /// <param name="objectInstance">The object instance to be validated (cannot be null).</param>
  89                 /// <returns>
  90                 ///     <see langword="true"/> if the specified obj is valid; otherwise, <see langword="false"/>.
  91                 /// </returns>
  92                 public bool IsValid(object objectInstance)
  93                 {
  94                         return IsValid(objectInstance, RunWhen.Everytime);
  95                 }
  96
  97                 /// <summary>
  98                 /// Determines whether the specified instance is valid.
  99                 /// <para>
 100                 /// All validators are run for the specified <see cref="RunWhen"/> phase.
 101                 /// </para>
 102                 /// </summary>
 103                 /// <param name="objectInstance">The object instance to be validated (cannot be null).</param>
 104                 /// <param name="runWhen">Restrict the set returned to the phase specified</param>
 105                 /// <returns>
 106                 /// <see langword="true"/> if the specified instance is valid; otherwise, <see langword="false"/>.
 107                 /// </returns>
 108                 public bool IsValid(object objectInstance, RunWhen runWhen)
 109                 {
 110                         if (objectInstance == null) throw new ArgumentNullException("objectInstance");
 111
 112                         bool isValid = true;
 113
 114                         ErrorSummary summary = new ErrorSummary();
 115
 116                         foreach(IValidator validator in GetValidators(objectInstance, runWhen))
 117                         {
 118                                 if (!validator.IsValid(objectInstance))
 119                                 {
 120                                         summary.RegisterErrorMessage(validator.Name, validator.ErrorMessage);
 121
 122                                         isValid = false;
 123                                 }
 124                         }
 125
 126                         errorPerInstance[objectInstance] = summary;
 127
 128                         return isValid;
 129                 }
 130
 131                 /// <summary>
 132                 /// Gets the registered validators.
 133                 /// </summary>
 134                 /// <param name="parentType">Type of the parent.</param>
 135                 /// <param name="property">The property.</param>
 136                 /// <returns></returns>
 137                 public IValidator[] GetValidators(Type parentType, PropertyInfo property)
 138                 {
 139                         return GetValidators(parentType, property, RunWhen.Everytime);
 140                 }
 141
 142                 /// <summary>
 143                 /// Gets the registered validators.
 144                 /// </summary>
 145                 /// <param name="parentType">Type of the parent.</param>
 146                 /// <param name="property">The property.</param>
 147                 /// <param name="runWhenPhase">The run when phase.</param>
 148                 /// <returns></returns>
 149                 public IValidator[] GetValidators(Type parentType, PropertyInfo property, RunWhen runWhenPhase)
 150                 {
 151                         if (parentType == null) throw new ArgumentNullException("parentType");
 152                         if (property == null) throw new ArgumentNullException("property");
 153
 154                         IValidator[] validators = registry.GetValidators(this, parentType, property, runWhenPhase);
 155
 156                         if (inferValidators && validators.Length == 0)
 157                         {
 158                                 Type defaultValidatorForType = (Type) type2Validator[property.PropertyType];
 159
 160                                 if (defaultValidatorForType != null)
 161                                 {
 162                                         validators = new IValidator[] { (IValidator) Activator.CreateInstance(defaultValidatorForType) };
 163
 164                                         validators[0].Initialize(property);
 165                                 }
 166                         }
 167
 168                         Array.Sort(validators, ValidatorComparer.Instance);
 169
 170                         return validators;
 171                 }
 172
 173                 /// <summary>
 174                 /// Gets the error list per instance.
 175                 /// </summary>
 176                 /// <param name="instance">The instance.</param>
 177                 /// <returns></returns>
 178                 public bool HasErrors(object instance)
 179                 {
 180                         ErrorSummary summary = (ErrorSummary) errorPerInstance[instance];
 181
 182                         if (summary == null) return false;
 183
 184                         return summary.ErrorsCount != 0;
 185                 }
 186
 187                 /// <summary>
 188                 /// Gets the error list per instance.
 189                 /// </summary>
 190                 /// <param name="instance">The instance.</param>
 191                 /// <returns></returns>
 192                 public ErrorSummary GetErrorSummary(object instance)
 193                 {
 194                         return (ErrorSummary) errorPerInstance[instance];
 195                 }
 196
 197                 private IValidator[] GetValidators(object objectInstance, RunWhen runWhen)
 198                 {
 199                         if (objectInstance == null) throw new ArgumentNullException("objectInstance");
 200
 201                         IValidator[] validators = registry.GetValidators(this, objectInstance.GetType(), runWhen);
 202
 203                         Array.Sort(validators, ValidatorComparer.Instance);
 204
 205                         return validators;
 206                 }
 207
 208                 class ValidatorComparer : IComparer
 209                 {
 210                         private readonly static ValidatorComparer instance = new ValidatorComparer();
 211
 212                         public int Compare(object x, object y)
 213                         {
 214                                 IValidator left = (IValidator) x;
 215                                 IValidator right = (IValidator) y;
 216
 217                                 return left.ExecutionOrder - right.ExecutionOrder;
 218                         }
 219
 220                         public static ValidatorComparer Instance
 221                         {
 222                                 get { return instance; }
 223                         }
 224                 }
 225         }
 226 }