MonoRail/Castle.MonoRail.Framework/Helpers/SetOperation.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.MonoRail.Framework.Helpers
  16 {
  17         using System;
  18         using System.Collections;
  19         using Castle.MonoRail.Framework.Internal;
  20
  21         /// <summary>
  22         /// The SetOperation exposes an <see cref="IterateOnDataSource"/> that
  23         /// extracts information from the attributes and creates a proper configured
  24         /// Iterator.
  25         /// <para>
  26         /// It is shared by a handful of MonoRail operations related to sets.
  27         /// </para>
  28         /// </summary>
  29         public static class SetOperation
  30         {
  31                 /// <summary>
  32                 /// Combines a group of well thought rules to create
  33                 /// an <see cref="OperationState"/> instance.
  34                 /// </summary>
  35                 ///
  36                 /// <remarks>
  37                 /// The parameters read from the <paramref name="attributes"/> are
  38                 ///
  39                 /// <list type="bullet">
  40                 /// <item>
  41                 ///             <term>value</term>
  42                 ///             <description>The property name used to extract the value</description>
  43                 /// </item>
  44                 /// <item>
  45                 ///             <term>text</term>
  46                 ///             <description>The property name used to extract the display text</description>
  47                 /// </item>
  48                 /// <item>
  49                 ///             <term>textformat</term>
  50                 ///             <description>A format rule to apply to the text</description>
  51                 /// </item>
  52                 /// <item>
  53                 ///             <term>valueformat</term>
  54                 ///             <description>A format rule to apply to the value</description>
  55                 /// </item>
  56                 /// <item>
  57                 ///             <term>suffix</term>
  58                 ///             <description>If the types on both sets are different,
  59                 ///             the suffix specifies a different target property</description>
  60                 /// </item>
  61                 /// <item>
  62                 ///             <term>sourceProperty</term>
  63                 ///             <description>
  64                 ///             If the types on both sets are different,
  65                 ///             the sourceProperty identifies a different source property to extract the value from.
  66                 ///             </description>
  67                 /// </item>
  68                 ///
  69                 /// </list>
  70                 ///
  71                 /// </remarks>
  72                 ///
  73                 /// <param name="initialSelection">The initial selection.</param>
  74                 /// <param name="dataSource">The data source.</param>
  75                 /// <param name="attributes">The attributes.</param>
  76                 /// <returns></returns>
  77                 public static OperationState IterateOnDataSource(object initialSelection,
  78                                                                  IEnumerable dataSource, IDictionary attributes)
  79                 {
  80                         // Extract necessary elements to know which "heuristic" to use
  81
  82                         bool isInitialSelectionASet = IsSet(initialSelection);
  83
  84                         Type initialSelectionType = ExtractType(initialSelection);
  85                         Type dataSourceType = ExtractType(dataSource);
  86
  87                         String customSuffix = CommonUtils.ObtainEntryAndRemove(attributes, "suffix");
  88                         String valueProperty = CommonUtils.ObtainEntryAndRemove(attributes, "value");
  89                         String textProperty = CommonUtils.ObtainEntryAndRemove(attributes, "text");
  90                         String textFormat = CommonUtils.ObtainEntryAndRemove(attributes, "textformat");
  91                         String valueFormat = CommonUtils.ObtainEntryAndRemove(attributes, "valueformat");
  92
  93                         bool emptyValueCase = CheckForEmpyTextValueCase(dataSourceType);
  94
  95                         if (dataSourceType == null)
  96                         {
  97                                 // If the dataSourceType could not be obtained
  98                                 // then the datasource is empty or null
  99
 100                                 return NoIterationState.Instance;
 101                         }
 102                         else if (initialSelectionType == null)
 103                         {
 104                                 if (customSuffix == null && valueProperty != null)
 105                                 {
 106                                         customSuffix = valueProperty;
 107                                 }
 108
 109                                 return new ListDataSourceState(dataSourceType, dataSource,
 110                                                                                            valueProperty, textProperty, textFormat, valueFormat, customSuffix);
 111                         }
 112                         else if (initialSelectionType == dataSourceType)
 113                         {
 114                                 return new SameTypeOperationState(dataSourceType,
 115                                                                   initialSelection, dataSource,
 116                                                                                                   emptyValueCase, valueProperty, textProperty, textFormat, valueFormat, isInitialSelectionASet);
 117                         }
 118                         else // types are different, most complex scenario
 119                         {
 120                                 String sourceProperty = CommonUtils.ObtainEntryAndRemove(attributes, "sourceProperty");
 121
 122                                 return new DifferentTypeOperationState(initialSelectionType,
 123                                                                        dataSourceType, initialSelection, dataSource,
 124                                                                                                            sourceProperty, valueProperty, textProperty, textFormat, valueFormat,
 125                                                                        isInitialSelectionASet);
 126                         }
 127                 }
 128
 129                 private static bool CheckForEmpyTextValueCase(Type datasourceType)
 130                 {
 131                         if (typeof(Enum).IsAssignableFrom(datasourceType))
 132                         {
 133                                 return true;
 134                         }
 135                         return false;
 136                 }
 137
 138                 private static Type ExtractType(object source)
 139                 {
 140                         if (source == null)
 141                         {
 142                                 return null;
 143                         }
 144                         else if (source is String)
 145                         {
 146                                 return typeof(String);
 147                         }
 148                         else if (source is IEnumerable)
 149                         {
 150                                 return ExtractType(source as IEnumerable);
 151                         }
 152                         else
 153                         {
 154                                 return source.GetType();
 155                         }
 156                 }
 157
 158                 private static Type ExtractType(IEnumerable source)
 159                 {
 160                         if (source == null)
 161                         {
 162                                 return null;
 163                         }
 164
 165                         IEnumerator enumerator = source.GetEnumerator();
 166
 167                         if (enumerator.MoveNext())
 168                         {
 169                                 return ExtractType(enumerator.Current);
 170                         }
 171
 172                         return null;
 173                 }
 174
 175                 private static bool IsSet(object initialSelection)
 176                 {
 177                         if (initialSelection == null)
 178                         {
 179                                 return false;
 180                         }
 181
 182                         return initialSelection.GetType() != typeof(String) &&
 183                                initialSelection is IEnumerable;
 184                 }
 185         }
 186
 187         /// <summary>
 188         /// Represents a set element
 189         /// </summary>
 190         public class SetItem
 191         {
 192                 private readonly string value;
 193                 private readonly object item;
 194                 private readonly string text;
 195                 private readonly bool isSelected;
 196
 197                 /// <summary>
 198                 /// Initializes a new instance of the <see cref="SetItem"/> class.
 199                 /// </summary>
 200                 /// <param name="item">The item.</param>
 201                 /// <param name="value">The value.</param>
 202                 /// <param name="text">The text.</param>
 203                 /// <param name="isSelected">if set to <c>true</c> [is selected].</param>
 204                 public SetItem(object item, String value, String text, bool isSelected)
 205                 {
 206                         this.item = item;
 207                         this.value = value;
 208                         this.text = text;
 209                         this.isSelected = isSelected;
 210                 }
 211
 212                 /// <summary>
 213                 /// Gets the item.
 214                 /// </summary>
 215                 /// <value>The item.</value>
 216                 public object Item
 217                 {
 218                         get { return item; }
 219                 }
 220
 221                 /// <summary>
 222                 /// Gets the value.
 223                 /// </summary>
 224                 /// <value>The value.</value>
 225                 public string Value
 226                 {
 227                         get { return value; }
 228                 }
 229
 230                 /// <summary>
 231                 /// Gets the text.
 232                 /// </summary>
 233                 /// <value>The text.</value>
 234                 public string Text
 235                 {
 236                         get { return text; }
 237                 }
 238
 239                 /// <summary>
 240                 /// Gets a value indicating whether this instance is selected.
 241                 /// </summary>
 242                 /// <value>
 243                 ///     <c>true</c> if this instance is selected; otherwise, <c>false</c>.
 244                 /// </value>
 245                 public bool IsSelected
 246                 {
 247                         get { return isSelected; }
 248                 }
 249         }
 250
 251         /// <summary>
 252         /// Base class for set iterators
 253         /// </summary>
 254         public abstract class OperationState : IEnumerable, IEnumerator
 255         {
 256                 /// <summary>
 257                 /// source type
 258                 /// </summary>
 259                 protected readonly Type type;
 260                 /// <summary>
 261                 /// Value getter for value
 262                 /// </summary>
 263                 protected readonly FormHelper.ValueGetter valuePropInfo;
 264                 /// <summary>
 265                 /// Value getter for text
 266                 /// </summary>
 267                 protected readonly FormHelper.ValueGetter textPropInfo;
 268
 269                 /// <summary>
 270                 /// Format rule for text
 271                 /// </summary>
 272                 protected readonly String textFormat;
 273                 /// <summary>
 274                 /// Format rule for value
 275                 /// </summary>
 276                 protected readonly String valueFormat;
 277
 278                 /// <summary>
 279                 /// Source enumerator
 280                 /// </summary>
 281                 protected IEnumerator enumerator;
 282
 283                 /// <summary>
 284                 /// Initializes a new instance of the <see cref="OperationState"/> class.
 285                 /// </summary>
 286                 /// <param name="type">The type.</param>
 287                 /// <param name="dataSource">The data source.</param>
 288                 /// <param name="emptyValueCase">if set to <c>true</c> [empty value case].</param>
 289                 /// <param name="valueProperty">The value property.</param>
 290                 /// <param name="textProperty">The text property.</param>
 291                 /// <param name="textFormat">The text format.</param>
 292                 /// <param name="valueFormat">The value format.</param>
 293                 protected OperationState(Type type, IEnumerable dataSource,
 294                         bool emptyValueCase,String valueProperty, String textProperty, String textFormat, String valueFormat)
 295                 {
 296                         if (dataSource != null)
 297                         {
 298                                 enumerator = dataSource.GetEnumerator();
 299                         }
 300
 301                         this.type = type;
 302                         this.textFormat = textFormat;
 303                         this.valueFormat = valueFormat;
 304
 305                         if (valueProperty != null || emptyValueCase)
 306                         {
 307                                 valuePropInfo = FormHelper.ValueGetterAbstractFactory.Create(type, valueProperty); // FormHelper.GetMethod(type, valueProperty);
 308                         }
 309
 310                         if (textProperty != null)
 311                         {
 312                                 textPropInfo = FormHelper.ValueGetterAbstractFactory.Create(type, textProperty);
 313                         }
 314                 }
 315
 316                 /// <summary>
 317                 /// Gets the target suffix.
 318                 /// </summary>
 319                 /// <value>The target suffix.</value>
 320                 public abstract String TargetSuffix { get; }
 321
 322                 /// <summary>
 323                 /// Formats the text.
 324                 /// </summary>
 325                 /// <param name="value">The value to be formatted.</param>
 326                 /// <param name="format">The format to apply.</param>
 327                 protected static void FormatText(ref object value, string format)
 328                 {
 329                         if (format != null && value != null)
 330                         {
 331                                 IFormattable formattable = value as IFormattable;
 332
 333                                 if (formattable != null)
 334                                 {
 335                                         value = formattable.ToString(format, null);
 336                                 }
 337                         }
 338                 }
 339
 340                 /// <summary>
 341                 /// Creates the item representation.
 342                 /// </summary>
 343                 /// <param name="current">The current.</param>
 344                 /// <returns></returns>
 345                 protected abstract SetItem CreateItemRepresentation(object current);
 346
 347                 #region IEnumerator implementation
 348
 349                 /// <summary>
 350                 /// Advances the enumerator to the next element of the collection.
 351                 /// </summary>
 352                 /// <returns>
 353                 /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
 354                 /// </returns>
 355                 /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
 356                 public bool MoveNext()
 357                 {
 358                         if (enumerator == null)
 359                         {
 360                                 return false;
 361                         }
 362                         return enumerator.MoveNext();
 363                 }
 364
 365                 /// <summary>
 366                 /// Sets the enumerator to its initial position, which is before the first element in the collection.
 367                 /// </summary>
 368                 /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
 369                 public void Reset()
 370                 {
 371                         if (enumerator != null)
 372                         {
 373                                 enumerator.Reset();
 374                         }
 375                 }
 376
 377                 /// <summary>
 378                 /// Gets the current element in the collection.
 379                 /// </summary>
 380                 /// <value></value>
 381                 /// <returns>The current element in the collection.</returns>
 382                 /// <exception cref="T:System.InvalidOperationException">The enumerator is positioned before the first element of the collection or after the last element. </exception>
 383                 public object Current
 384                 {
 385                         get { return CreateItemRepresentation(enumerator.Current); }
 386                 }
 387
 388                 #endregion
 389
 390                 #region IEnumerable implementation
 391
 392                 /// <summary>
 393                 /// Returns an enumerator that iterates through a collection.
 394                 /// </summary>
 395                 /// <returns>
 396                 /// An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection.
 397                 /// </returns>
 398                 public IEnumerator GetEnumerator()
 399                 {
 400                         return this;
 401                 }
 402
 403                 #endregion
 404         }
 405
 406         /// <summary>
 407         /// Used for empty/null datasources
 408         /// </summary>
 409         public class NoIterationState : OperationState
 410         {
 411                 /// <summary>
 412                 /// Single instance for the iterator.
 413                 /// </summary>
 414                 public static readonly NoIterationState Instance = new NoIterationState();
 415
 416                 private NoIterationState() : base(null, null, false, null, null, null, null)
 417                 {
 418                 }
 419
 420                 /// <summary>
 421                 /// Gets the target suffix.
 422                 /// </summary>
 423                 /// <value>The target suffix.</value>
 424                 public override string TargetSuffix
 425                 {
 426                         get { return null; }
 427                 }
 428
 429                 /// <summary>
 430                 /// Creates the item representation.
 431                 /// </summary>
 432                 /// <param name="current">The current.</param>
 433                 /// <returns></returns>
 434                 protected override SetItem CreateItemRepresentation(object current)
 435                 {
 436                         throw new NotImplementedException();
 437                 }
 438         }
 439
 440         /// <summary>
 441         /// Simple iterator
 442         /// </summary>
 443         public class ListDataSourceState : OperationState
 444         {
 445                 private readonly string customSuffix;
 446
 447                 /// <summary>
 448                 /// Initializes a new instance of the <see cref="ListDataSourceState"/> class.
 449                 /// </summary>
 450                 /// <param name="type">The type.</param>
 451                 /// <param name="dataSource">The data source.</param>
 452                 /// <param name="valueProperty">The value property.</param>
 453                 /// <param name="textProperty">The text property.</param>
 454                 /// <param name="textFormat">The text format.</param>
 455                 /// <param name="valueFormat">The value format.</param>
 456                 /// <param name="customSuffix">The custom suffix.</param>
 457                 public ListDataSourceState(Type type, IEnumerable dataSource, String valueProperty,
 458                         String textProperty, String textFormat, String valueFormat, String customSuffix)
 459                         : base(type, dataSource, false, valueProperty, textProperty, textFormat, valueFormat)
 460                 {
 461                         this.customSuffix = customSuffix;
 462                 }
 463
 464                 /// <summary>
 465                 /// Gets the target suffix.
 466                 /// </summary>
 467                 /// <value>The target suffix.</value>
 468                 public override string TargetSuffix
 469                 {
 470                         get { return customSuffix; }
 471                 }
 472
 473                 /// <summary>
 474                 /// Creates the item representation.
 475                 /// </summary>
 476                 /// <param name="current">The current.</param>
 477                 /// <returns></returns>
 478                 protected override SetItem CreateItemRepresentation(object current)
 479                 {
 480                         object value = current;
 481                         object text = current;
 482
 483                         if (valuePropInfo != null)
 484                         {
 485                                 value = valuePropInfo.GetValue(current);
 486                         }
 487
 488                         if (textPropInfo != null)
 489                         {
 490                                 text = textPropInfo.GetValue(current);
 491                         }
 492
 493                         FormatText(ref text, textFormat);
 494                         FormatText(ref value, valueFormat);
 495
 496                         return new SetItem(current, value != null ? value.ToString() : String.Empty, text != null ? text.ToString() : String.Empty, false);
 497                 }
 498         }
 499
 500         /// <summary>
 501         /// Iterator for sets type same type
 502         /// </summary>
 503         public class SameTypeOperationState : OperationState
 504         {
 505                 private readonly object initialSelection;
 506                 private readonly bool isInitialSelectionASet;
 507
 508                 /// <summary>
 509                 /// Initializes a new instance of the <see cref="SameTypeOperationState"/> class.
 510                 /// </summary>
 511                 /// <param name="type">The type.</param>
 512                 /// <param name="initialSelection">The initial selection.</param>
 513                 /// <param name="dataSource">The data source.</param>
 514                 /// <param name="emptyValueCase">if set to <c>true</c> [empty value case].</param>
 515                 /// <param name="valueProperty">The value property.</param>
 516                 /// <param name="textProperty">The text property.</param>
 517                 /// <param name="textFormat">The text format.</param>
 518                 /// <param name="valueFormat">The value format.</param>
 519                 /// <param name="isInitialSelectionASet">if set to <c>true</c> [is initial selection A set].</param>
 520                 public SameTypeOperationState(Type type, object initialSelection, IEnumerable dataSource,
 521                         bool emptyValueCase,String valueProperty, String textProperty, String textFormat, String valueFormat, bool isInitialSelectionASet)
 522                         : base(type, dataSource, emptyValueCase, valueProperty, textProperty, textFormat, valueFormat)
 523                 {
 524                         this.initialSelection = initialSelection;
 525                         this.isInitialSelectionASet = isInitialSelectionASet;
 526                 }
 527
 528                 /// <summary>
 529                 /// Gets the target suffix.
 530                 /// </summary>
 531                 /// <value>The target suffix.</value>
 532                 public override string TargetSuffix
 533                 {
 534                         get { return valuePropInfo == null ? "" : valuePropInfo.Name; }
 535                 }
 536
 537                 /// <summary>
 538                 /// Creates the item representation.
 539                 /// </summary>
 540                 /// <param name="current">The current.</param>
 541                 /// <returns></returns>
 542                 protected override SetItem CreateItemRepresentation(object current)
 543                 {
 544                         object value = current;
 545                         object text = current;
 546
 547                         if (valuePropInfo != null)
 548                         {
 549                                 value = valuePropInfo.GetValue(current);
 550                         }
 551
 552                         if (textPropInfo != null)
 553                         {
 554                                 text = textPropInfo.GetValue(current);
 555                         }
 556
 557                         FormatText(ref text, textFormat);
 558                         FormatText(ref value, valueFormat);
 559
 560                         bool isSelected = FormHelper.IsPresent(value, initialSelection, valuePropInfo, isInitialSelectionASet);
 561
 562                         return new SetItem(current, value != null ? value.ToString() : String.Empty, text != null ? text.ToString() : String.Empty, isSelected);
 563                 }
 564         }
 565
 566         /// <summary>
 567         /// Iterator for different types on the set
 568         /// </summary>
 569         public class DifferentTypeOperationState : OperationState
 570         {
 571                 private readonly object initialSelection;
 572                 private readonly bool isInitialSelectionASet;
 573                 private readonly FormHelper.ValueGetter sourcePropInfo;
 574
 575                 /// <summary>
 576                 /// Initializes a new instance of the <see cref="DifferentTypeOperationState"/> class.
 577                 /// </summary>
 578                 /// <param name="initialSelectionType">Initial type of the selection.</param>
 579                 /// <param name="dataSourceType">Type of the data source.</param>
 580                 /// <param name="initialSelection">The initial selection.</param>
 581                 /// <param name="dataSource">The data source.</param>
 582                 /// <param name="sourceProperty">The source property.</param>
 583                 /// <param name="valueProperty">The value property.</param>
 584                 /// <param name="textProperty">The text property.</param>
 585                 /// <param name="textFormat">The text format.</param>
 586                 /// <param name="valueFormat">The value format.</param>
 587                 /// <param name="isInitialSelectionASet">if set to <c>true</c> [is initial selection A set].</param>
 588                 public DifferentTypeOperationState(Type initialSelectionType, Type dataSourceType,
 589                         object initialSelection, IEnumerable dataSource,
 590                         String sourceProperty, String valueProperty,
 591                         String textProperty, String textFormat, String valueFormat, bool isInitialSelectionASet)
 592                         : base(dataSourceType, dataSource, false, valueProperty, textProperty, textFormat, valueFormat)
 593                 {
 594                         this.initialSelection = initialSelection;
 595                         this.isInitialSelectionASet = isInitialSelectionASet;
 596
 597                         if (sourceProperty != null)
 598                         {
 599                                 sourcePropInfo = FormHelper.ValueGetterAbstractFactory.Create(initialSelectionType, sourceProperty); // FormHelper.GetMethod(initialSelectionType, sourceProperty);
 600                         }
 601                         else if (valueProperty != null)
 602                         {
 603                                 sourcePropInfo = FormHelper.ValueGetterAbstractFactory.Create(initialSelectionType, valueProperty); // FormHelper.GetMethod(initialSelectionType, valueProperty);
 604                         }
 605                 }
 606
 607                 /// <summary>
 608                 /// Gets the target suffix.
 609                 /// </summary>
 610                 /// <value>The target suffix.</value>
 611                 public override string TargetSuffix
 612                 {
 613                         get { return sourcePropInfo == null ? "" : sourcePropInfo.Name; }
 614                 }
 615
 616                 /// <summary>
 617                 /// Creates the item representation.
 618                 /// </summary>
 619                 /// <param name="current">The current.</param>
 620                 /// <returns></returns>
 621                 protected override SetItem CreateItemRepresentation(object current)
 622                 {
 623                         object value = current;
 624                         object text = current;
 625
 626                         if (valuePropInfo != null)
 627                         {
 628                                 value = valuePropInfo.GetValue(current);
 629                         }
 630
 631                         if (textPropInfo != null)
 632                         {
 633                                 text = textPropInfo.GetValue(current);
 634                         }
 635
 636                         FormatText(ref text, textFormat);
 637                         FormatText(ref value, valueFormat);
 638
 639                         bool isSelected = FormHelper.IsPresent(value, initialSelection, sourcePropInfo, isInitialSelectionASet);
 640
 641                         return new SetItem(current, value != null ? value.ToString() : String.Empty, text != null ? text.ToString() : String.Empty, isSelected);
 642                 }
 643         }
 644 }