Core/Castle.Core/StringObjectDictionaryAdapter.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.Core
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20
  21         public class StringObjectDictionaryAdapter : IDictionary<string,object>
  22         {
  23                 private readonly IDictionary dictionary;
  24
  25                 public StringObjectDictionaryAdapter(IDictionary dictionary)
  26                 {
  27                         this.dictionary = dictionary;
  28                 }
  29
  30                 bool IDictionary<string, object>.ContainsKey(string key)
  31                 {
  32                         return dictionary.Contains(key);
  33                 }
  34
  35                 void IDictionary<string, object>.Add(string key, object value)
  36                 {
  37                         throw new NotImplementedException();
  38                 }
  39
  40                 bool IDictionary<string, object>.Remove(string key)
  41                 {
  42                         throw new NotImplementedException();
  43                 }
  44
  45                 bool IDictionary<string, object>.TryGetValue(string key, out object value)
  46                 {
  47                         value = null;
  48                         if (dictionary.Contains(key))
  49                         {
  50                                 value = dictionary[key];
  51                                 return true;
  52                         }
  53                         else
  54                         {
  55                                 return false;
  56                         }
  57                 }
  58
  59                 object IDictionary<string, object>.this[string key]
  60                 {
  61                         get { return dictionary[key]; }
  62                         set { throw new NotImplementedException(); }
  63                 }
  64
  65                 ICollection<string> IDictionary<string, object>.Keys
  66                 {
  67                         get
  68                         {
  69                                 string[] keys = new string[Count];
  70                                 dictionary.Keys.CopyTo(keys, 0);
  71                                 return keys;
  72                         }
  73                 }
  74
  75                 ICollection<object> IDictionary<string, object>.Values
  76                 {
  77                         get
  78                         {
  79                                 object[] values = new object[Count];
  80                                 dictionary.Values.CopyTo(values, 0);
  81                                 return values;
  82                         }
  83                 }
  84
  85                 void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> item)
  86                 {
  87                         throw new NotImplementedException();
  88                 }
  89
  90                 bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> item)
  91                 {
  92                         throw new NotImplementedException();
  93                 }
  94
  95                 void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
  96                 {
  97                         throw new NotImplementedException();
  98                 }
  99
 100                 bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> item)
 101                 {
 102                         throw new NotImplementedException();
 103                 }
 104
 105                 IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator()
 106                 {
 107                         return new EnumeratorAdapter(this);
 108                 }
 109
 110                 public bool Contains(object key)
 111                 {
 112                         return dictionary.Contains(key);
 113                 }
 114
 115                 public void Add(object key, object value)
 116                 {
 117                         dictionary.Add(key, value);
 118                 }
 119
 120                 public void Clear()
 121                 {
 122                         dictionary.Clear();
 123                 }
 124
 125                 public void Remove(object key)
 126                 {
 127                         dictionary.Remove(key);
 128                 }
 129
 130                 public object this[object key]
 131                 {
 132                         get { return dictionary[key]; }
 133                         set { dictionary[key] = value; }
 134                 }
 135
 136                 public ICollection Keys
 137                 {
 138                         get { return dictionary.Keys; }
 139                 }
 140
 141                 public ICollection Values
 142                 {
 143                         get { return dictionary.Values; }
 144                 }
 145
 146                 public bool IsReadOnly
 147                 {
 148                         get { return dictionary.IsReadOnly; }
 149                 }
 150
 151                 public bool IsFixedSize
 152                 {
 153                         get { return dictionary.IsFixedSize; }
 154                 }
 155
 156                 public void CopyTo(Array array, int index)
 157                 {
 158                         dictionary.CopyTo(array, index);
 159                 }
 160
 161                 public int Count
 162                 {
 163                         get { return dictionary.Count; }
 164                 }
 165
 166                 public object SyncRoot
 167                 {
 168                         get { return dictionary.SyncRoot; }
 169                 }
 170
 171                 public bool IsSynchronized
 172                 {
 173                         get { return dictionary.IsSynchronized; }
 174                 }
 175
 176                 public IEnumerator GetEnumerator()
 177                 {
 178                         return ((IEnumerable) dictionary).GetEnumerator();
 179                 }
 180
 181                 internal class EnumeratorAdapter : IEnumerator<KeyValuePair<string, object>>
 182                 {
 183                         private readonly StringObjectDictionaryAdapter adapter;
 184                         private IEnumerator<string> keyEnumerator;
 185                         private string currentKey;
 186                         private object currentValue;
 187
 188                         public EnumeratorAdapter(StringObjectDictionaryAdapter adapter)
 189                         {
 190                                 this.adapter = adapter;
 191                                 keyEnumerator = ((IDictionary<string, object>) adapter).Keys.GetEnumerator();
 192                         }
 193
 194                         public bool MoveNext()
 195                         {
 196                                 if (keyEnumerator.MoveNext())
 197                                 {
 198                                         currentKey = keyEnumerator.Current;
 199                                         currentValue = adapter[currentKey];
 200                                         return true;
 201                                 }
 202
 203                                 return false;
 204                         }
 205
 206                         public void Reset()
 207                         {
 208                                 keyEnumerator.Reset();
 209                         }
 210
 211                         public object Current
 212                         {
 213                                 get { return new KeyValuePair<string, object>(currentKey, currentValue); }
 214                         }
 215
 216                         KeyValuePair<string, object> IEnumerator<KeyValuePair<string, object>>.Current
 217                         {
 218                                 get { return new KeyValuePair<string, object>(currentKey, currentValue); }
 219                         }
 220
 221                         public void Dispose()
 222                         {
 223                         }
 224                 }
 225         }
 226 }