Components/Binder/Castle.Components.Binder/TreeBuilder.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.Specialized;
  19         using System.Web;
  20
  21         /// <summary>
  22         ///
  23         /// </summary>
  24         public class TreeBuilder
  25         {
  26                 public CompositeNode BuildSourceNode(NameValueCollection nameValueCollection)
  27                 {
  28                         CompositeNode root = new CompositeNode("root");
  29
  30                         PopulateTree(root, nameValueCollection);
  31
  32                         return root;
  33                 }
  34
  35                 public void PopulateTree(CompositeNode root, NameValueCollection nameValueCollection)
  36                 {
  37                         foreach(String key in nameValueCollection.Keys)
  38                         {
  39                                 if (key == null) continue;
  40                                 string singleKeyName = NormalizeKey(key);
  41                                 String[] values = nameValueCollection.GetValues(key);
  42
  43                                 if (values == null) continue;
  44
  45                                 if (values.Length == 1 && key.EndsWith("[]"))
  46                                 {
  47                                         if (values[0] == string.Empty)
  48                                         {
  49                                                 ProcessNode(root, typeof(String[]), singleKeyName, new string[0]);
  50                                         }
  51                                         else
  52                                         {
  53                                                 values = values[0].Split(',');
  54                                                 ProcessNode(root, typeof(String[]), singleKeyName, values);
  55                                         }
  56                                 }
  57                                 else if (values.Length == 1)
  58                                 {
  59                                         ProcessNode(root, typeof(String), key, values[0]);
  60                                 }
  61                                 else
  62                                 {
  63                                         ProcessNode(root, typeof(String[]), singleKeyName, values);
  64                                 }
  65                         }
  66                 }
  67
  68                 public void PopulateTree(CompositeNode root, HttpFileCollection fileCollection)
  69                 {
  70                         foreach(String key in fileCollection.Keys)
  71                         {
  72                                 if (key == null) continue;
  73
  74                                 HttpPostedFile value = fileCollection.Get(key);
  75
  76                                 if (value == null) continue;
  77
  78                                 ProcessNode(root, typeof(HttpPostedFile), key, value);
  79                         }
  80                 }
  81
  82                 private string NormalizeKey(string key)
  83                 {
  84                                 return key.EndsWith("[]") ? key.Substring(0, key.Length - 2) : key;
  85                 }
  86
  87                 private void ProcessNode(CompositeNode node, Type type, String name, object value)
  88                 {
  89                         if (name == null || name == String.Empty)
  90                         {
  91                                 // Ignore
  92                                 return;
  93                         }
  94                         if (name[0] == '.' || name[0] == '[' || name[0] == ']')
  95                         {
  96                                 AddLeafNode(node, type, name, value);
  97                                 return;
  98                         }
  99
 100                         int dotIndex = name.IndexOf('.');
 101                         int startBracketIndex = name.IndexOf('[');
 102
 103                         if (dotIndex != -1 && (startBracketIndex == -1 || dotIndex < startBracketIndex))
 104                         {
 105                                 // Child node
 106
 107                                 String childNodeName = name.Substring(0, dotIndex);
 108
 109                                 CompositeNode newNode = GetOrCreateCompositeNode(node, childNodeName);
 110
 111                                 ProcessNode(newNode, type, name.Substring(dotIndex + 1), value);
 112                         }
 113                         else if (startBracketIndex != -1)
 114                         {
 115                                 // Indexed node
 116
 117                                 int endBracket = name.IndexOf(']');
 118
 119                                 if (endBracket == -1)
 120                                 {
 121                                         // TODO: Something is wrong
 122                                 }
 123
 124                                 String enclosed = name.Substring(startBracketIndex + 1, endBracket - startBracketIndex - 1);
 125
 126                                 if (enclosed == null || enclosed == String.Empty)
 127                                 {
 128                                         // TODO: Something is wrong
 129                                 }
 130
 131                                 String indexedNodeName = name.Substring(0, startBracketIndex);
 132
 133                                 CompositeNode newNode = GetOrCreateIndexedNode(node, indexedNodeName);
 134
 135                                 if (endBracket + 1 == name.Length) // entries like emails[0] = value
 136                                 {
 137                                         AddLeafNode(newNode, type, value);
 138                                 }
 139                                 else
 140                                 {
 141                                         name = name.Substring(endBracket + 2); // entries like customer[0].name = value
 142
 143                                         newNode = GetOrCreateCompositeNode(newNode, enclosed);
 144
 145                                         ProcessNode(newNode, type, name, value);
 146                                 }
 147                         }
 148                         else
 149                         {
 150                                 AddLeafNode(node, type, name, value);
 151                         }
 152                 }
 153
 154                 private void AddLeafNode(CompositeNode parent, Type type, object value)
 155                 {
 156                         AddLeafNode(parent, type, String.Empty, value);
 157                 }
 158
 159                 private void AddLeafNode(CompositeNode parent, Type type, String nodeName, object value)
 160                 {
 161                         parent.AddChildNode(new LeafNode(type, nodeName, value));
 162                 }
 163
 164                 private CompositeNode GetOrCreateCompositeNode(CompositeNode parent, string nodeName)
 165                 {
 166                         Node node = parent.GetChildNode(nodeName);
 167
 168                         if (node != null && node.NodeType != NodeType.Composite)
 169                         {
 170                                 throw new BindingException("Attempt to create or obtain a composite node " +
 171                                         "named {0}, but a node with the same exists with the type {1}", nodeName, node.NodeType);
 172                         }
 173
 174                         if (node == null)
 175                         {
 176                                 node = new CompositeNode(nodeName);
 177                                 parent.AddChildNode(node);
 178                         }
 179
 180                         return (CompositeNode) node;
 181                 }
 182
 183                 private IndexedNode GetOrCreateIndexedNode(CompositeNode parent, string nodeName)
 184                 {
 185                         Node node = parent.GetChildNode(nodeName);
 186
 187                         if (node != null && node.NodeType != NodeType.Indexed)
 188                         {
 189                                 throw new BindingException("Attempt to create or obtain an indexed node " +
 190                                         "named {0}, but a node with the same exists with the type {1}", nodeName, node.NodeType);
 191                         }
 192
 193                         if (node == null)
 194                         {
 195                                 node = new IndexedNode(nodeName);
 196                                 parent.AddChildNode(node);
 197                         }
 198
 199                         return (IndexedNode) node;
 200                 }
 201         }
 202 }