Components/Binder/Castle.Components.Binder/DataBinder.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.Components.Binder
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.ComponentModel;
  21         using System.Reflection;
  22         using System.Web;
  23         using Castle.Components.Validator;
  24         using Castle.Core;
  25         using Castle.Core.Logging;
  26
  27         /// <summary>
  28         /// </summary>
  29         [Serializable]
  30         public class DataBinder : MarshalByRefObject, IDataBinder, IServiceEnabledComponent
  31         {
  32                 protected internal static readonly BindingFlags PropertiesBindingFlags =
  33                         BindingFlags.Instance | BindingFlags.Public;
  34
  35                 private IConverter converter = new DefaultConverter();
  36
  37                 private ValidatorRunner validator;
  38
  39                 /// <summary>Collect the databind errors</summary>
  40                 protected IList errors;
  41
  42                 /// <summary>Holds a sorted array of properties names that should be ignored</summary>
  43                 private string[] excludedPropertyList;
  44
  45                 /// <summary>Holds a sorted array of properties names that are on the white list</summary>
  46                 private string[] allowedPropertyList;
  47
  48                 private Stack instanceStack;
  49                 private Stack<string> prefixStack;
  50
  51                 private IDictionary<object, ErrorSummary> validationErrorSummaryPerInstance = new Dictionary<object, ErrorSummary>();
  52
  53                 private IBinderTranslator binderTranslator;
  54
  55                 private ILogger logger = NullLogger.Instance;
  56
  57                 public event BinderHandler OnBeforeBinding;
  58
  59                 public event BinderHandler OnAfterBinding;
  60
  61                 /// <summary>
  62                 /// Initializes a new instance of the <see cref="DataBinder"/> class.
  63                 /// </summary>
  64                 public DataBinder()
  65                 {
  66                 }
  67
  68                 #region IServiceEnabledComponent
  69
  70                 public void Service(IServiceProvider provider)
  71                 {
  72                         ILoggerFactory loggerFactory = (ILoggerFactory) provider.GetService(typeof(ILoggerFactory));
  73
  74                         if (loggerFactory != null)
  75                         {
  76                                 logger = loggerFactory.Create(typeof(DataBinder));
  77                         }
  78                 }
  79
  80                 #endregion
  81
  82                 #region IDataBinder
  83
  84                 public bool CanBindParameter(Type desiredType, String paramName, CompositeNode treeRoot)
  85                 {
  86                         bool canConvert;
  87
  88                         Node childNode = treeRoot.GetChildNode(paramName);
  89
  90                         if (childNode != null)
  91                         {
  92                                 canConvert = true;
  93                         }
  94                         else if (desiredType == typeof(DateTime))
  95                         {
  96                                 TrySpecialDateTimeBinding(desiredType, treeRoot, paramName, out canConvert);
  97                         }
  98                         else
  99                         {
 100                                 canConvert = false;
 101                         }
 102
 103                         return canConvert;
 104                 }
 105
 106                 public bool CanBindObject(Type targetType, String prefix, CompositeNode treeRoot)
 107                 {
 108                         Node childNode = treeRoot.GetChildNode(prefix);
 109
 110                         return childNode != null;
 111                 }
 112
 113                 public object BindParameter(Type desiredType, String paramName, CompositeNode treeRoot)
 114                 {
 115                         bool conversionSucceeded;
 116                         object result;
 117
 118                         try
 119                         {
 120                                 if (desiredType.IsArray)
 121                                 {
 122                                         Node childNode = treeRoot.GetChildNode(paramName);
 123
 124                                         result = ConvertToArray(desiredType, paramName, childNode, out conversionSucceeded);
 125                                 }
 126                                 else
 127                                 {
 128                                         result = ConvertToSimpleValue(desiredType, paramName, treeRoot, out conversionSucceeded);
 129                                 }
 130                         }
 131                         catch(Exception ex)
 132                         {
 133                                 // Something unexpected during convertion
 134                                 // throw new exception with paramName specified
 135
 136                                 throw new BindingException(
 137                                         "Exception converting param '" + paramName + "' to " + desiredType + ". Check inner exception for details", ex);
 138                         }
 139
 140                         return result;
 141                 }
 142
 143                 public object BindObject(Type targetType, string prefix, CompositeNode treeRoot)
 144                 {
 145                         return BindObject(targetType, prefix, null, null, treeRoot);
 146                 }
 147
 148                 public object BindObject(Type targetType, string prefix, string excludedProperties, string allowedProperties,
 149                                          CompositeNode treeRoot)
 150                 {
 151                         if (targetType == null)
 152                         {
 153                                 throw new ArgumentNullException("targetType");
 154                         }
 155                         if (prefix == null)
 156                         {
 157                                 throw new ArgumentNullException("prefix");
 158                         }
 159                         if (treeRoot == null)
 160                         {
 161                                 throw new ArgumentNullException("treeRoot");
 162                         }
 163
 164                         errors = new ArrayList();
 165                         instanceStack = new Stack();
 166                         prefixStack = new Stack<string>();
 167
 168                         excludedPropertyList = CreateNormalizedList(excludedProperties);
 169                         allowedPropertyList = CreateNormalizedList(allowedProperties);
 170
 171                         return InternalBindObject(targetType, prefix, treeRoot.GetChildNode(prefix));
 172                 }
 173
 174                 public void BindObjectInstance(object instance, string prefix, CompositeNode treeRoot)
 175                 {
 176                         BindObjectInstance(instance, prefix, null, null, treeRoot);
 177                 }
 178
 179                 public void BindObjectInstance(object instance, string prefix, string excludedProperties, string allowedProperties,
 180                                                CompositeNode treeRoot)
 181                 {
 182                         if (instance == null)
 183                         {
 184                                 throw new ArgumentNullException("instance");
 185                         }
 186                         if (prefix == null)
 187                         {
 188                                 throw new ArgumentNullException("prefix");
 189                         }
 190                         if (treeRoot == null)
 191                         {
 192                                 throw new ArgumentNullException("treeRoot");
 193                         }
 194
 195                         errors = new ArrayList();
 196                         instanceStack = new Stack();
 197                         prefixStack = new Stack<string>();
 198
 199                         excludedPropertyList = CreateNormalizedList(excludedProperties);
 200                         allowedPropertyList = CreateNormalizedList(allowedProperties);
 201
 202                         InternalRecursiveBindObjectInstance(instance, prefix, treeRoot.GetChildNode(prefix));
 203                 }
 204
 205                 /// <summary>
 206                 /// Represents the databind errors
 207                 /// </summary>
 208                 public ErrorList ErrorList
 209                 {
 210                         get { return new ErrorList(errors); }
 211                 }
 212
 213                 public IConverter Converter
 214                 {
 215                         get { return converter; }
 216                         set { converter = value; }
 217                 }
 218
 219                 public ValidatorRunner Validator
 220                 {
 221                         get { return validator; }
 222                         set { validator = value; }
 223                 }
 224
 225                 public IBinderTranslator Translator
 226                 {
 227                         get { return binderTranslator; }
 228                         set { binderTranslator = value; }
 229                 }
 230
 231                 /// <summary>
 232                 /// Gets the validation error summary.
 233                 /// </summary>
 234                 /// <param name="instance">The instance.</param>
 235                 public ErrorSummary GetValidationSummary(object instance)
 236                 {
 237                         return validationErrorSummaryPerInstance.ContainsKey(instance) ? validationErrorSummaryPerInstance[instance] : null;
 238                 }
 239
 240                 #endregion
 241
 242                 #region Implementation
 243
 244                 protected object InternalBindObject(Type instanceType, String paramPrefix, Node node)
 245                 {
 246                         bool succeeded;
 247                         return InternalBindObject(instanceType, paramPrefix, node, out succeeded);
 248                 }
 249
 250                 protected object InternalBindObject(Type instanceType, String paramPrefix, Node node, out bool succeeded)
 251                 {
 252                         succeeded = false;
 253
 254                         if (IsSpecialType(instanceType))
 255                         {
 256                                 return BindSpecialObjectInstance(instanceType, paramPrefix, node, out succeeded);
 257                         }
 258
 259                         if (ShouldIgnoreType(instanceType))
 260                         {
 261                                 return null;
 262                         }
 263
 264                         if (instanceType.IsArray)
 265                         {
 266                                 return InternalBindObjectArray(instanceType, paramPrefix, node, out succeeded);
 267                         }
 268                         else if (IsGenericList(instanceType))
 269                         {
 270                                 return InternalBindGenericList(instanceType, paramPrefix, node, out succeeded);
 271                         }
 272                         else
 273                         {
 274                                 succeeded = true;
 275                                 object instance = CreateInstance(instanceType, paramPrefix, node);
 276                                 InternalRecursiveBindObjectInstance(instance, paramPrefix, node);
 277                                 return instance;
 278                         }
 279                 }
 280
 281                 protected void InternalRecursiveBindObjectInstance(object instance, String prefix, Node node)
 282                 {
 283                         if (node == null)
 284                         {
 285                                 return;
 286                         }
 287
 288                         if (node.NodeType != NodeType.Composite && node.NodeType != NodeType.Indexed)
 289                         {
 290                                 throw new BindingException(
 291                                         "Non-composite node passed to InternalRecursiveBindObjectInstance while binding {0} with prefix {1}", instance,
 292                                         prefix);
 293                         }
 294
 295                         InternalRecursiveBindObjectInstance(instance, prefix, (CompositeNode) node);
 296                 }
 297
 298                 protected void InternalRecursiveBindObjectInstance(object instance, String prefix, CompositeNode node)
 299                 {
 300                         if (node == null || instance == null)
 301                         {
 302                                 return;
 303                         }
 304
 305                         BeforeBinding(instance, prefix, node);
 306
 307                         if (PerformCustomBinding(instance, prefix, node))
 308                         {
 309                                 return;
 310                         }
 311
 312                         PushInstance(instance, prefix);
 313
 314                         ErrorSummary summary = new ErrorSummary();
 315
 316                         validationErrorSummaryPerInstance[instance] = summary;
 317
 318                         Type instanceType = instance.GetType();
 319
 320                         PropertyInfo[] props = instanceType.GetProperties(PropertiesBindingFlags);
 321
 322                         string nodeFullName = node.FullName;
 323
 324                         foreach(PropertyInfo prop in props)
 325                         {
 326                                 if (ShouldIgnoreProperty(prop, nodeFullName))
 327                                 {
 328                                         continue;
 329                                 }
 330
 331                                 Type propType = prop.PropertyType;
 332                                 String paramName = prop.Name;
 333
 334                                 String translatedParamName = Translate(instanceType, paramName);
 335
 336                                 if (translatedParamName == null)
 337                                 {
 338                                         continue;
 339                                 }
 340
 341                                 bool isSimpleProperty = IsSimpleProperty(propType);
 342
 343                                 // There are some caveats by running the validators here.
 344                                 // We should follow the validator's execution order...
 345                                 if (isSimpleProperty)
 346                                 {
 347                                         if (CheckForValidationFailures(instance, instanceType, prop, node, translatedParamName, prefix, summary))
 348                                         {
 349                                                 continue;
 350                                         }
 351                                 }
 352
 353                                 BeforeBindingProperty(instance, prop, prefix, node);
 354
 355                                 try
 356                                 {
 357                                         bool conversionSucceeded;
 358
 359                                         if (isSimpleProperty)
 360                                         {
 361                                                 object value = ConvertToSimpleValue(propType, translatedParamName, node, out conversionSucceeded);
 362
 363                                                 if (conversionSucceeded)
 364                                                 {
 365                                                         SetPropertyValue(instance, prop, value);
 366                                                 }
 367                                         }
 368                                         else
 369                                         {
 370                                                 // if the property is an object, we look if it is already instanciated
 371                                                 object value = prop.GetValue(instance, null);
 372
 373                                                 Node nestedNode = node.GetChildNode(paramName);
 374
 375                                                 if (nestedNode != null)
 376                                                 {
 377                                                         if (ShouldRecreateInstance(value, propType, paramName, nestedNode))
 378                                                         {
 379                                                                 value = InternalBindObject(propType, paramName, nestedNode, out conversionSucceeded);
 380
 381                                                                 if (conversionSucceeded)
 382                                                                 {
 383                                                                         SetPropertyValue(instance, prop, value);
 384                                                                 }
 385                                                         }
 386                                                         else
 387                                                         {
 388                                                                 InternalRecursiveBindObjectInstance(value, paramName, nestedNode);
 389                                                         }
 390                                                 }
 391
 392                                                 CheckForValidationFailures(instance, instanceType, prop, value, translatedParamName, prefix, summary);
 393                                         }
 394                                 }
 395                                 catch(Exception ex)
 396                                 {
 397                                         errors.Add(new DataBindError(prefix, prop.Name, ex));
 398                                 }
 399                         }
 400
 401                         PopInstance(instance, prefix);
 402
 403                         AfterBinding(instance, prefix, node);
 404                 }
 405
 406                 /// <summary>
 407                 /// Sets the property value of the object we are binding.
 408                 /// Databinders that require different ways to access properties
 409                 /// can override this method.
 410                 /// </summary>
 411                 /// <param name="instance"></param>
 412                 /// <param name="prop"></param>
 413                 /// <param name="value"></param>
 414                 protected virtual void SetPropertyValue(object instance, PropertyInfo prop, object value)
 415                 {
 416                         if (!prop.CanWrite)
 417                         {
 418                                 return;
 419                         }
 420                         prop.SetValue(instance, value, null);
 421                 }
 422
 423                 protected bool CheckForValidationFailures(object instance, Type instanceType,
 424                                                           PropertyInfo prop, CompositeNode node,
 425                                                           string name, string prefix,
 426                                                           ErrorSummary summary)
 427                 {
 428                         object value = null;
 429
 430                         if (validator == null)
 431                         {
 432                                 return false;
 433                         }
 434
 435                         IValidator[] validators = validator.GetValidators(instanceType, prop);
 436
 437                         if (validators.Length != 0)
 438                         {
 439                                 Node valNode = node.GetChildNode(name);
 440
 441                                 if (valNode != null && valNode.NodeType == NodeType.Leaf)
 442                                 {
 443                                         value = ((LeafNode)valNode).Value;
 444                                 }
 445
 446                                 if (value == null && IsDateTimeType(prop.PropertyType))
 447                                 {
 448                                         bool conversionSucceeded;
 449                                         value = TryGetDateWithUTCFormat(node, name, out conversionSucceeded);
 450                                 }
 451
 452                                 if (value == null && valNode == null)
 453                                 {
 454                                         // Value was not present on the data source. Skip validation
 455                                         return false;
 456                                 }
 457                         }
 458
 459                         return CheckForValidationFailures(instance, instanceType, prop, value, name, prefix, summary);
 460                 }
 461
 462                 protected bool CheckForValidationFailures(object instance, Type instanceType,
 463                                                           PropertyInfo prop, object value,
 464                                                           string name, string prefix,
 465                                                           ErrorSummary summary)
 466                 {
 467                         bool hasFailure = false;
 468
 469                         if (validator == null)
 470                         {
 471                                 return false;
 472                         }
 473
 474                         IValidator[] validators = validator.GetValidators(instanceType, prop);
 475
 476                         foreach(IValidator validatorItem in validators)
 477                         {
 478                                 if (!validatorItem.IsValid(instance, value))
 479                                 {
 480                                         string propName = validatorItem.FriendlyName ?? validatorItem.Name;
 481
 482                                         errors.Add(new DataBindError(prefix, prop.Name, validatorItem.ErrorMessage));
 483
 484                                         summary.RegisterErrorMessage(propName, validatorItem.ErrorMessage);
 485
 486                                         hasFailure = true;
 487                                 }
 488                         }
 489
 490                         return hasFailure;
 491                 }
 492
 493                 protected int StackDepth
 494                 {
 495                         get { return instanceStack.Count; }
 496                 }
 497
 498                 private string Translate(Type instanceType, string paramName)
 499                 {
 500                         if (binderTranslator != null)
 501                         {
 502                                 return binderTranslator.Translate(instanceType, paramName);
 503                         }
 504
 505                         return paramName;
 506                 }
 507
 508                 private object InternalBindObjectArray(Type instanceType, String paramPrefix, Node node, out bool succeeded)
 509                 {
 510                         succeeded = false;
 511
 512                         if (node == null)
 513                         {
 514                                 return Array.CreateInstance(instanceType.GetElementType(), 0);
 515                         }
 516
 517                         return ConvertToArray(instanceType, paramPrefix, node, out succeeded);
 518                 }
 519
 520                 internal static bool IsGenericList(Type instanceType)
 521                 {
 522                         if (!instanceType.IsGenericType)
 523                         {
 524                                 return false;
 525                         }
 526                         if (typeof(IList).IsAssignableFrom(instanceType))
 527                         {
 528                                 return true;
 529                         }
 530
 531                         Type[] genericArgs = instanceType.GetGenericArguments();
 532
 533                         if (genericArgs.Length == 0)
 534                         {
 535                                 return false;
 536                         }
 537                         Type listType = typeof(IList<>).MakeGenericType(genericArgs[0]);
 538                         return listType.IsAssignableFrom(instanceType);
 539                 }
 540
 541                 private object InternalBindGenericList(Type instanceType, string paramPrefix, Node node, out bool succeeded)
 542                 {
 543                         succeeded = false;
 544
 545                         if (node == null)
 546                         {
 547                                 return CreateInstance(instanceType, paramPrefix, node);
 548                         }
 549
 550                         return ConvertToGenericList(instanceType, paramPrefix, node, out succeeded);
 551                 }
 552
 553                 #endregion
 554
 555                 #region CreateInstance
 556
 557                 protected virtual object CreateInstance(Type instanceType, String paramPrefix, Node node)
 558                 {
 559                         const BindingFlags creationFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
 560
 561                         return Activator.CreateInstance(instanceType, creationFlags, null, null, null);
 562                 }
 563
 564                 #endregion
 565
 566                 #region Overridables
 567
 568                 protected virtual void AfterBinding(object instance, String prefix, Node node)
 569                 {
 570                         if (OnAfterBinding != null)
 571                         {
 572                                 OnAfterBinding(instance, prefix, node);
 573                         }
 574                 }
 575
 576                 protected virtual void BeforeBinding(object instance, String prefix, Node node)
 577                 {
 578                         if (OnBeforeBinding != null)
 579                         {
 580                                 OnBeforeBinding(instance, prefix, node);
 581                         }
 582                 }
 583
 584                 protected virtual void BeforeBindingProperty(object instance, PropertyInfo prop, string prefix, CompositeNode node)
 585                 {
 586                 }
 587
 588                 protected virtual bool ShouldRecreateInstance(object value, Type type, String prefix, Node node)
 589                 {
 590                         return value == null || type.IsArray || IsGenericList(type);
 591                 }
 592
 593                 protected virtual bool ShouldIgnoreType(Type instanceType)
 594                 {
 595                         bool ignore = instanceType.IsAbstract || instanceType.IsInterface;
 596
 597                         if (ignore && instanceType.IsGenericType)
 598                         {
 599                                 ignore = !IsGenericList(instanceType);
 600                         }
 601
 602                         return ignore;
 603                 }
 604
 605                 protected virtual bool PerformCustomBinding(object instance, string prefix, Node node)
 606                 {
 607                         return false;
 608                 }
 609
 610                 /// <summary>
 611                 /// Implementations will bound the instance itself.
 612                 /// <seealso cref="IsSpecialType"/>
 613                 /// </summary>
 614                 /// <remarks>
 615                 /// <seealso cref="IsSpecialType"/>
 616                 /// </remarks>
 617                 /// <param name="instanceType"></param>
 618                 /// <param name="prefix"></param>
 619                 /// <param name="node"></param>
 620                 /// <param name="succeeded"></param>
 621                 protected virtual object BindSpecialObjectInstance(Type instanceType, String prefix,
 622                                                                    Node node, out bool succeeded)
 623                 {
 624                         succeeded = false;
 625
 626                         return null;
 627                 }
 628
 629                 /// <summary>
 630                 /// Invoked during object binding to allow
 631                 /// subclasses to have a chance of binding the types itself.
 632                 /// If the implementation returns <c>true</c>
 633                 /// the binder will invoke <see cref="BindSpecialObjectInstance"/>
 634                 /// </summary>
 635                 /// <param name="instanceType">Type about to be bound</param>
 636                 /// <returns><c>true</c> if subclass wants to handle binding</returns>
 637                 protected virtual bool IsSpecialType(Type instanceType)
 638                 {
 639                         return false;
 640                 }
 641
 642                 #endregion
 643
 644                 protected ILogger Logger
 645                 {
 646                         get { return logger; }
 647                 }
 648
 649                 protected object ConvertLeafNode(Type desiredType, LeafNode lNode, out bool conversionSucceeded)
 650                 {
 651                         return Converter.Convert(desiredType, lNode.ValueType, lNode.Value, out conversionSucceeded);
 652                 }
 653
 654                 private object ConvertToSimpleValue(Type desiredType, string key, CompositeNode parent, out bool conversionSucceeded)
 655                 {
 656                         conversionSucceeded = false;
 657
 658                         Node childNode = parent.GetChildNode(key);
 659
 660                         if (childNode == null && IsDateTimeType(desiredType))
 661                         {
 662                                 return TrySpecialDateTimeBinding(desiredType, parent, key, out conversionSucceeded);
 663                         }
 664                         else if (childNode == null)
 665                         {
 666                                 return null;
 667                         }
 668                         else if (childNode.NodeType == NodeType.Leaf)
 669                         {
 670                                 return ConvertLeafNode(desiredType, (LeafNode) childNode, out conversionSucceeded);
 671                         }
 672                         else
 673                         {
 674                                 throw new BindingException("Could not convert param as the node related " +
 675                                                            "to the param is not a leaf node. Param {0} parent node: {1}", key, parent.Name);
 676                         }
 677                 }
 678
 679                 private object ConvertToArray(Type desiredType, String key, Node node, out bool conversionSucceeded)
 680                 {
 681                         Type elemType = desiredType.GetElementType();
 682
 683                         if (node == null)
 684                         {
 685                                 conversionSucceeded = false;
 686                                 return Array.CreateInstance(elemType, 0);
 687                         }
 688                         else if (node.NodeType == NodeType.Leaf)
 689                         {
 690                                 LeafNode leafNode = node as LeafNode;
 691
 692                                 return Converter.Convert(desiredType, leafNode.ValueType, leafNode.Value, out conversionSucceeded);
 693                         }
 694                         else if (node.NodeType == NodeType.Indexed)
 695                         {
 696                                 IndexedNode indexedNode = node as IndexedNode;
 697
 698                                 if (IsSimpleProperty(elemType))
 699                                 {
 700                                         return ConvertFlatNodesToArray(desiredType, indexedNode.ChildNodes, out conversionSucceeded);
 701                                 }
 702                                 else
 703                                 {
 704                                         return ConvertComplexNodesToArray(desiredType, indexedNode, out conversionSucceeded);
 705                                 }
 706                         }
 707                         else
 708                         {
 709                                 throw new BindingException("Could not convert param to array as the node related " +
 710                                                            "to the param is not a leaf node nor an indexed node. Key {0}", key);
 711                         }
 712                 }
 713
 714                 private object ConvertComplexNodesToArray(Type desiredType, IndexedNode parent, out bool conversionSucceeded)
 715                 {
 716                         Type arrayElemType = desiredType.GetElementType();
 717
 718                         ArrayList validItems = ConvertComplexNodesToList(arrayElemType, parent, out conversionSucceeded);
 719
 720                         return conversionSucceeded ? validItems.ToArray(arrayElemType) : Array.CreateInstance(arrayElemType, 0);
 721                 }
 722
 723                 private ArrayList ConvertComplexNodesToList(Type elemType, IndexedNode parent, out bool conversionSucceeded)
 724                 {
 725                         conversionSucceeded = true;
 726
 727                         ArrayList validItems = new ArrayList();
 728
 729                         foreach(Node node in parent.ChildNodes)
 730                         {
 731                                 if (node.NodeType == NodeType.Composite)
 732                                 {
 733                                         CompositeNode lnode = node as CompositeNode;
 734
 735                                         validItems.Add(InternalBindObject(elemType, parent.Name, lnode, out conversionSucceeded));
 736
 737                                         if (!conversionSucceeded)
 738                                         {
 739                                                 break;
 740                                         }
 741                                 }
 742                         }
 743
 744                         return validItems;
 745                 }
 746
 747                 private object ConvertFlatNodesToArray(Type desiredType, Node[] nodes, out bool conversionSucceeded)
 748                 {
 749                         Type arrayElemType = desiredType.GetElementType();
 750
 751                         ArrayList validItems = ConvertFlatNodesToList(arrayElemType, nodes, out conversionSucceeded);
 752
 753                         return conversionSucceeded ? validItems.ToArray(arrayElemType) : Array.CreateInstance(arrayElemType, 0);
 754                 }
 755
 756                 private ArrayList ConvertFlatNodesToList(Type elemType, Node[] nodes, out bool conversionSucceeded)
 757                 {
 758                         conversionSucceeded = true;
 759
 760                         ArrayList validItems = new ArrayList();
 761
 762                         foreach(Node node in nodes)
 763                         {
 764                                 if (node.Name != String.Empty)
 765                                 {
 766                                         throw new BindingException("Unexpected non-flat node found: {0}", node.Name);
 767                                 }
 768
 769                                 if (node.NodeType == NodeType.Leaf)
 770                                 {
 771                                         LeafNode lnode = node as LeafNode;
 772
 773                                         validItems.Add(ConvertLeafNode(elemType, lnode, out conversionSucceeded));
 774
 775                                         if (!conversionSucceeded)
 776                                         {
 777                                                 break;
 778                                         }
 779                                 }
 780                         }
 781
 782                         return validItems;
 783                 }
 784
 785                 private object ConvertToGenericList(Type desiredType, String key, Node node, out bool conversionSucceeded)
 786                 {
 787                         Type[] genericArgs = desiredType.GetGenericArguments();
 788
 789                         if (genericArgs.Length == 0)
 790                         {
 791                                 throw new BindingException("Can't infer the Generics placeholders (type parameters). Key {0}.", key);
 792                         }
 793
 794                         Type elemType = genericArgs[0];
 795
 796                         if (node == null)
 797                         {
 798                                 conversionSucceeded = false;
 799                                 return CreateInstance(desiredType, key, node);
 800                         }
 801                         else if (node.NodeType == NodeType.Leaf)
 802                         {
 803                                 LeafNode leafNode = node as LeafNode;
 804
 805                                 return Converter.Convert(desiredType, leafNode.ValueType, leafNode.Value, out conversionSucceeded);
 806                         }
 807                         else if (node.NodeType == NodeType.Indexed)
 808                         {
 809                                 IndexedNode indexedNode = node as IndexedNode;
 810
 811                                 IList convertedNodes;
 812
 813                                 if (IsSimpleProperty(elemType))
 814                                 {
 815                                         convertedNodes = ConvertFlatNodesToList(elemType, indexedNode.ChildNodes, out conversionSucceeded);
 816                                 }
 817                                 else
 818                                 {
 819                                         convertedNodes = ConvertComplexNodesToList(elemType, indexedNode, out conversionSucceeded);
 820                                 }
 821
 822                                 Type desiredImplType = desiredType.IsInterface
 823                                                         ? typeof(List<>).MakeGenericType(elemType)
 824                                                         : desiredType;
 825                                 IList target = (IList)CreateInstance(desiredImplType, key, node);
 826
 827                                 foreach(object elem in convertedNodes)
 828                                 {
 829                                         target.Add(elem);
 830                                 }
 831
 832                                 return target;
 833                         }
 834                         else
 835                         {
 836                                 throw new BindingException("Could not convert param to generic list as the node related " +
 837                                                            "to the param is not a leaf node nor an indexed node. Key {0}", key);
 838                         }
 839                 }
 840
 841                 private string TryGetDateWithUTCFormat(CompositeNode treeRoot, string paramName, out bool conversionSucceeded)
 842                 {
 843                         // YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00)
 844                         string fullDateTime = "";
 845                         conversionSucceeded = false;
 846
 847                         Node dayNode = treeRoot.GetChildNode(paramName + "day");
 848                         Node monthNode = treeRoot.GetChildNode(paramName + "month");
 849                         Node yearNode = treeRoot.GetChildNode(paramName + "year");
 850
 851                         Node hourNode = treeRoot.GetChildNode(paramName + "hour");
 852                         Node minuteNode = treeRoot.GetChildNode(paramName + "minute");
 853                         Node secondNode = treeRoot.GetChildNode(paramName + "second");
 854
 855                         if (dayNode != null)
 856                         {
 857                                 int day = (int) RelaxedConvertLeafNode(typeof(int), dayNode, 0);
 858                                 int month = (int) RelaxedConvertLeafNode(typeof(int), monthNode, 0);
 859                                 int year = (int) RelaxedConvertLeafNode(typeof(int), yearNode, 0);
 860
 861                                 fullDateTime = string.Format("{0:0000}-{1:00}-{2:00}", year, month, day);
 862                                 conversionSucceeded = true;
 863                         }
 864
 865                         if (hourNode != null)
 866                         {
 867                                 int hour = (int) RelaxedConvertLeafNode(typeof(int), hourNode, 0);
 868                                 int minute = (int) RelaxedConvertLeafNode(typeof(int), minuteNode, 0);
 869                                 int second = (int) RelaxedConvertLeafNode(typeof(int), secondNode, 0);
 870
 871                                 fullDateTime += string.Format("T{0:00}:{1:00}:{2:00}", hour, minute, second);
 872                                 conversionSucceeded = true;
 873                         }
 874
 875                         return fullDateTime == "" ? null : fullDateTime;
 876                 }
 877
 878                 private object TrySpecialDateTimeBinding(Type desiredType, CompositeNode treeRoot,
 879                                                          String paramName, out bool conversionSucceeded)
 880                 {
 881                         string dateUtc = TryGetDateWithUTCFormat(treeRoot, paramName, out conversionSucceeded);
 882
 883                         if (dateUtc != null)
 884                         {
 885                                 conversionSucceeded = true;
 886
 887                                 DateTime dt = DateTime.Parse(dateUtc);
 888
 889                                 if (desiredType.Name == "NullableDateTime")
 890                                 {
 891                                         TypeConverter typeConverter = TypeDescriptor.GetConverter(desiredType);
 892
 893                                         return typeConverter.ConvertFrom(dateUtc);
 894                                 }
 895                                 else
 896                                 {
 897                                         return DateTime.Parse(dateUtc);
 898                                 }
 899                         }
 900
 901                         conversionSucceeded = false;
 902                         return null;
 903                 }
 904
 905                 private object RelaxedConvertLeafNode(Type desiredType, Node node, object defaultValue)
 906                 {
 907                         if (node == null)
 908                         {
 909                                 return defaultValue;
 910                         }
 911
 912                         if (node.NodeType != NodeType.Leaf)
 913                         {
 914                                 throw new BindingException("Expected LeafNode, found {0} named {1}", node.NodeType, node.Name);
 915                         }
 916
 917                         bool conversionSucceeded;
 918
 919                         object result = ConvertLeafNode(desiredType, (LeafNode) node, out conversionSucceeded);
 920
 921                         return conversionSucceeded ? result : defaultValue;
 922                 }
 923
 924                 private bool IsDateTimeType(Type desiredType)
 925                 {
 926                         if (desiredType == typeof(DateTime))
 927                         {
 928                                 return true;
 929                         }
 930                         else if (desiredType.Name == "NullableDateTime")
 931                         {
 932                                 return true;
 933                         }
 934                         else if (desiredType.Name == "Nullable`1")
 935                         {
 936                                 Type[] args = desiredType.GetGenericArguments();
 937
 938                                 return (args.Length == 1 && args[0] == typeof(DateTime));
 939                         }
 940
 941                         return false;
 942                 }
 943
 944                 #region Support methods
 945
 946                 protected object InstanceOnStack
 947                 {
 948                         get
 949                         {
 950                                 if (instanceStack.Count == 0)
 951                                 {
 952                                         return null;
 953                                 }
 954
 955                                 return instanceStack.Peek();
 956                         }
 957                 }
 958
 959                 protected string PrefixOnStack
 960                 {
 961                         get
 962                         {
 963                                 if (prefixStack.Count == 0)
 964                                 {
 965                                         return null;
 966                                 }
 967
 968                                 return prefixStack.Peek();
 969                         }
 970                 }
 971
 972                 protected string ParentPrefixOnStack
 973                 {
 974                         get
 975                         {
 976                                 if (prefixStack.Count < 2)
 977                                 {
 978                                         return null;
 979                                 }
 980
 981                                 return prefixStack.ToArray()[prefixStack.Count - 2];
 982                         }
 983                 }
 984
 985                 protected String[] CreateNormalizedList(String csv)
 986                 {
 987                         if (csv == null || csv.Trim() == String.Empty)
 988                         {
 989                                 return null;
 990                         }
 991                         else
 992                         {
 993                                 String[] list = csv.Split(',');
 994                                 NormalizeList(list);
 995                                 return list;
 996                         }
 997                 }
 998
 999                 protected virtual void PushInstance(object instance, string prefix)
1000                 {
1001                         instanceStack.Push(instance);
1002                         prefixStack.Push(prefix);
1003                 }
1004
1005                 protected virtual void PopInstance(object instance, string prefix)
1006                 {
1007                         object actual = instanceStack.Pop();
1008
1009                         if (actual != instance)
1010                         {
1011                                 throw new BindingException("Unexpected item on the stack: found {0}, expecting {1}", actual, instance);
1012                         }
1013
1014                         string actualPrefix = prefixStack.Pop();
1015
1016                         if (actualPrefix != prefix)
1017                         {
1018                                 throw new BindingException("Unexpected prefix on the stack: found {0}, expecting {1}", actualPrefix, prefix);
1019                         }
1020                 }
1021
1022                 private void NormalizeList(String[] list)
1023                 {
1024                         for(int i = 0; i < list.Length; i++)
1025                         {
1026                                 list[i] = "root." + list[i].Trim();
1027                         }
1028
1029                         Array.Sort(list, CaseInsensitiveComparer.Default);
1030                 }
1031
1032                 private bool ShouldIgnoreProperty(PropertyInfo prop, string nodeFullName)
1033                 {
1034                         bool allowed = true;
1035                         bool disallowed = false;
1036
1037                         string propId = string.Format("{0}.{1}", nodeFullName, prop.Name);
1038
1039                         if (allowedPropertyList != null)
1040                         {
1041                                 allowed = Array.BinarySearch(allowedPropertyList, propId, CaseInsensitiveComparer.Default) >= 0;
1042                         }
1043                         if (excludedPropertyList != null)
1044                         {
1045                                 disallowed = Array.BinarySearch(excludedPropertyList, propId, CaseInsensitiveComparer.Default) >= 0;
1046                         }
1047
1048                         return (!allowed) || (disallowed);
1049                 }
1050
1051                 private bool IsSimpleProperty(Type propType)
1052                 {
1053                         if (propType.IsArray)
1054                         {
1055                                 return false;
1056                         }
1057
1058                         bool isSimple = propType.IsPrimitive ||
1059                                         propType.IsEnum ||
1060                                         propType == typeof(String) ||
1061                                         propType == typeof(Guid) ||
1062                                         propType == typeof(DateTime) ||
1063                                         propType == typeof(Decimal) ||
1064                                         propType == typeof(HttpPostedFile);
1065
1066                         if (isSimple)
1067                         {
1068                                 return true;
1069                         }
1070
1071                         TypeConverter tconverter = TypeDescriptor.GetConverter(propType);
1072
1073                         return tconverter.CanConvertFrom(typeof(String));
1074                 }
1075
1076                 #endregion
1077         }
1078 }