mcs/class/System.Web/System.Web.UI/StateBag.cs

   1
   2 //
   3 // Permission is hereby granted, free of charge, to any person obtaining
   4 // a copy of this software and associated documentation files (the
   5 // "Software"), to deal in the Software without restriction, including
   6 // without limitation the rights to use, copy, modify, merge, publish,
   7 // distribute, sublicense, and/or sell copies of the Software, and to
   8 // permit persons to whom the Software is furnished to do so, subject to
   9 // the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be
  12 // included in all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  15 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  18 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  19 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21 //
  22 /**
  23  * Namespace: System.Web.UI
  24  * Class:     StateBag
  25  *
  26  * Author:  Gaurav Vaish
  27  * Maintainer: gvaish@iitk.ac.in
  28  * Implementation: yes
  29  * Contact: <gvaish@iitk.ac.in>
  30  * Status:  100%
  31  *
  32  * (C) Gaurav Vaish (2001)
  33  */
  34
  35 using System;
  36 using System.Web;
  37 using System.Collections;
  38 using System.Collections.Specialized;
  39
  40 namespace System.Web.UI
  41 {
  42         public sealed class StateBag : IStateManager, IDictionary, ICollection, IEnumerable
  43         {
  44                 private bool ignoreCase;
  45                 private bool marked;
  46                 private HybridDictionary bag;
  47
  48                 public StateBag (bool ignoreCase)
  49                 {
  50                         Initialize (ignoreCase);
  51                 }
  52
  53                 public StateBag ()
  54                 {
  55                         Initialize (false);
  56                 }
  57
  58                 private void Initialize (bool ignoreCase)
  59                 {
  60                         this.ignoreCase = ignoreCase;
  61                         marked = false;
  62                         bag = new HybridDictionary (ignoreCase);
  63                 }
  64
  65                 public int Count {
  66                         get { return bag.Count; }
  67                 }
  68
  69
  70                 public object this [string key] {
  71                         get {
  72                                 if (key == null || key.Length == 0)
  73                                         throw new ArgumentException (HttpRuntime.FormatResourceString ("Key_Cannot_Be_Null"));
  74
  75                                 object val = bag [key];
  76
  77                                 if (val is StateItem)
  78                                         return ((StateItem) val).Value;
  79
  80                                 return null; //
  81                         }
  82
  83                         set { Add (key, value); }
  84                 }
  85
  86                 object IDictionary.this [object key] {
  87                         get { return this [(string) key] as object; }
  88
  89                         set { Add ((string) key, value); }
  90                 }
  91
  92                 public ICollection Keys {
  93                         get { return bag.Keys; }
  94                 }
  95
  96                 public ICollection Values {
  97                         get { return bag.Values; }
  98                 }
  99
 100                 public StateItem Add (string key, object value)
 101                 {
 102                         if (key == null || key.Length == 0)
 103                                 throw new ArgumentException (HttpRuntime.FormatResourceString ("Key_Cannot_Be_Null"));
 104
 105                         StateItem val = bag [key] as StateItem; //don't throw exception when null
 106                         if(val == null) {
 107                                 if(value != null || marked) {
 108                                         val = new StateItem (value);
 109                                         bag.Add (key, val);
 110                                 }
 111                         }
 112                         else if (value == null && !marked)
 113                                 bag.Remove (key);
 114                         else
 115                                 val.Value = value;
 116
 117                         if (val != null && marked) {
 118                                 val.IsDirty = true;
 119                         }
 120
 121                         return val;
 122                 }
 123
 124                 public void Clear ()
 125                 {
 126                         bag.Clear ();
 127                 }
 128
 129                 public IDictionaryEnumerator GetEnumerator ()
 130                 {
 131                         return bag.GetEnumerator ();
 132                 }
 133
 134                 public bool IsItemDirty (string key)
 135                 {
 136                         object o = bag [key];
 137
 138                         if (o is StateItem)
 139                                 return ((StateItem) o).IsDirty;
 140
 141                         return false;
 142                 }
 143
 144                 public void Remove (string key)
 145                 {
 146                         bag.Remove (key);
 147                 }
 148
 149                 /// <summary>
 150                 /// Undocumented
 151                 /// </summary>
 152                 public void SetItemDirty (string key, bool dirty)
 153                 {
 154                         if (bag [key] is StateItem)
 155                                 ((StateItem) bag [key]).IsDirty = dirty;
 156                 }
 157
 158                 internal bool IsTrackingViewState {
 159                         get { return marked; }
 160                 }
 161
 162                 internal void LoadViewState (object state)
 163                 {
 164                         if(state!=null) {
 165                                 Pair pair = (Pair) state;
 166                                 ArrayList keyList = (ArrayList) (pair.First);
 167                                 ArrayList valList = (ArrayList) (pair.Second);
 168
 169                                 int valCount = valList.Count;
 170                                 for(int i = 0; i < keyList.Count; i++) {
 171                                         if (i < valCount)
 172                                                 Add ((string) keyList [i], valList [i]);
 173                                         else
 174                                                 Add ((string) keyList [i], null);
 175                                 }
 176                         }
 177                 }
 178
 179                 internal object SaveViewState ()
 180                 {
 181                         if(bag.Count > 0) {
 182                                 ArrayList keyList = null, valList = null;
 183
 184                                 foreach (string key in bag.Keys) {
 185                                         StateItem item = (StateItem) bag [key];
 186
 187                                         if (item.IsDirty) {
 188                                                 if (keyList == null) {
 189                                                         keyList = new ArrayList ();
 190                                                         valList = new ArrayList ();
 191                                                 }
 192
 193                                                 keyList.Add (key);
 194                                                 valList.Add (item.Value);
 195                                         }
 196                                 }
 197
 198                                 if (keyList!=null)
 199                                         return new Pair (keyList, valList);
 200                         }
 201                         return null;
 202                 }
 203
 204                 internal void TrackViewState()
 205                 {
 206                         marked = true;
 207                 }
 208
 209                 IEnumerator IEnumerable.GetEnumerator ()
 210                 {
 211                         return GetEnumerator ();
 212                 }
 213
 214                 void IStateManager.LoadViewState (object savedState)
 215                 {
 216                         LoadViewState (savedState);
 217                 }
 218
 219                 object IStateManager.SaveViewState ()
 220                 {
 221                         return SaveViewState ();
 222                 }
 223
 224                 void IStateManager.TrackViewState ()
 225                 {
 226                         TrackViewState ();
 227                 }
 228
 229                 bool IStateManager.IsTrackingViewState {
 230                         get { return IsTrackingViewState; }
 231                 }
 232
 233                 void ICollection.CopyTo (Array array, int index)
 234                 {
 235                         Values.CopyTo (array, index);
 236                 }
 237
 238                 bool ICollection.IsSynchronized {
 239                         get { return false; }
 240                 }
 241
 242                 object ICollection.SyncRoot
 243                 {
 244                         get { return this; }
 245                 }
 246
 247                 void IDictionary.Add (object key, object value)
 248                 {
 249                         Add ((string) key, value);
 250                 }
 251
 252                 void IDictionary.Remove (object key)
 253                 {
 254                         Remove ((string) key);
 255                 }
 256
 257                 bool IDictionary.Contains (object key)
 258                 {
 259                         return bag.Contains ((string) key);
 260                 }
 261
 262                 bool IDictionary.IsFixedSize {
 263                         get { return false; }
 264                 }
 265
 266                 bool IDictionary.IsReadOnly {
 267                         get { return false; }
 268                 }
 269         }
 270 }