MonoRail/Castle.MonoRail.Framework/Configuration/ServiceEntryCollection.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.Configuration
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Xml;
  20
  21         using Castle.Components.Common.EmailSender;
  22         using Castle.Components.Validator;
  23         using Castle.MonoRail.Framework.Internal;
  24         using Castle.MonoRail.Framework.Services.AjaxProxyGenerator;
  25
  26
  27         public class ServiceEntryCollection : ISerializedConfig
  28         {
  29                 private Hashtable service2Impl = new Hashtable();
  30                 private IList customServices = new ArrayList();
  31
  32                 public ServiceEntryCollection()
  33                 {
  34                 }
  35
  36                 public ICollection CustomServices
  37                 {
  38                         get { return customServices; }
  39                 }
  40
  41                 #region ISerializedConfig implementation
  42
  43                 public void Deserialize(XmlNode section)
  44                 {
  45                         XmlNodeList services = section.SelectNodes("services/service");
  46
  47                         foreach(XmlNode node in services)
  48                         {
  49                                 ServiceEntry entry = new ServiceEntry();
  50
  51                                 entry.Deserialize(node);
  52
  53                                 if (entry.ServiceType == ServiceIdentification.Custom)
  54                                 {
  55                                         if (entry.Interface != null)
  56                                         {
  57                                                 RegisterService(entry.Interface, entry.Service);
  58                                         }
  59                                         else
  60                                         {
  61                                                 customServices.Add(entry.Service);
  62                                         }
  63                                 }
  64                                 else
  65                                 {
  66                                         RegisterService(entry.ServiceType, entry.Service);
  67                                 }
  68                         }
  69                 }
  70
  71                 #endregion
  72
  73                 public void RegisterService(ServiceIdentification id, Type service)
  74                 {
  75                         RegisterService(ToInterface(id), service);
  76                 }
  77
  78                 public void RegisterService(Type inter, Type service)
  79                 {
  80                         service2Impl[inter] = service;
  81                 }
  82
  83                 public Type GetService(ServiceIdentification id)
  84                 {
  85                         return (Type) service2Impl[ToInterface(id)];
  86                 }
  87
  88                 public bool HasService(ServiceIdentification id)
  89                 {
  90                         return service2Impl.Contains(ToInterface(id));
  91                 }
  92
  93                 public IDictionary ServiceImplMap
  94                 {
  95                         get { return service2Impl; }
  96                 }
  97
  98                 private Type ToInterface(ServiceIdentification id)
  99                 {
 100                         switch(id)
 101                         {
 102                                 case ServiceIdentification.ControllerFactory:
 103                                         return typeof(IControllerFactory);
 104                                 case ServiceIdentification.ViewComponentFactory:
 105                                         return typeof(IViewComponentFactory);
 106                                 case ServiceIdentification.FilterFactory:
 107                                         return typeof(IFilterFactory);
 108                                 case ServiceIdentification.EmailSender:
 109                                         return typeof(IEmailSender);
 110                                 case ServiceIdentification.ControllerDescriptorProvider:
 111                                         return typeof(IControllerDescriptorProvider);
 112                                 case ServiceIdentification.ResourceDescriptorProvider:
 113                                         return typeof(IResourceDescriptorProvider);
 114                                 case ServiceIdentification.RescueDescriptorProvider:
 115                                         return typeof(IRescueDescriptorProvider);
 116                                 case ServiceIdentification.LayoutDescriptorProvider:
 117                                         return typeof(ILayoutDescriptorProvider);
 118                                 case ServiceIdentification.HelperDescriptorProvider:
 119                                         return typeof(IHelperDescriptorProvider);
 120                                 case ServiceIdentification.FilterDescriptorProvider:
 121                                         return typeof(IFilterDescriptorProvider);
 122                                 case ServiceIdentification.EmailTemplateService:
 123                                         return typeof(IEmailTemplateService);
 124                                 case ServiceIdentification.ControllerTree:
 125                                         return typeof(IControllerTree);
 126                                 case ServiceIdentification.CacheProvider:
 127                                         return typeof(ICacheProvider);
 128                                 case ServiceIdentification.ViewSourceLoader:
 129                                         return typeof(IViewSourceLoader);
 130                                 case ServiceIdentification.ScaffoldingSupport:
 131                                         return typeof(IScaffoldingSupport);
 132                                 case ServiceIdentification.ViewEngineManager:
 133                                         return typeof(IViewEngineManager);
 134                                 case ServiceIdentification.ResourceFactory:
 135                                         return typeof(IResourceFactory);
 136                                 case ServiceIdentification.ExecutorFactory:
 137                                         return typeof(IControllerLifecycleExecutorFactory);
 138                                 case ServiceIdentification.TransformationFilterFactory:
 139                                         return typeof(ITransformFilterFactory);
 140                                 case ServiceIdentification.TransformFilterDescriptorProvider:
 141                                         return typeof(ITransformFilterDescriptorProvider);
 142                                 case ServiceIdentification.UrlBuilder:
 143                                         return typeof(IUrlBuilder);
 144                                 case ServiceIdentification.UrlTokenizer:
 145                                         return typeof(IUrlTokenizer);
 146                                 case ServiceIdentification.ServerUtility:
 147                                         return typeof(IServerUtility);
 148                                 case ServiceIdentification.ValidatorRegistry:
 149                                         return typeof(IValidatorRegistry);
 150                                 case ServiceIdentification.AjaxProxyGenerator:
 151                                         return typeof(IAjaxProxyGenerator);
 152                                 default:
 153                                         throw new NotSupportedException("Id not supported " + id);
 154                         }
 155                 }
 156         }
 157 }