?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add ISafeSerializationData
[mcs.git] / class / System / System.Collections.Specialized / NameObjectCollectionBase.cs
blobc934a328c053dd2bc49099fedcbb28e6471c9547
1 //
2 // System.Collections.Specialized.NameObjectCollectionBase.cs
3 //
4 // Author:
5 // Gleb Novodran
6 // Andreas Nahr (ClassDevelopment@A-SoftTech.com)
7 //
8 // (C) Ximian, Inc. http://www.ximian.com
9 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
18 //
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 //
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30
31 using System;
32 using System.Collections;
33 using System.Runtime.Serialization;
34
35 namespace System.Collections.Specialized
36 {
37 [Serializable]
38 public abstract class NameObjectCollectionBase : ICollection, IEnumerable, ISerializable, IDeserializationCallback
39 {
40 private Hashtable m_ItemsContainer;
41 /// <summary>
42 /// Extends Hashtable based Items container to support storing null-key pairs
43 /// </summary>
44 private _Item m_NullKeyItem;
45 private ArrayList m_ItemsArray;
46 private IHashCodeProvider m_hashprovider;
47 private IComparer m_comparer;
48 private int m_defCapacity;
49 private bool m_readonly;
50 SerializationInfo infoCopy;
51 private KeysCollection keyscoll;
52 #if NET_2_0
53 private IEqualityComparer equality_comparer;
54
55 internal IEqualityComparer EqualityComparer {
56 get { return equality_comparer; }
57 }
58 #endif
59 internal IComparer Comparer {
60 get {return m_comparer;}
61 }
62
63 internal IHashCodeProvider HashCodeProvider {
64 get {return m_hashprovider;}
65 }
66
67 internal class _Item
68 {
69 public string key;
70 public object value;
71 public _Item(string key, object value)
72 {
73 this.key = key;
74 this.value = value;
75 }
76 }
77 /// <summary>
78 /// Implements IEnumerable interface for KeysCollection
79 /// </summary>
80 [Serializable]
81 internal class _KeysEnumerator : IEnumerator
82 {
83 private NameObjectCollectionBase m_collection;
84 private int m_position;
85
86 internal _KeysEnumerator(NameObjectCollectionBase collection)
87 {
88 m_collection = collection;
89 Reset();
90 }
91 public object Current
92 {
93
94 get{
95 if ((m_position<m_collection.Count)||(m_position<0))
96 return m_collection.BaseGetKey(m_position);
97 else
98 throw new InvalidOperationException();
99 }
100
101 }
102 public bool MoveNext()
103 {
104 return ((++m_position) < m_collection.Count);
105 }
106 public void Reset()
107 {
108 m_position = -1;
109 }
110 }
111
112 /// <summary>
113 /// SDK: Represents a collection of the String keys of a collection.
114 /// </summary>
115 [Serializable]
116 public class KeysCollection : ICollection, IEnumerable
117 {
118 private NameObjectCollectionBase m_collection;
119
120 internal KeysCollection (NameObjectCollectionBase collection)
121 {
122 this.m_collection = collection;
123 }
124
125 public virtual string Get( int index )
126 {
127 return m_collection.BaseGetKey(index);
128 }
129
130 // ICollection methods -----------------------------------
131 void ICollection.CopyTo (Array array, int arrayIndex)
132 {
133 ArrayList items = m_collection.m_ItemsArray;
134 #if NET_2_0
135 if (null == array)
136 throw new ArgumentNullException ("array");
137
138 if (arrayIndex < 0)
139 throw new ArgumentOutOfRangeException ("arrayIndex");
140
141 if ((array.Length > 0) && (arrayIndex >= array.Length))
142 throw new ArgumentException ("arrayIndex is equal to or greater than array.Length");
143
144 if (arrayIndex + items.Count > array.Length)
145 throw new ArgumentException ("Not enough room from arrayIndex to end of array for this KeysCollection");
146 #endif
147
148 if (array != null && array.Rank > 1)
149 throw new ArgumentException ("array is multidimensional");
150
151 object[] objArray = (object[])array;
152 for (int i = 0; i < items.Count; i++, arrayIndex++)
153 objArray [arrayIndex] = ((_Item)items [i]).key;
154 }
155
156 bool ICollection.IsSynchronized
157 {
158 get{
159 return false;
160 }
161 }
162 object ICollection.SyncRoot
163 {
164 get{
165 return m_collection;
166 }
167 }
168 /// <summary>
169 /// Gets the number of keys in the NameObjectCollectionBase.KeysCollection
170 /// </summary>
171 public int Count
172 {
173 get{
174 return m_collection.Count;
175 }
176 }
177
178 public string this [int index] {
179 get { return Get (index); }
180 }
181
182 // IEnumerable methods --------------------------------
183 /// <summary>
184 /// SDK: Returns an enumerator that can iterate through the NameObjectCollectionBase.KeysCollection.
185 /// </summary>
186 /// <returns></returns>
187 public IEnumerator GetEnumerator()
188 {
189 return new _KeysEnumerator(m_collection);
190 }
191 }
192
193 //--------------- Protected Instance Constructors --------------
194
195 /// <summary>
196 /// SDK: Initializes a new instance of the NameObjectCollectionBase class that is empty.
197 /// </summary>
198 protected NameObjectCollectionBase ()
199 {
200 m_readonly = false;
201 #if NET_1_0
202 m_hashprovider = CaseInsensitiveHashCodeProvider.Default;
203 m_comparer = CaseInsensitiveComparer.Default;
204 #else
205 m_hashprovider = CaseInsensitiveHashCodeProvider.DefaultInvariant;
206 m_comparer = CaseInsensitiveComparer.DefaultInvariant;
207 #endif
208 m_defCapacity = 0;
209 Init();
210 }
211
212 protected NameObjectCollectionBase( int capacity )
213 {
214 m_readonly = false;
215 #if NET_1_0
216 m_hashprovider = CaseInsensitiveHashCodeProvider.Default;
217 m_comparer = CaseInsensitiveComparer.Default;
218 #else
219 m_hashprovider = CaseInsensitiveHashCodeProvider.DefaultInvariant;
220 m_comparer = CaseInsensitiveComparer.DefaultInvariant;
221 #endif
222 m_defCapacity = capacity;
223 Init();
224 }
225
226 #if NET_2_0
227
228 internal NameObjectCollectionBase (IEqualityComparer equalityComparer, IComparer comparer, IHashCodeProvider hcp)
229 {
230 equality_comparer = equalityComparer;
231 m_comparer = comparer;
232 m_hashprovider = hcp;
233 m_readonly = false;
234 m_defCapacity = 0;
235 Init ();
236 }
237
238 protected NameObjectCollectionBase (IEqualityComparer equalityComparer) : this( (equalityComparer == null ? StringComparer.InvariantCultureIgnoreCase : equalityComparer), null, null)
239 {
240 }
241
242 [Obsolete ("Use NameObjectCollectionBase(IEqualityComparer)")]
243 #endif
244 protected NameObjectCollectionBase( IHashCodeProvider hashProvider, IComparer comparer )
245 {
246 m_comparer = comparer;
247 m_hashprovider = hashProvider;
248 m_readonly = false;
249 m_defCapacity = 0;
250 Init ();
251 }
252
253 protected NameObjectCollectionBase (SerializationInfo info, StreamingContext context)
254 {
255 infoCopy = info;
256 }
257
258 #if NET_2_0
259 protected NameObjectCollectionBase (int capacity, IEqualityComparer equalityComparer)
260 {
261 m_readonly = false;
262 equality_comparer = (equalityComparer == null ? StringComparer.InvariantCultureIgnoreCase : equalityComparer);
263 m_defCapacity = capacity;
264 Init();
265 }
266
267 [Obsolete ("Use NameObjectCollectionBase(int,IEqualityComparer)")]
268 #endif
269 protected NameObjectCollectionBase( int capacity, IHashCodeProvider hashProvider, IComparer comparer )
270 {
271 m_readonly = false;
272
273 m_hashprovider = hashProvider;
274 m_comparer = comparer;
275 m_defCapacity = capacity;
276 Init();
277 }
278
279 private void Init ()
280 {
281 #if NET_2_0
282 if (equality_comparer != null)
283 m_ItemsContainer = new Hashtable (m_defCapacity, equality_comparer);
284 else
285 m_ItemsContainer = new Hashtable (m_defCapacity, m_hashprovider, m_comparer);
286 #else
287 m_ItemsContainer = new Hashtable (m_defCapacity, m_hashprovider, m_comparer);
288 #endif
289 m_ItemsArray = new ArrayList();
290 m_NullKeyItem = null;
291 }
292
293 //--------------- Public Instance Properties -------------------
294
295 public virtual NameObjectCollectionBase.KeysCollection Keys {
296 get {
297 if (keyscoll == null)
298 keyscoll = new KeysCollection (this);
299 return keyscoll;
300 }
301 }
302
303 //--------------- Public Instance Methods ----------------------
304 //
305 /// <summary>
306 /// SDK: Returns an enumerator that can iterate through the NameObjectCollectionBase.
307 ///
308 /// <remark>This enumerator returns the keys of the collection as strings.</remark>
309 /// </summary>
310 /// <returns></returns>
311 public
312 #if NET_2_0
313 virtual
314 #endif
315 IEnumerator GetEnumerator()
316 {
317 return new _KeysEnumerator(this);
318 }
319
320 // ISerializable
321 public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
322 {
323 if (info == null)
324 throw new ArgumentNullException ("info");
325
326 int count = Count;
327 string [] keys = new string [count];
328 object [] values = new object [count];
329 int i = 0;
330 foreach (_Item item in m_ItemsArray) {
331 keys [i] = item.key;
332 values [i] = item.value;
333 i++;
334 }
335
336 #if NET_2_0
337 if (equality_comparer != null) {
338 info.AddValue ("KeyComparer", equality_comparer, typeof (IEqualityComparer));
339 info.AddValue ("Version", 4, typeof (int));
340 } else {
341 info.AddValue ("HashProvider", m_hashprovider, typeof (IHashCodeProvider));
342 info.AddValue ("Comparer", m_comparer, typeof (IComparer));
343 info.AddValue ("Version", 2, typeof (int));
344 }
345 #else
346 info.AddValue ("HashProvider", m_hashprovider, typeof (IHashCodeProvider));
347 info.AddValue ("Comparer", m_comparer, typeof (IComparer));
348 #endif
349 info.AddValue("ReadOnly", m_readonly);
350 info.AddValue("Count", count);
351 info.AddValue("Keys", keys, typeof(string[]));
352 info.AddValue("Values", values, typeof(object[]));
353 }
354
355 // ICollection
356 public virtual int Count
357 {
358 get{
359 return m_ItemsArray.Count;
360 }
361 }
362
363 bool ICollection.IsSynchronized
364 {
365 get { return false; }
366 }
367
368 object ICollection.SyncRoot
369 {
370 get { return this; }
371 }
372
373 void ICollection.CopyTo (Array array, int index)
374 {
375 ((ICollection)Keys).CopyTo (array, index);
376 }
377
378 // IDeserializationCallback
379 public virtual void OnDeserialization (object sender)
380 {
381 SerializationInfo info = infoCopy;
382
383 // If a subclass overrides the serialization constructor
384 // and inplements its own serialization process, infoCopy will
385 // be null and we can ignore this callback.
386 if (info == null)
387 return;
388
389 infoCopy = null;
390 m_hashprovider = (IHashCodeProvider) info.GetValue ("HashProvider",
391 typeof (IHashCodeProvider));
392 #if NET_2_0
393 if (m_hashprovider == null) {
394 equality_comparer = (IEqualityComparer) info.GetValue ("KeyComparer", typeof (IEqualityComparer));
395 } else {
396 m_comparer = (IComparer) info.GetValue ("Comparer", typeof (IComparer));
397 if (m_comparer == null)
398 throw new SerializationException ("The comparer is null");
399 }
400 #else
401 if (m_hashprovider == null)
402 throw new SerializationException ("The hash provider is null");
403
404 m_comparer = (IComparer) info.GetValue ("Comparer", typeof (IComparer));
405 if (m_comparer == null)
406 throw new SerializationException ("The comparer is null");
407 #endif
408 m_readonly = info.GetBoolean ("ReadOnly");
409 string [] keys = (string []) info.GetValue ("Keys", typeof (string []));
410 if (keys == null)
411 throw new SerializationException ("keys is null");
412
413 object [] values = (object []) info.GetValue ("Values", typeof (object []));
414 if (values == null)
415 throw new SerializationException ("values is null");
416
417 Init ();
418 int count = keys.Length;
419 for (int i = 0; i < count; i++)
420 BaseAdd (keys [i], values [i]);
421 }
422
423 //--------------- Protected Instance Properties ----------------
424 /// <summary>
425 /// SDK: Gets or sets a value indicating whether the NameObjectCollectionBase instance is read-only.
426 /// </summary>
427 protected bool IsReadOnly
428 {
429 get{
430 return m_readonly;
431 }
432 set{
433 m_readonly=value;
434 }
435 }
436
437 //--------------- Protected Instance Methods -------------------
438 /// <summary>
439 /// Adds an Item with the specified key and value into the <see cref="NameObjectCollectionBase"/>NameObjectCollectionBase instance.
440 /// </summary>
441 /// <param name="name"></param>
442 /// <param name="value"></param>
443 protected void BaseAdd( string name, object value )
444 {
445 if (this.IsReadOnly)
446 throw new NotSupportedException("Collection is read-only");
447
448 _Item newitem=new _Item(name, value);
449
450 if (name==null){
451 //todo: consider nullkey entry
452 if (m_NullKeyItem==null)
453 m_NullKeyItem = newitem;
454 }
455 else
456 if (m_ItemsContainer[name]==null){
457 m_ItemsContainer.Add(name,newitem);
458 }
459 m_ItemsArray.Add(newitem);
460 }
461
462 protected void BaseClear()
463 {
464 if (this.IsReadOnly)
465 throw new NotSupportedException("Collection is read-only");
466 Init();
467 }
468
469 /// <summary>
470 /// SDK: Gets the value of the entry at the specified index of the NameObjectCollectionBase instance.
471 /// </summary>
472 /// <param name="index"></param>
473 /// <returns></returns>
474 protected object BaseGet( int index )
475 {
476 return ((_Item)m_ItemsArray[index]).value;
477 }
478
479 /// <summary>
480 /// SDK: Gets the value of the first entry with the specified key from the NameObjectCollectionBase instance.
481 /// </summary>
482 /// <remark>CAUTION: The BaseGet method does not distinguish between a null reference which is returned because the specified key is not found and a null reference which is returned because the value associated with the key is a null reference.</remark>
483 /// <param name="name"></param>
484 /// <returns></returns>
485 protected object BaseGet( string name )
486 {
487 _Item item = FindFirstMatchedItem(name);
488 /// CAUTION: The BaseGet method does not distinguish between a null reference which is returned because the specified key is not found and a null reference which is returned because the value associated with the key is a null reference.
489 if (item==null)
490 return null;
491 else
492 return item.value;
493 }
494
495 /// <summary>
496 /// SDK:Returns a String array that contains all the keys in the NameObjectCollectionBase instance.
497 /// </summary>
498 /// <returns>A String array that contains all the keys in the NameObjectCollectionBase instance.</returns>
499 protected string[] BaseGetAllKeys()
500 {
501 int cnt = m_ItemsArray.Count;
502 string[] allKeys = new string[cnt];
503 for(int i=0; i<cnt; i++)
504 allKeys[i] = BaseGetKey(i);//((_Item)m_ItemsArray[i]).key;
505
506 return allKeys;
507 }
508
509 /// <summary>
510 /// SDK: Returns an Object array that contains all the values in the NameObjectCollectionBase instance.
511 /// </summary>
512 /// <returns>An Object array that contains all the values in the NameObjectCollectionBase instance.</returns>
513 protected object[] BaseGetAllValues()
514 {
515 int cnt = m_ItemsArray.Count;
516 object[] allValues = new object[cnt];
517 for(int i=0; i<cnt; i++)
518 allValues[i] = BaseGet(i);
519
520 return allValues;
521 }
522
523 protected object[] BaseGetAllValues( Type type )
524 {
525 if (type == null)
526 throw new ArgumentNullException("'type' argument can't be null");
527 int cnt = m_ItemsArray.Count;
528 object[] allValues = (object[]) Array.CreateInstance (type, cnt);
529 for(int i=0; i<cnt; i++)
530 allValues[i] = BaseGet(i);
531
532 return allValues;
533 }
534
535 protected string BaseGetKey( int index )
536 {
537 return ((_Item)m_ItemsArray[index]).key;
538 }
539
540 /// <summary>
541 /// Gets a value indicating whether the NameObjectCollectionBase instance contains entries whose keys are not a null reference
542 /// </summary>
543 /// <returns>true if the NameObjectCollectionBase instance contains entries whose keys are not a null reference otherwise, false.</returns>
544 protected bool BaseHasKeys()
545 {
546 return (m_ItemsContainer.Count>0);
547 }
548
549 protected void BaseRemove( string name )
550 {
551 int cnt = 0;
552 String key;
553 if (this.IsReadOnly)
554 throw new NotSupportedException("Collection is read-only");
555 if (name!=null)
556 {
557 m_ItemsContainer.Remove(name);
558 }
559 else {
560 m_NullKeyItem = null;
561 }
562
563 cnt = m_ItemsArray.Count;
564 for (int i=0 ; i< cnt; ){
565 key=BaseGetKey(i);
566 if (Equals (key, name)) {
567 m_ItemsArray.RemoveAt(i);
568 cnt--;
569 }
570 else
571 i++;
572 }
573 }
574
575 /// <summary>
576 ///
577 /// </summary>
578 /// <param name="index"></param>
579 /// <LAME>This function implemented the way Microsoft implemented it -
580 /// item is removed from hashtable and array without considering the case when there are two items with the same key but different values in array.
581 /// E.g. if
582 /// hashtable is [("Key1","value1")] and array contains [("Key1","value1")("Key1","value2")] then
583 /// after RemoveAt(1) the collection will be in following state:
584 /// hashtable:[]
585 /// array: [("Key1","value1")]
586 /// It's ok only then the key is uniquely assosiated with the value
587 /// To fix it a comparsion of objects stored under the same key in the hashtable and in the arraylist should be added
588 /// </LAME>>
589 protected void BaseRemoveAt( int index )
590 {
591 if (this.IsReadOnly)
592 throw new NotSupportedException("Collection is read-only");
593 string key = BaseGetKey(index);
594 if (key!=null){
595 // TODO: see LAME description above
596 m_ItemsContainer.Remove(key);
597 }
598 else
599 m_NullKeyItem = null;
600 m_ItemsArray.RemoveAt(index);
601 }
602
603 /// <summary>
604 /// SDK: Sets the value of the entry at the specified index of the NameObjectCollectionBase instance.
605 /// </summary>
606 /// <param name="index"></param>
607 /// <param name="value"></param>
608 protected void BaseSet( int index, object value )
609 {
610 #if NET_2_0
611 if (this.IsReadOnly)
612 throw new NotSupportedException("Collection is read-only");
613 #endif
614 _Item item = (_Item)m_ItemsArray[index];
615 item.value = value;
616 }
617
618 /// <summary>
619 /// Sets the value of the first entry with the specified key in the NameObjectCollectionBase instance, if found; otherwise, adds an entry with the specified key and value into the NameObjectCollectionBase instance.
620 /// </summary>
621 /// <param name="name">The String key of the entry to set. The key can be a null reference </param>
622 /// <param name="value">The Object that represents the new value of the entry to set. The value can be a null reference</param>
623 protected void BaseSet( string name, object value )
624 {
625 #if NET_2_0
626 if (this.IsReadOnly)
627 throw new NotSupportedException("Collection is read-only");
628 #endif
629 _Item item = FindFirstMatchedItem(name);
630 if (item!=null)
631 item.value=value;
632 else
633 BaseAdd(name, value);
634 }
635
636 [MonoTODO]
637 private _Item FindFirstMatchedItem(string name)
638 {
639 if (name!=null)
640 return (_Item)m_ItemsContainer[name];
641 else {
642 //TODO: consider null key case
643 return m_NullKeyItem;
644 }
645 }
646
647 internal bool Equals (string s1, string s2)
648 {
649 #if NET_2_0
650 if (m_comparer != null)
651 return (m_comparer.Compare (s1, s2) == 0);
652 else
653 return equality_comparer.Equals (s1, s2);
654 #else
655 return (m_comparer.Compare (s1, s2) == 0);
656 #endif
657 }
658 }
659 }
git-svn mirror of mcs