InversionOfControl/Castle.MicroKernel/Registration/Configuration.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.Registration
  16 {
  17         using System;
  18         using Castle.Core.Configuration;
  19
  20         #region Node
  21
  22         /// <summary>
  23         /// Represents a configuration child.
  24         /// </summary>
  25         public abstract class Node
  26         {
  27                 private readonly String name;
  28
  29                 protected Node(String name)
  30                 {
  31                         this.name = name;
  32                 }
  33
  34                 protected string Name
  35                 {
  36                         get { return name; }
  37                 }
  38
  39                 /// <summary>
  40                 /// Applies the configuration node.
  41                 /// </summary>
  42                 /// <param name="configuration">The configuration.</param>
  43                 public abstract void ApplyTo(IConfiguration configuration);
  44         }
  45
  46         #endregion
  47
  48         #region Attribute
  49
  50         /// <summary>
  51         /// Represents a configuration attribute.
  52         /// </summary>
  53         public class Attribute : Node
  54         {
  55                 private readonly String value;
  56
  57                 internal Attribute(String name, String value)
  58                         : base(name)
  59                 {
  60                         this.value = value;
  61                 }
  62
  63                 /// <summary>
  64                 /// Applies the configuration node.
  65                 /// </summary>
  66                 /// <param name="configuration">The configuration.</param>
  67                 public override void ApplyTo(IConfiguration configuration)
  68                 {
  69                         configuration.Attributes.Add(Name, value);
  70                 }
  71
  72                 /// <summary>
  73                 /// Create a <see cref="NamedAttribute"/> with name.
  74                 /// </summary>
  75                 /// <param name="name">The attribute name.</param>
  76                 /// <returns>The new <see cref="NamedAttribute"/></returns>
  77                 public static NamedAttribute ForName(String name)
  78                 {
  79                         return new NamedAttribute(name);
  80                 }
  81         }
  82
  83         #endregion
  84
  85         #region NamedChild
  86
  87         /// <summary>
  88         /// Represents a named attribute.
  89         /// </summary>
  90         public class NamedAttribute
  91         {
  92                 private readonly String name;
  93
  94                 internal NamedAttribute(String name)
  95                 {
  96                         this.name = name;
  97                 }
  98
  99                 /// <summary>
 100                 /// Builds the <see cref="Attribute"/> with name/value.
 101                 /// </summary>
 102                 /// <param name="value">The attribute value.</param>
 103                 /// <returns>The new <see cref="SimpleChild"/></returns>
 104                 public Attribute Eq(String value)
 105                 {
 106                         return new Attribute(name, value);
 107                 }
 108         }
 109
 110         #endregion
 111
 112         #region Child
 113
 114         /// <summary>
 115         /// Represents a configuration child.
 116         /// </summary>
 117         public abstract class Child
 118         {
 119                 /// <summary>
 120                 /// Create a <see cref="NamedChild"/> with name.
 121                 /// </summary>
 122                 /// <param name="name">The child name.</param>
 123                 /// <returns>The new <see cref="NamedChild"/></returns>
 124                 public static NamedChild ForName(String name)
 125                 {
 126                         return new NamedChild(name);
 127                 }
 128         }
 129
 130         #endregion
 131
 132         #region NamedChild
 133
 134         /// <summary>
 135         /// Represents a named child.
 136         /// </summary>
 137         public class NamedChild : Node
 138         {
 139                 internal NamedChild(String name)
 140                         : base(name)
 141                 {
 142                 }
 143
 144                 /// <summary>
 145                 /// Builds the <see cref="SimpleChild"/> with name/value.
 146                 /// </summary>
 147                 /// <param name="value">The child value.</param>
 148                 /// <returns>The new <see cref="SimpleChild"/></returns>
 149                 public SimpleChild Eq(String value)
 150                 {
 151                         return new SimpleChild(Name, value);
 152                 }
 153
 154                 /// <summary>
 155                 /// Builds the <see cref="ComplexChild"/> with name/config.
 156                 /// </summary>
 157                 /// <param name="configNode">The child configuration.</param>
 158                 /// <returns>The new <see cref="ComplexChild"/></returns>
 159                 public ComplexChild Eq(IConfiguration configNode)
 160                 {
 161                         return new ComplexChild(Name, configNode);
 162                 }
 163
 164                 /// <summary>
 165                 /// Builds the <see cref="Child"/> with name/config.
 166                 /// </summary>
 167                 /// <param name="childNodes">The child nodes.</param>
 168                 /// <returns>The new <see cref="CompoundChild"/></returns>
 169                 public CompoundChild Eq(params Node[] childNodes)
 170                 {
 171                         return new CompoundChild(Name, childNodes);
 172                 }
 173
 174                 /// <summary>
 175                 /// Applies the configuration node.
 176                 /// </summary>
 177                 /// <param name="configuration">The configuration.</param>
 178                 public override void ApplyTo(IConfiguration configuration)
 179                 {
 180                         MutableConfiguration node = new MutableConfiguration(Name);
 181                         configuration.Children.Add(node);
 182                 }
 183         }
 184
 185         #endregion
 186
 187         #region SimpleChild
 188
 189         /// <summary>
 190         /// Represents a simple child node.
 191         /// </summary>
 192         public class SimpleChild : Node
 193         {
 194                 private readonly String value;
 195
 196                 internal SimpleChild(String name, String value)
 197                         : base(name)
 198                 {
 199                         this.value = value;
 200                 }
 201
 202                 /// <summary>
 203                 /// Applies the configuration node.
 204                 /// </summary>
 205                 /// <param name="configuration">The configuration.</param>
 206                 public override void ApplyTo(IConfiguration configuration)
 207                 {
 208                         MutableConfiguration node = new MutableConfiguration(Name, value);
 209                         configuration.Children.Add(node);
 210                 }
 211         }
 212
 213         #endregion
 214
 215         #region ComplexChild
 216
 217         /// <summary>
 218         /// Represents a complex child node.
 219         /// </summary>
 220         public class ComplexChild : Node
 221         {
 222                 private readonly IConfiguration configNode;
 223
 224                 internal ComplexChild(String name, IConfiguration configNode)
 225                         : base(name)
 226                 {
 227                         this.configNode = configNode;
 228                 }
 229
 230                 /// <summary>
 231                 /// Applies the configuration node.
 232                 /// </summary>
 233                 /// <param name="configuration">The configuration.</param>
 234                 public override void ApplyTo(IConfiguration configuration)
 235                 {
 236                         MutableConfiguration node = new MutableConfiguration(Name);
 237                         node.Children.Add(configNode);
 238                         configuration.Children.Add(node);
 239                 }
 240         }
 241
 242         #endregion
 243
 244         #region CompoundChild
 245
 246         /// <summary>
 247         /// Represents a compound child node.
 248         /// </summary>
 249         public class CompoundChild : Node
 250         {
 251                 private readonly Node[] childNodes;
 252
 253                 internal CompoundChild(String name, Node[] childNodes)
 254                         : base(name)
 255                 {
 256                         this.childNodes = childNodes;
 257                 }
 258
 259                 /// <summary>
 260                 /// Applies the configuration node.
 261                 /// </summary>
 262                 /// <param name="configuration">The configuration.</param>
 263                 public override void ApplyTo(IConfiguration configuration)
 264                 {
 265                         MutableConfiguration node = new MutableConfiguration(Name);
 266                         foreach (Node childNode in childNodes)
 267                         {
 268                                 childNode.ApplyTo( node );
 269                         }
 270                         configuration.Children.Add(node);
 271                 }
 272         }
 273
 274         #endregion
 275 }