InversionOfControl/Castle.MicroKernel/SubSystems/Conversion/Converters/DictionaryConverter.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.MicroKernel.SubSystems.Conversion
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         using Castle.Core.Configuration;
  21
  22         [Serializable]
  23         public class DictionaryConverter : AbstractTypeConverter
  24         {
  25                 public override bool CanHandleType(Type type)
  26                 {
  27                         return (type == typeof(IDictionary) || type == typeof(Hashtable));
  28                 }
  29
  30                 public override object PerformConversion(String value, Type targetType)
  31                 {
  32                         throw new NotImplementedException();
  33                 }
  34
  35                 public override object PerformConversion(IConfiguration configuration, Type targetType)
  36                 {
  37                         System.Diagnostics.Debug.Assert( targetType == typeof(IDictionary) || targetType == typeof(Hashtable) );
  38
  39                         Hashtable dict = new Hashtable();
  40
  41                         String keyTypeName = configuration.Attributes["keyType"];
  42                         Type defaultKeyType = typeof(String);
  43
  44                         String valueTypeName = configuration.Attributes["valueType"];
  45                         Type defaultValueType = typeof(String);
  46
  47                         if (keyTypeName != null)
  48                         {
  49                                 defaultKeyType = (Type) Context.Composition.PerformConversion( keyTypeName, typeof(Type) );
  50                         }
  51                         if (valueTypeName != null)
  52                         {
  53                                 defaultValueType = (Type) Context.Composition.PerformConversion( valueTypeName, typeof(Type) );
  54                         }
  55
  56                         foreach(IConfiguration itemConfig in configuration.Children)
  57                         {
  58                                 // Preparing the key
  59
  60                                 String keyValue = itemConfig.Attributes["key"];
  61
  62                                 if (keyValue == null)
  63                                 {
  64                                         throw new ConverterException("You must provide a key for the dictionary entry");
  65                                 }
  66
  67                                 Type convertKeyTo = defaultKeyType;
  68
  69                                 if (itemConfig.Attributes["keyType"] != null)
  70                                 {
  71                                         convertKeyTo = (Type) Context.Composition.PerformConversion(
  72                                                 itemConfig.Attributes["keyType"], typeof(Type) );
  73                                 }
  74
  75                                 object key = Context.Composition.PerformConversion(keyValue, convertKeyTo);
  76
  77                                 // Preparing the value
  78
  79                                 Type convertValueTo = defaultValueType;
  80
  81                                 if (itemConfig.Attributes["valueType"] != null)
  82                                 {
  83                                         convertValueTo = (Type) Context.Composition.PerformConversion(
  84                                                 itemConfig.Attributes["valueType"], typeof(Type) );
  85                                 }
  86
  87                                 object value;
  88
  89                                 if (itemConfig.Children.Count == 0)
  90                                 {
  91                                         value = Context.Composition.PerformConversion(
  92                                                 itemConfig, convertValueTo);
  93                                 }
  94                                 else
  95                                 {
  96                                         value = Context.Composition.PerformConversion(
  97                                                 itemConfig.Children[0], convertValueTo);
  98                                 }
  99
 100                                 dict.Add( key, value );
 101                         }
 102
 103                         return dict;
 104                 }
 105         }
 106 }