Components/Binder/Castle.Components.Binder/Node.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.Components.Binder
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20
  21         public enum NodeType
  22         {
  23                 Unspecified,
  24                 Composite,
  25                 Indexed,
  26                 Leaf
  27         }
  28
  29         public abstract class Node
  30         {
  31                 private readonly String name;
  32                 private readonly NodeType nodeType;
  33                 private Node parent;
  34
  35                 protected Node(String name, NodeType nodeType)
  36                 {
  37                         this.name = name;
  38                         this.nodeType = nodeType;
  39                 }
  40
  41                 public String Name
  42                 {
  43                         get { return name;}
  44                 }
  45
  46                 public NodeType NodeType
  47                 {
  48                         get { return nodeType; }
  49                 }
  50
  51                 public String FullName
  52                 {
  53                         get
  54                         {
  55                                 if (Parent != null)
  56                                 {
  57                                         return string.Format("{0}.{1}", Parent.FullName, Name);
  58                                 }
  59
  60                                 return Name;
  61                         }
  62                 }
  63
  64                 public Node Parent
  65                 {
  66                         get { return parent; }
  67                         set { parent = value; }
  68                 }
  69         }
  70
  71         public class CompositeNode : Node
  72         {
  73                 private readonly HybridDictionary name2Node = new HybridDictionary(true);
  74                 private readonly ArrayList nodeList = new ArrayList();
  75
  76                 public CompositeNode(String name) : base(name, NodeType.Composite)
  77                 {
  78                 }
  79
  80                 protected CompositeNode(string name, NodeType nodeType) : base(name, nodeType)
  81                 {
  82                 }
  83
  84                 public void AddChildNode(Node node)
  85                 {
  86                         if (node == null) throw new ArgumentNullException("node");
  87
  88                         name2Node[node.Name] = node;
  89                         nodeList.Add(node);
  90                         node.Parent = this;
  91                 }
  92
  93                 public Node GetChildNode(String name)
  94                 {
  95                         int index = name.IndexOf(".");
  96
  97                         if (!name2Node.Contains(name) && index != -1)
  98                         {
  99                                 string firstNodeName = name.Substring(0, index);
 100                                 string remainingName = name.Substring(index + 1);
 101
 102                                 Node innerNode = (Node)name2Node[firstNodeName];
 103
 104                                 if (innerNode != null && innerNode.NodeType == NodeType.Composite)
 105                                 {
 106                                         return (innerNode as CompositeNode).GetChildNode(remainingName);
 107                                 }
 108
 109                                 throw new BindingException("node is not Composite but still need to recurse to {0}", remainingName);
 110                         }
 111
 112                         return (Node) name2Node[name];
 113                 }
 114
 115                 public Node[] ChildNodes
 116                 {
 117                         get { return (Node[]) nodeList.ToArray(typeof(Node)); }
 118                 }
 119
 120                 public int ChildrenCount
 121                 {
 122                         get { return nodeList.Count; }
 123                 }
 124         }
 125
 126         public class IndexedNode : CompositeNode
 127         {
 128                 public IndexedNode(string name) : base(name, NodeType.Indexed)
 129                 {
 130                 }
 131         }
 132
 133         public class LeafNode : Node
 134         {
 135                 private readonly Type type;
 136                 private readonly object value;
 137
 138                 public LeafNode(Type type, string name, object value) : base(name, NodeType.Leaf)
 139                 {
 140                         if (type == null) throw new ArgumentNullException("type", "A type must be specified");
 141                         if (value == null) throw new ArgumentNullException("value", "A value must be specified");
 142
 143                         this.type = type;
 144                         this.value = value;
 145                 }
 146
 147                 public Type ValueType
 148                 {
 149                         get { return type; }
 150                 }
 151
 152                 public bool IsArray
 153                 {
 154                         get { return type.IsArray; }
 155                 }
 156
 157                 public object Value
 158                 {
 159                         get { return value; }
 160                 }
 161         }
 162 }