InversionOfControl/Castle.Windsor/Configuration/Interpreters/AbstractInterpreter.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.Windsor.Configuration.Interpreters
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Configuration;
  20
  21         using Castle.Core.Resource;
  22         using Castle.Core.Configuration;
  23         using Castle.MicroKernel;
  24
  25         /// <summary>
  26         /// Provides common methods for those who wants
  27         /// to implement <see cref="IConfigurationInterpreter"/>
  28         /// </summary>
  29         public abstract class AbstractInterpreter : IConfigurationInterpreter
  30         {
  31                 #region Fields
  32
  33                 protected static readonly string ContainersNodeName = "containers";
  34                 protected static readonly string ContainerNodeName = "container";
  35                 protected static readonly string FacilitiesNodeName = "facilities";
  36                 protected static readonly string FacilityNodeName = "facility";
  37                 protected static readonly string ComponentsNodeName = "components";
  38                 protected static readonly string BootstrapNodeName = "bootstrap";
  39                 protected static readonly string ComponentNodeName = "component";
  40                 protected static readonly string IncludeNodeName = "include";
  41                 protected static readonly string PropertiesNodeName = "properties";
  42
  43                 // private ImportDirectiveCollection imports = new ImportDirectiveCollection();
  44                 private IResource source;
  45                 private Stack resourceStack = new Stack();
  46                 private string environmentName;
  47
  48                 #endregion
  49
  50                 #region Constructors
  51
  52                 public AbstractInterpreter(IResource source)
  53                 {
  54                         if (source == null) throw new ArgumentNullException("source", "IResource is null");
  55
  56                         this.source = source;
  57
  58                         PushResource(source);
  59                 }
  60
  61                 public AbstractInterpreter(string filename) : this(new FileResource(filename))
  62                 {
  63                 }
  64
  65                 public AbstractInterpreter() : this(new ConfigResource())
  66                 {
  67                 }
  68
  69                 #endregion
  70
  71                 /// <summary>
  72                 /// Should obtain the contents from the resource,
  73                 /// interpret it and populate the <see cref="IConfigurationStore"/>
  74                 /// accordingly.
  75                 /// </summary>
  76                 /// <param name="resource"></param>
  77                 /// <param name="store"></param>
  78                 public abstract void ProcessResource(IResource resource, IConfigurationStore store);
  79
  80                 #region Support for Resource stack
  81
  82                 protected void PushResource(IResource resource)
  83                 {
  84                         resourceStack.Push(resource);
  85                 }
  86
  87                 protected void PopResource()
  88                 {
  89                         resourceStack.Pop();
  90                 }
  91
  92                 protected IResource CurrentResource
  93                 {
  94                         get
  95                         {
  96                                 if (resourceStack.Count == 0) return null;
  97
  98                                 return resourceStack.Peek() as IResource;
  99                         }
 100                 }
 101
 102                 #endregion
 103
 104                 #region Properties
 105
 106                 /// <summary>
 107                 /// Exposes the reference to <see cref="IResource"/>
 108                 /// which the interpreter is likely to hold
 109                 /// </summary>
 110                 /// <value></value>
 111                 public IResource Source
 112                 {
 113                         get { return source; }
 114                 }
 115
 116                 /// <summary>
 117                 /// Gets or sets the name of the environment.
 118                 /// </summary>
 119                 /// <value>The name of the environment.</value>
 120                 public string EnvironmentName
 121                 {
 122                         get { return environmentName; }
 123                         set { environmentName = value; }
 124                 }
 125
 126                 #endregion
 127
 128                 #region Helpers to populate IConfigurationStore
 129
 130                 protected void AddFacilityConfig(IConfiguration facility, IConfigurationStore store)
 131                 {
 132                         AddFacilityConfig( facility.Attributes["id"], facility, store );
 133                 }
 134
 135                 protected void AddComponentConfig(IConfiguration component, IConfigurationStore store)
 136                 {
 137                         AddComponentConfig( component.Attributes["id"], component, store );
 138                 }
 139
 140                 protected void AddChildContainerConfig(string name, IConfiguration childContainer, IConfigurationStore store)
 141                 {
 142                         AssertValidId(name);
 143
 144                         // TODO: Use import collection on type attribute (if it exists)
 145
 146                         store.AddChildContainerConfiguration(name, childContainer);
 147                 }
 148
 149                 protected void AddFacilityConfig(string id, IConfiguration facility, IConfigurationStore store)
 150                 {
 151                         AssertValidId(id);
 152
 153                         // TODO: Use import collection on type attribute (if it exists)
 154
 155                         store.AddFacilityConfiguration( id, facility );
 156                 }
 157
 158                 protected void AddComponentConfig(string id, IConfiguration component, IConfigurationStore store)
 159                 {
 160                         AssertValidId(id);
 161
 162                         // TODO: Use import collection on type and service attribute (if they exist)
 163
 164                         store.AddComponentConfiguration( id, component );
 165                 }
 166
 167                 protected void AddBootstrapComponentConfig(string id, IConfiguration component, IConfigurationStore store)
 168                 {
 169                         AssertValidId(id);
 170
 171                         // TODO: Use import collection on type and service attribute (if they exist)
 172
 173                         store.AddBootstrapComponentConfiguration(id, component);
 174                 }
 175
 176                 private void AssertValidId(string id)
 177                 {
 178                         if (id == null || id.Length == 0)
 179                         {
 180                                 string message = "Component or Facility was declared without a proper 'id' attribute";
 181
 182                                 throw new ConfigurationErrorsException(message);
 183                         }
 184                 }
 185
 186                 #endregion
 187
 188                 protected void ProcessInclude(string uri, IConfigurationStore store)
 189                 {
 190                         IResource resource = store.GetResource(uri, CurrentResource);
 191
 192                         if (resource == null)
 193                         {
 194                                 // TODO: Proper Exception
 195                         }
 196
 197                         PushResource(resource);
 198
 199                         ProcessResource(resource, store);
 200
 201                         PopResource();
 202                 }
 203         }
 204 }