Components/DictionaryAdapter/Castle.Components.DictionaryAdapter/Attributes/DictionaryStringListAttribute.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.Components.DictionaryAdapter
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.ComponentModel;
  21         using System.Text;
  22
  23         /// <summary>
  24         /// Identifies a property should be represented as a
  25         /// delimited string value.
  26         /// </summary>
  27         [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
  28         public class DictionaryStringListAttribute : Attribute,
  29                                                      IDictionaryPropertyGetter,
  30                                                      IDictionaryPropertySetter
  31         {
  32                 private char separator = ',';
  33
  34                 /// <summary>
  35                 /// Gets the separator.
  36                 /// </summary>
  37                 public char Separator
  38                 {
  39                         get { return separator; }
  40                         set { separator = value; }
  41                 }
  42
  43                 #region IDictionaryPropertyGetter
  44
  45                 object IDictionaryPropertyGetter.GetPropertyValue(
  46                         IDictionaryAdapterFactory factory, IDictionary dictionary,
  47                         string key, object storedValue, PropertyDescriptor property)
  48                 {
  49                         Type propertyType = property.PropertyType;
  50
  51                         if (storedValue == null ||
  52                             !storedValue.GetType().IsInstanceOfType(propertyType))
  53                         {
  54                                 if (propertyType.IsGenericType)
  55                                 {
  56                                         Type genericDef = propertyType.GetGenericTypeDefinition();
  57
  58                                         if (genericDef == typeof(IList<>) ||
  59                                             genericDef == typeof(ICollection<>) ||
  60                                             genericDef == typeof(List<>) ||
  61                                             genericDef == typeof(IEnumerable<>))
  62                                         {
  63                                                 Type paramType = propertyType.GetGenericArguments()[0];
  64                                                 TypeConverter converter = TypeDescriptor.GetConverter(paramType);
  65
  66                                                 if (converter != null && converter.CanConvertFrom(typeof(string)))
  67                                                 {
  68                                                         Type genericList = typeof(StringListWrapper<>).MakeGenericType(
  69                                                                 new Type[] {paramType});
  70                                                         return Activator.CreateInstance(genericList, key, storedValue,
  71                                                                                         separator, dictionary);
  72                                                 }
  73                                         }
  74                                 }
  75                         }
  76
  77                         return storedValue;
  78                 }
  79
  80                 #endregion
  81
  82                 #region IDictionaryPropertySetter Members
  83
  84                 bool IDictionaryPropertySetter.SetPropertyValue(
  85                         IDictionaryAdapterFactory factory, IDictionary dictionary,
  86                         string key, ref object value, PropertyDescriptor property)
  87                 {
  88                         IEnumerable enumerable = value as IEnumerable;
  89                         if (enumerable != null)
  90                         {
  91                                 value = BuildString(enumerable, separator);
  92                         }
  93                         return true;
  94                 }
  95
  96                 #endregion
  97
  98                 internal static string BuildString(IEnumerable enumerable, char separator)
  99                 {
 100                         bool first = true;
 101                         StringBuilder builder = new StringBuilder();
 102
 103                         foreach(object item in enumerable)
 104                         {
 105                                 if (first)
 106                                 {
 107                                         first = false;
 108                                 }
 109                                 else
 110                                 {
 111                                         builder.Append(separator);
 112                                 }
 113
 114                                 builder.Append(item.ToString());
 115                         }
 116
 117                         return builder.ToString();
 118                 }
 119         }
 120
 121         #region StringList
 122
 123         internal class StringListWrapper<T> : IList<T>
 124         {
 125                 private readonly string key;
 126                 private readonly char separator;
 127                 private readonly IDictionary dictionary;
 128                 private readonly List<T> inner;
 129
 130                 public StringListWrapper(string key, string list,
 131                                          char separator, IDictionary dictionary)
 132                 {
 133                         this.key = key;
 134                         this.separator = separator;
 135                         this.dictionary = dictionary;
 136                         inner = new List<T>();
 137
 138                         ParseList(list);
 139                 }
 140
 141                 #region IList<T> Members
 142
 143                 public int IndexOf(T item)
 144                 {
 145                         return inner.IndexOf(item);
 146                 }
 147
 148                 public void Insert(int index, T item)
 149                 {
 150                         inner.Insert(index, item);
 151                         SynchronizeDictionary();
 152                 }
 153
 154                 public void RemoveAt(int index)
 155                 {
 156                         inner.RemoveAt(index);
 157                         SynchronizeDictionary();
 158                 }
 159
 160                 public T this[int index]
 161                 {
 162                         get { return inner[index]; }
 163                         set
 164                         {
 165                                 inner[index] = value;
 166                                 SynchronizeDictionary();
 167                         }
 168                 }
 169
 170                 #endregion
 171
 172                 #region ICollection<T> Members
 173
 174                 public void Add(T item)
 175                 {
 176                         inner.Add(item);
 177                         SynchronizeDictionary();
 178                 }
 179
 180                 public void Clear()
 181                 {
 182                         inner.Clear();
 183                         SynchronizeDictionary();
 184                 }
 185
 186                 public bool Contains(T item)
 187                 {
 188                         return inner.Contains(item);
 189                 }
 190
 191                 public void CopyTo(T[] array, int arrayIndex)
 192                 {
 193                         inner.CopyTo(array, arrayIndex);
 194                 }
 195
 196                 public int Count
 197                 {
 198                         get { return inner.Count; }
 199                 }
 200
 201                 public bool IsReadOnly
 202                 {
 203                         get { return false; }
 204                 }
 205
 206                 public bool Remove(T item)
 207                 {
 208                         if (inner.Remove(item))
 209                         {
 210                                 SynchronizeDictionary();
 211                                 return true;
 212                         }
 213                         return false;
 214                 }
 215
 216                 #endregion
 217
 218                 #region IEnumerable<T> Members
 219
 220                 public IEnumerator<T> GetEnumerator()
 221                 {
 222                         return inner.GetEnumerator();
 223                 }
 224
 225                 #endregion
 226
 227                 #region IEnumerable Members
 228
 229                 IEnumerator IEnumerable.GetEnumerator()
 230                 {
 231                         return inner.GetEnumerator();
 232                 }
 233
 234                 #endregion
 235
 236                 private void ParseList(string list)
 237                 {
 238                         if (list != null)
 239                         {
 240                                 TypeConverter converter = TypeDescriptor.GetConverter(typeof(T));
 241
 242                                 foreach(string item in list.Split(separator))
 243                                 {
 244                                         inner.Add((T) converter.ConvertFrom(item));
 245                                 }
 246                         }
 247                 }
 248
 249                 private void SynchronizeDictionary()
 250                 {
 251                         dictionary[key] = DictionaryStringListAttribute.
 252                                 BuildString(inner, separator);
 253                 }
 254         }
 255
 256         #endregion
 257 }