InversionOfControl/Castle.MicroKernel/SubSystems/Conversion/DefaultConversionManager.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.MicroKernel.SubSystems.Conversion
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Threading;
  20         using Castle.Core;
  21         using Castle.Core.Configuration;
  22
  23         /// <summary>
  24         /// Composition of all available conversion managers
  25         /// </summary>
  26         [Serializable]
  27         public class DefaultConversionManager : AbstractSubSystem, IConversionManager, ITypeConverterContext
  28         {
  29                 private static LocalDataStoreSlot slot = Thread.AllocateDataSlot();
  30                 private IList converters;
  31                 private IList standAloneConverters;
  32
  33                 public DefaultConversionManager()
  34                 {
  35                         converters = new ArrayList();
  36                         standAloneConverters = new ArrayList();
  37
  38                         InitDefaultConverters();
  39                 }
  40
  41                 protected virtual void InitDefaultConverters()
  42                 {
  43                         Add(new PrimitiveConverter());
  44                         Add(new TimeSpanConverter());
  45                         Add(new TypeNameConverter());
  46                         Add(new EnumConverter());
  47                         Add(new ListConverter());
  48                         Add(new DictionaryConverter());
  49                         Add(new GenericDictionaryConverter());
  50                         Add(new GenericListConverter());
  51                         Add(new ArrayConverter());
  52                         Add(new ComponentConverter());
  53                         Add(new AttributeAwareConverter());
  54                         Add(new ComponentModelConverter());
  55                 }
  56
  57                 #region IConversionManager Members
  58
  59                 public void Add(ITypeConverter converter)
  60                 {
  61                         converter.Context = this;
  62
  63                         converters.Add(converter);
  64
  65                         if (!(converter is IKernelDependentConverter))
  66                         {
  67                                 standAloneConverters.Add(converter);
  68                         }
  69                 }
  70
  71                 public bool IsSupportedAndPrimitiveType(Type type)
  72                 {
  73                         foreach(ITypeConverter converter in standAloneConverters)
  74                         {
  75                                 if (converter.CanHandleType(type)) return true;
  76                         }
  77
  78                         return false;
  79                 }
  80
  81                 #endregion
  82
  83                 #region ITypeConverter Members
  84
  85                 public ITypeConverterContext Context
  86                 {
  87                         get { return this; }
  88                         set { throw new NotImplementedException(); }
  89                 }
  90
  91                 public bool CanHandleType(Type type)
  92                 {
  93                         foreach(ITypeConverter converter in converters)
  94                         {
  95                                 if (converter.CanHandleType(type)) return true;
  96                         }
  97
  98                         return false;
  99                 }
 100
 101                 public bool CanHandleType(Type type, IConfiguration configuration)
 102                 {
 103                         foreach(ITypeConverter converter in converters)
 104                         {
 105                                 if (converter.CanHandleType(type, configuration)) return true;
 106                         }
 107
 108                         return false;
 109                 }
 110
 111                 public object PerformConversion(String value, Type targetType)
 112                 {
 113                         foreach(ITypeConverter converter in converters)
 114                         {
 115                                 if (converter.CanHandleType(targetType))
 116                                 {
 117                                         return converter.PerformConversion(value, targetType);
 118                                 }
 119                         }
 120
 121                         String message = String.Format("No converter registered to handle the type {0}",
 122                                                        targetType.FullName);
 123
 124                         throw new ConverterException(message);
 125                 }
 126
 127                 public object PerformConversion(IConfiguration configuration, Type targetType)
 128                 {
 129                         foreach(ITypeConverter converter in converters)
 130                         {
 131                                 if (converter.CanHandleType(targetType, configuration))
 132                                 {
 133                                         return converter.PerformConversion(configuration, targetType);
 134                                 }
 135                         }
 136
 137                         String message = String.Format("No converter registered to handle the type {0}",
 138                                                        targetType.FullName);
 139
 140                         throw new ConverterException(message);
 141                 }
 142
 143                 #endregion
 144
 145                 #region ITypeConverterContext Members
 146
 147                 IKernel ITypeConverterContext.Kernel
 148                 {
 149                         get { return base.Kernel; }
 150                 }
 151
 152                 public void PushModel(ComponentModel model)
 153                 {
 154                         CurrentStack.Push(model);
 155                 }
 156
 157                 public void PopModel()
 158                 {
 159                         CurrentStack.Pop();
 160                 }
 161
 162                 public ComponentModel CurrentModel
 163                 {
 164                         get
 165                         {
 166                                 if (CurrentStack.Count == 0) return null;
 167                                 else return (ComponentModel) CurrentStack.Peek();
 168                         }
 169                 }
 170
 171                 public ITypeConverter Composition
 172                 {
 173                         get { return this; }
 174                 }
 175
 176                 #endregion
 177
 178                 private Stack CurrentStack
 179                 {
 180                         get
 181                         {
 182                                 Stack stack = (Stack) Thread.GetData(slot);
 183
 184                                 if (stack == null)
 185                                 {
 186                                         stack = new Stack();
 187                                         Thread.SetData(slot, stack);
 188                                 }
 189
 190                                 return stack;
 191                         }
 192                 }
 193         }
 194 }