?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(DISTFILES): Comment out a few missing files.
[mono-project.git] / mcs / class / corlib / System / Array.cs
blobea37a7a1e1d07d41d66902814687ed427e77419a
1 //
2 // System.Array.cs
3 //
4 // Authors:
5 // Joe Shaw (joe@ximian.com)
6 // Martin Baulig (martin@gnome.org)
7 // Dietmar Maurer (dietmar@ximian.com)
8 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
9 //
10 // (C) 2001-2003 Ximian, Inc. http://www.ximian.com
11 //
12
13 //
14 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
15 //
16 // Permission is hereby granted, free of charge, to any person obtaining
17 // a copy of this software and associated documentation files (the
18 // "Software"), to deal in the Software without restriction, including
19 // without limitation the rights to use, copy, modify, merge, publish,
20 // distribute, sublicense, and/or sell copies of the Software, and to
21 // permit persons to whom the Software is furnished to do so, subject to
22 // the following conditions:
23 //
24 // The above copyright notice and this permission notice shall be
25 // included in all copies or substantial portions of the Software.
26 //
27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 //
35
36 using System.Collections;
37 using System.Runtime.CompilerServices;
38 using System.Runtime.InteropServices;
39 #if NET_2_0
40 using System.Collections.Generic;
41 #endif
42 namespace System
43 {
44 [Serializable]
45 [MonoTODO ("We are doing way to many double/triple exception checks for the overloaded functions")]
46 [MonoTODO ("Sort overloads parameter checks are VERY inconsistent")]
47 public abstract class Array : ICloneable, ICollection, IList, IEnumerable
48 {
49 // Constructor
50 private Array ()
51 {
52 }
53
54 // Properties
55 public int Length {
56 get {
57 int length = this.GetLength (0);
58
59 for (int i = 1; i < this.Rank; i++) {
60 length *= this.GetLength (i);
61 }
62 return length;
63 }
64 }
65
66 #if NET_1_1
67 [ComVisible (false)]
68 public long LongLength {
69 get { return Length; }
70 }
71 #endif
72
73 public int Rank {
74 get {
75 return this.GetRank ();
76 }
77 }
78
79 // IList interface
80 object IList.this [int index] {
81 get {
82 if (unchecked ((uint) index) >= unchecked ((uint) Length))
83 throw new ArgumentOutOfRangeException ("index");
84 return GetValueImpl (index);
85 }
86 set {
87 if (unchecked ((uint) index) >= unchecked ((uint) Length))
88 throw new ArgumentOutOfRangeException ("index");
89 SetValueImpl (value, index);
90 }
91 }
92
93 int IList.Add (object value)
94 {
95 throw new NotSupportedException ();
96 }
97
98 void IList.Clear ()
99 {
100 Array.Clear (this, this.GetLowerBound (0), this.Length);
101 }
102
103 bool IList.Contains (object value)
104 {
105 if (this.Rank > 1)
106 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
107
108 int length = this.Length;
109 for (int i = 0; i < length; i++) {
110 if (Object.Equals (value, this.GetValueImpl (i)))
111 return true;
112 }
113 return false;
114 }
115
116 int IList.IndexOf (object value)
117 {
118 if (this.Rank > 1)
119 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
120
121 int length = this.Length;
122 for (int i = 0; i < length; i++) {
123 if (Object.Equals (value, this.GetValueImpl (i)))
124 // array index may not be zero-based.
125 // use lower bound
126 return i + this.GetLowerBound (0);
127 }
128
129 int retVal;
130 unchecked {
131 // lower bound may be MinValue
132 retVal = this.GetLowerBound (0) - 1;
133 }
134
135 return retVal;
136 }
137
138 void IList.Insert (int index, object value)
139 {
140 throw new NotSupportedException ();
141 }
142
143 void IList.Remove (object value)
144 {
145 throw new NotSupportedException ();
146 }
147
148 void IList.RemoveAt (int index)
149 {
150 throw new NotSupportedException ();
151 }
152
153 // InternalCall Methods
154 [MethodImplAttribute (MethodImplOptions.InternalCall)]
155 private extern int GetRank ();
156
157 [MethodImplAttribute (MethodImplOptions.InternalCall)]
158 public extern int GetLength (int dimension);
159
160 #if NET_1_1
161 [ComVisible (false)]
162 public long GetLongLength (int dimension)
163 {
164 return GetLength (dimension);
165 }
166 #endif
167
168 [MethodImplAttribute (MethodImplOptions.InternalCall)]
169 public extern int GetLowerBound (int dimension);
170
171 [MethodImplAttribute (MethodImplOptions.InternalCall)]
172 public extern object GetValue (int[] indices);
173
174 [MethodImplAttribute (MethodImplOptions.InternalCall)]
175 public extern void SetValue (object value, int[] indices);
176
177 // CAUTION! No bounds checking!
178 [MethodImplAttribute (MethodImplOptions.InternalCall)]
179 internal extern object GetValueImpl (int pos);
180
181 // CAUTION! No bounds checking!
182 [MethodImplAttribute (MethodImplOptions.InternalCall)]
183 internal extern void SetValueImpl (object value, int pos);
184
185 [MethodImplAttribute (MethodImplOptions.InternalCall)]
186 internal extern static bool FastCopy (Array source, int source_idx, Array dest, int dest_idx, int length);
187
188 [MethodImplAttribute (MethodImplOptions.InternalCall)]
189 internal extern static Array CreateInstanceImpl (Type elementType, int[] lengths, int[] bounds);
190
191 // Properties
192 int ICollection.Count {
193 get {
194 return Length;
195 }
196 }
197
198 public virtual bool IsSynchronized {
199 get {
200 return false;
201 }
202 }
203
204 public virtual object SyncRoot {
205 get {
206 return this;
207 }
208 }
209
210 public virtual bool IsFixedSize {
211 get {
212 return true;
213 }
214 }
215
216 public virtual bool IsReadOnly {
217 get {
218 return false;
219 }
220 }
221
222 public virtual IEnumerator GetEnumerator ()
223 {
224 return new SimpleEnumerator (this);
225 }
226
227 public int GetUpperBound (int dimension)
228 {
229 return GetLowerBound (dimension) + GetLength (dimension) - 1;
230 }
231
232 public object GetValue (int index)
233 {
234 if (Rank != 1)
235 throw new ArgumentException (Locale.GetText ("Array was not a one-dimensional array."));
236 if (index < GetLowerBound (0) || index > GetUpperBound (0))
237 throw new IndexOutOfRangeException (Locale.GetText (
238 "Index has to be between upper and lower bound of the array."));
239
240 return GetValueImpl (index - GetLowerBound (0));
241 }
242
243 public object GetValue (int index1, int index2)
244 {
245 int[] ind = {index1, index2};
246 return GetValue (ind);
247 }
248
249 public object GetValue (int index1, int index2, int index3)
250 {
251 int[] ind = {index1, index2, index3};
252 return GetValue (ind);
253 }
254
255 #if NET_1_1
256 [ComVisible (false)]
257 public object GetValue (long index)
258 {
259 if (index < 0 || index > Int32.MaxValue)
260 throw new ArgumentOutOfRangeException ("index", Locale.GetText (
261 "Value must be >= 0 and <= Int32.MaxValue."));
262
263 return GetValue ((int) index);
264 }
265
266 [ComVisible (false)]
267 public object GetValue (long index1, long index2)
268 {
269 if (index1 < 0 || index1 > Int32.MaxValue)
270 throw new ArgumentOutOfRangeException ("index1", Locale.GetText (
271 "Value must be >= 0 and <= Int32.MaxValue."));
272
273 if (index2 < 0 || index2 > Int32.MaxValue)
274 throw new ArgumentOutOfRangeException ("index2", Locale.GetText (
275 "Value must be >= 0 and <= Int32.MaxValue."));
276
277 return GetValue ((int) index1, (int) index2);
278 }
279
280 [ComVisible (false)]
281 public object GetValue (long index1, long index2, long index3)
282 {
283 if (index1 < 0 || index1 > Int32.MaxValue)
284 throw new ArgumentOutOfRangeException ("index1", Locale.GetText (
285 "Value must be >= 0 and <= Int32.MaxValue."));
286
287 if (index2 < 0 || index2 > Int32.MaxValue)
288 throw new ArgumentOutOfRangeException ("index2", Locale.GetText (
289 "Value must be >= 0 and <= Int32.MaxValue."));
290
291 if (index3 < 0 || index3 > Int32.MaxValue)
292 throw new ArgumentOutOfRangeException ("index3", Locale.GetText (
293 "Value must be >= 0 and <= Int32.MaxValue."));
294
295 return GetValue ((int) index1, (int) index2, (int) index3);
296 }
297
298 [ComVisible (false)]
299 public void SetValue (object value, long index)
300 {
301 if (index < 0 || index > Int32.MaxValue)
302 throw new ArgumentOutOfRangeException ("index", Locale.GetText (
303 "Value must be >= 0 and <= Int32.MaxValue."));
304
305 SetValue (value, (int) index);
306 }
307
308 [ComVisible (false)]
309 public void SetValue (object value, long index1, long index2)
310 {
311 if (index1 < 0 || index1 > Int32.MaxValue)
312 throw new ArgumentOutOfRangeException ("index1", Locale.GetText (
313 "Value must be >= 0 and <= Int32.MaxValue."));
314
315 if (index2 < 0 || index2 > Int32.MaxValue)
316 throw new ArgumentOutOfRangeException ("index2", Locale.GetText (
317 "Value must be >= 0 and <= Int32.MaxValue."));
318
319 int[] ind = {(int) index1, (int) index2};
320 SetValue (value, ind);
321 }
322
323 [ComVisible (false)]
324 public void SetValue (object value, long index1, long index2, long index3)
325 {
326 if (index1 < 0 || index1 > Int32.MaxValue)
327 throw new ArgumentOutOfRangeException ("index1", Locale.GetText (
328 "Value must be >= 0 and <= Int32.MaxValue."));
329
330 if (index2 < 0 || index2 > Int32.MaxValue)
331 throw new ArgumentOutOfRangeException ("index2", Locale.GetText (
332 "Value must be >= 0 and <= Int32.MaxValue."));
333
334 if (index3 < 0 || index3 > Int32.MaxValue)
335 throw new ArgumentOutOfRangeException ("index3", Locale.GetText (
336 "Value must be >= 0 and <= Int32.MaxValue."));
337
338 int[] ind = {(int) index1, (int) index2, (int) index3};
339 SetValue (value, ind);
340 }
341 #endif
342
343 // // This function is currently unused, but just in case we need it later on ... */
344 // internal int IndexToPos (int[] idxs)
345 // {
346 // if (idxs == null)
347 // throw new ArgumentNullException ("idxs");
348 //
349 // if ((idxs.Rank != 1) || (idxs.Length != Rank))
350 // throw new ArgumentException ();
351 //
352 // if ((idxs [0] < GetLowerBound (0)) || (idxs [0] > GetUpperBound (0)))
353 // throw new IndexOutOfRangeException();
354 //
355 // int pos = idxs [0] - GetLowerBound (0);
356 // for (int i = 1; i < Rank; i++) {
357 // if ((idxs [i] < GetLowerBound (i)) || (idxs [i] > GetUpperBound (i)))
358 // throw new IndexOutOfRangeException();
359 //
360 // pos *= GetLength (i);
361 // pos += idxs [i] - GetLowerBound (i);
362 // }
363 //
364 // return pos;
365 // }
366
367 public void SetValue (object value, int index)
368 {
369 if (Rank != 1)
370 throw new ArgumentException (Locale.GetText ("Array was not a one-dimensional array."));
371 if (index < GetLowerBound (0) || index > GetUpperBound (0))
372 throw new IndexOutOfRangeException (Locale.GetText (
373 "Index has to be >= lower bound and <= upper bound of the array."));
374
375 SetValueImpl (value, index - GetLowerBound (0));
376 }
377
378 public void SetValue (object value, int index1, int index2)
379 {
380 int[] ind = {index1, index2};
381 SetValue (value, ind);
382 }
383
384 public void SetValue (object value, int index1, int index2, int index3)
385 {
386 int[] ind = {index1, index2, index3};
387 SetValue (value, ind);
388 }
389
390 public static Array CreateInstance (Type elementType, int length)
391 {
392 int[] lengths = {length};
393 int[] bounds = null;
394
395 return CreateInstanceImpl (elementType, lengths, bounds);
396 }
397
398 public static Array CreateInstance (Type elementType, int length1, int length2)
399 {
400 int[] lengths = {length1, length2};
401 int[] bounds = null;
402
403 return CreateInstanceImpl (elementType, lengths, bounds);
404 }
405
406 public static Array CreateInstance (Type elementType, int length1, int length2, int length3)
407 {
408 int[] lengths = {length1, length2, length3};
409 int[] bounds = null;
410
411 return CreateInstanceImpl (elementType, lengths, bounds);
412 }
413
414 public static Array CreateInstance (Type elementType, int[] lengths)
415 {
416 if (elementType == null)
417 throw new ArgumentNullException ("elementType");
418 if (lengths == null)
419 throw new ArgumentNullException ("lengths");
420
421 if (lengths.Length > 255)
422 throw new TypeLoadException ();
423
424 int[] bounds = null;
425
426 return CreateInstanceImpl (elementType, lengths, bounds);
427 }
428
429 public static Array CreateInstance (Type elementType, int[] lengths, int [] bounds)
430 {
431 if (elementType == null)
432 throw new ArgumentNullException ("elementType");
433 if (lengths == null)
434 throw new ArgumentNullException ("lengths");
435 if (bounds == null)
436 throw new ArgumentNullException ("bounds");
437
438 if (lengths.Length < 1)
439 throw new ArgumentException (Locale.GetText ("Arrays must contain >= 1 elements."));
440
441 if (lengths.Length != bounds.Length)
442 throw new ArgumentException (Locale.GetText ("Arrays must be of same size."));
443
444 for (int j = 0; j < bounds.Length; j ++) {
445 if (lengths [j] < 0)
446 throw new ArgumentOutOfRangeException ("lengths", Locale.GetText (
447 "Each value has to be >= 0."));
448 if ((long)bounds [j] + (long)lengths [j] > (long)Int32.MaxValue)
449 throw new ArgumentOutOfRangeException ("lengths", Locale.GetText (
450 "Length + bound must not exceed Int32.MaxValue."));
451 }
452
453 if (lengths.Length > 255)
454 throw new TypeLoadException ();
455
456 return CreateInstanceImpl (elementType, lengths, bounds);
457 }
458
459 #if NET_1_1
460 static int [] GetIntArray (long [] values)
461 {
462 int len = values.Length;
463 int [] ints = new int [len];
464 for (int i = 0; i < len; i++) {
465 long current = values [i];
466 if (current < 0 || current > (long) Int32.MaxValue)
467 throw new ArgumentOutOfRangeException ("values", Locale.GetText (
468 "Each value has to be >= 0 and <= Int32.MaxValue."));
469
470 ints [i] = (int) current;
471 }
472 return ints;
473 }
474
475 public static Array CreateInstance (Type elementType, params long [] lengths)
476 {
477 if (lengths == null) {
478 // LAMESPEC: Docs say we should throw a ArgumentNull, but .NET
479 // 1.1 actually throws a NullReference.
480 throw new NullReferenceException (Locale.GetText ("'lengths' cannot be null."));
481 }
482 return CreateInstance (elementType, GetIntArray (lengths));
483 }
484
485 [ComVisible (false)]
486 public object GetValue (long [] indices)
487 {
488 if (indices == null) {
489 // LAMESPEC: Docs say we should throw a ArgumentNull, but .NET
490 // 1.1 actually throws a NullReference.
491 throw new NullReferenceException (Locale.GetText ("'indices' cannot be null."));
492 }
493 return GetValue (GetIntArray (indices));
494 }
495
496 [ComVisible (false)]
497 public void SetValue (object value, long [] indices)
498 {
499 if (indices == null) {
500 // LAMESPEC: Docs say we should throw a ArgumentNull, but .NET
501 // 1.1 actually throws a NullReference.
502 throw new NullReferenceException (Locale.GetText ("'indices' cannot be null."));
503 }
504 SetValue (value, GetIntArray (indices));
505 }
506 #endif
507
508 public static int BinarySearch (Array array, object value)
509 {
510 if (array == null)
511 throw new ArgumentNullException ("array");
512
513 if (value == null)
514 return -1;
515
516 if (array.Rank > 1)
517 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
518
519 if (!(value is IComparable))
520 throw new ArgumentException (Locale.GetText ("value does not support IComparable."));
521
522 return DoBinarySearch (array, array.GetLowerBound (0), array.GetLength (0), value, null);
523 }
524
525 public static int BinarySearch (Array array, object value, IComparer comparer)
526 {
527 if (array == null)
528 throw new ArgumentNullException ("array");
529
530 if (array.Rank > 1)
531 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
532
533 if ((comparer == null) && (value != null) && !(value is IComparable))
534 throw new ArgumentException (Locale.GetText (
535 "comparer is null and value does not support IComparable."));
536
537 return DoBinarySearch (array, array.GetLowerBound (0), array.GetLength (0), value, comparer);
538 }
539
540 public static int BinarySearch (Array array, int index, int length, object value)
541 {
542 if (array == null)
543 throw new ArgumentNullException ("array");
544
545 if (array.Rank > 1)
546 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
547
548 if (index < array.GetLowerBound (0))
549 throw new ArgumentOutOfRangeException ("index", Locale.GetText (
550 "index is less than the lower bound of array."));
551 if (length < 0)
552 throw new ArgumentOutOfRangeException ("length", Locale.GetText (
553 "Value has to be >= 0."));
554 // re-ordered to avoid possible integer overflow
555 if (index > array.GetLowerBound (0) + array.GetLength (0) - length)
556 throw new ArgumentException (Locale.GetText (
557 "index and length do not specify a valid range in array."));
558 if ((value != null) && (!(value is IComparable)))
559 throw new ArgumentException (Locale.GetText (
560 "value does not support IComparable"));
561
562 return DoBinarySearch (array, index, length, value, null);
563 }
564
565 public static int BinarySearch (Array array, int index, int length, object value, IComparer comparer)
566 {
567 if (array == null)
568 throw new ArgumentNullException ("array");
569
570 if (array.Rank > 1)
571 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
572
573 if (index < array.GetLowerBound (0))
574 throw new ArgumentOutOfRangeException ("index", Locale.GetText (
575 "index is less than the lower bound of array."));
576 if (length < 0)
577 throw new ArgumentOutOfRangeException ("length", Locale.GetText (
578 "Value has to be >= 0."));
579 // re-ordered to avoid possible integer overflow
580 if (index > array.GetLowerBound (0) + array.GetLength (0) - length)
581 throw new ArgumentException (Locale.GetText (
582 "index and length do not specify a valid range in array."));
583
584 if ((comparer == null) && (value != null) && !(value is IComparable))
585 throw new ArgumentException (Locale.GetText (
586 "comparer is null and value does not support IComparable."));
587
588 return DoBinarySearch (array, index, length, value, comparer);
589 }
590
591 static int DoBinarySearch (Array array, int index, int length, object value, IComparer comparer)
592 {
593 // cache this in case we need it
594 IComparable valueCompare = value as IComparable;
595 if (comparer == null)
596 comparer = Comparer.Default;
597
598 int iMin = index;
599 // Comment from Tum (tum@veridicus.com):
600 // *Must* start at index + length - 1 to pass rotor test co2460binarysearch_iioi
601 int iMax = index + length - 1;
602 int iCmp = 0;
603 try {
604 while (iMin <= iMax) {
605 int iMid = (iMin + iMax) / 2;
606 object elt = array.GetValueImpl (iMid);
607
608 iCmp = comparer.Compare (value, elt);
609
610 if (iCmp == 0)
611 return iMid;
612 else if (iCmp < 0)
613 iMax = iMid - 1;
614 else
615 iMin = iMid + 1; // compensate for the rounding down
616 }
617 }
618 catch (Exception e) {
619 throw new InvalidOperationException (Locale.GetText ("Comparer threw an exception."), e);
620 }
621
622 return ~iMin;
623 }
624
625 public static void Clear (Array array, int index, int length)
626 {
627 if (array == null)
628 throw new ArgumentNullException ("array");
629 if (length < 0)
630 throw new ArgumentOutOfRangeException ("length < 0");
631
632 int low = array.GetLowerBound (0);
633 if (index < low)
634 throw new IndexOutOfRangeException ("index < lower bound");
635 index = index - low;
636
637 // re-ordered to avoid possible integer overflow
638 if (index > array.Length - length)
639 throw new IndexOutOfRangeException ("index + length > size");
640
641 ClearInternal (array, index, length);
642 }
643
644 [MethodImplAttribute (MethodImplOptions.InternalCall)]
645 static extern void ClearInternal (Array a, int index, int count);
646
647 [MethodImplAttribute (MethodImplOptions.InternalCall)]
648 public virtual extern object Clone ();
649
650 public static void Copy (Array sourceArray, Array destinationArray, int length)
651 {
652 // need these checks here because we are going to use
653 // GetLowerBound() on source and dest.
654 if (sourceArray == null)
655 throw new ArgumentNullException ("sourceArray");
656
657 if (destinationArray == null)
658 throw new ArgumentNullException ("destinationArray");
659
660 Copy (sourceArray, sourceArray.GetLowerBound (0), destinationArray,
661 destinationArray.GetLowerBound (0), length);
662 }
663
664 public static void Copy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
665 {
666 if (sourceArray == null)
667 throw new ArgumentNullException ("sourceArray");
668
669 if (destinationArray == null)
670 throw new ArgumentNullException ("destinationArray");
671
672 if (length < 0)
673 throw new ArgumentOutOfRangeException ("length", Locale.GetText (
674 "Value has to be >= 0."));;
675
676 if (sourceIndex < 0)
677 throw new ArgumentOutOfRangeException ("sourceIndex", Locale.GetText (
678 "Value has to be >= 0."));;
679
680 if (destinationIndex < 0)
681 throw new ArgumentOutOfRangeException ("destinationIndex", Locale.GetText (
682 "Value has to be >= 0."));;
683
684 if (FastCopy (sourceArray, sourceIndex, destinationArray, destinationIndex, length))
685 return;
686
687 int source_pos = sourceIndex - sourceArray.GetLowerBound (0);
688 int dest_pos = destinationIndex - destinationArray.GetLowerBound (0);
689
690 // re-ordered to avoid possible integer overflow
691 if (source_pos > sourceArray.Length - length || dest_pos > destinationArray.Length - length)
692 throw new ArgumentException ("length");
693
694 if (sourceArray.Rank != destinationArray.Rank)
695 throw new RankException (Locale.GetText ("Arrays must be of same size."));
696
697 Type src_type = sourceArray.GetType ().GetElementType ();
698 Type dst_type = destinationArray.GetType ().GetElementType ();
699
700 if (!Object.ReferenceEquals (sourceArray, destinationArray) || source_pos > dest_pos) {
701 for (int i = 0; i < length; i++) {
702 Object srcval = sourceArray.GetValueImpl (source_pos + i);
703
704 try {
705 destinationArray.SetValueImpl (srcval, dest_pos + i);
706 } catch {
707 if ((dst_type.IsValueType || dst_type.Equals (typeof (String))) &&
708 (src_type.Equals (typeof (Object))))
709 throw new InvalidCastException ();
710 else
711 throw new ArrayTypeMismatchException (String.Format (Locale.GetText (
712 "(Types: source={0}; target={1})"), src_type.FullName, dst_type.FullName));
713 }
714 }
715 }
716 else {
717 for (int i = length - 1; i >= 0; i--) {
718 Object srcval = sourceArray.GetValueImpl (source_pos + i);
719
720 try {
721 destinationArray.SetValueImpl (srcval, dest_pos + i);
722 } catch {
723 if ((dst_type.IsValueType || dst_type.Equals (typeof (String))) &&
724 (src_type.Equals (typeof (Object))))
725 throw new InvalidCastException ();
726 else
727 throw new ArrayTypeMismatchException (String.Format (Locale.GetText (
728 "(Types: source={0}; target={1})"), src_type.FullName, dst_type.FullName));
729 }
730 }
731 }
732 }
733
734 #if NET_1_1
735 public static void Copy (Array sourceArray, long sourceIndex, Array destinationArray,
736 long destinationIndex, long length)
737 {
738 if (sourceArray == null)
739 throw new ArgumentNullException ("sourceArray");
740
741 if (destinationArray == null)
742 throw new ArgumentNullException ("destinationArray");
743
744 if (sourceIndex < Int32.MinValue || sourceIndex > Int32.MaxValue)
745 throw new ArgumentOutOfRangeException ("sourceIndex",
746 Locale.GetText ("Must be in the Int32 range."));
747
748 if (destinationIndex < Int32.MinValue || destinationIndex > Int32.MaxValue)
749 throw new ArgumentOutOfRangeException ("destinationIndex",
750 Locale.GetText ("Must be in the Int32 range."));
751
752 if (length < 0 || length > Int32.MaxValue)
753 throw new ArgumentOutOfRangeException ("length", Locale.GetText (
754 "Value must be >= 0 and <= Int32.MaxValue."));
755
756 Copy (sourceArray, (int) sourceIndex, destinationArray, (int) destinationIndex, (int) length);
757 }
758
759 public static void Copy (Array sourceArray, Array destinationArray, long length)
760 {
761 if (length < 0 || length > Int32.MaxValue)
762 throw new ArgumentOutOfRangeException ("length", Locale.GetText (
763 "Value must be >= 0 and <= Int32.MaxValue."));
764
765 Copy (sourceArray, destinationArray, (int) length);
766 }
767 #endif
768
769 public static int IndexOf (Array array, object value)
770 {
771 if (array == null)
772 throw new ArgumentNullException ("array");
773
774 return IndexOf (array, value, 0, array.Length);
775 }
776
777 public static int IndexOf (Array array, object value, int startIndex)
778 {
779 if (array == null)
780 throw new ArgumentNullException ("array");
781
782 return IndexOf (array, value, startIndex, array.Length - startIndex);
783 }
784
785 public static int IndexOf (Array array, object value, int startIndex, int count)
786 {
787 if (array == null)
788 throw new ArgumentNullException ("array");
789
790 if (array.Rank > 1)
791 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
792
793 // re-ordered to avoid possible integer overflow
794 if (count < 0 || startIndex < array.GetLowerBound (0) || startIndex - 1 > array.GetUpperBound (0) - count)
795 throw new ArgumentOutOfRangeException ();
796
797 int max = startIndex + count;
798 for (int i = startIndex; i < max; i++) {
799 if (Object.Equals (array.GetValueImpl (i), value))
800 return i;
801 }
802
803 return array.GetLowerBound (0) - 1;
804 }
805
806 [MonoTODO]
807 public void Initialize()
808 {
809 //FIXME: We would like to find a compiler that uses
810 // this method. It looks like this method do nothing
811 // in C# so no exception is trown by the moment.
812 }
813
814 public static int LastIndexOf (Array array, object value)
815 {
816 if (array == null)
817 throw new ArgumentNullException ("array");
818
819 return LastIndexOf (array, value, array.Length - 1);
820 }
821
822 public static int LastIndexOf (Array array, object value, int startIndex)
823 {
824 if (array == null)
825 throw new ArgumentNullException ("array");
826
827 return LastIndexOf (array, value, startIndex, startIndex - array.GetLowerBound (0) + 1);
828 }
829
830 public static int LastIndexOf (Array array, object value, int startIndex, int count)
831 {
832 if (array == null)
833 throw new ArgumentNullException ("array");
834
835 if (array.Rank > 1)
836 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
837
838 if (count < 0 || startIndex < array.GetLowerBound (0) ||
839 startIndex > array.GetUpperBound (0) || startIndex - count + 1 < array.GetLowerBound (0))
840 throw new ArgumentOutOfRangeException ();
841
842 for (int i = startIndex; i >= startIndex - count + 1; i--) {
843 if (Object.Equals (array.GetValueImpl (i), value))
844 return i;
845 }
846
847 return array.GetLowerBound (0) - 1;
848 }
849
850 public static void Reverse (Array array)
851 {
852 if (array == null)
853 throw new ArgumentNullException ("array");
854
855 Reverse (array, array.GetLowerBound (0), array.GetLength (0));
856 }
857
858 public static void Reverse (Array array, int index, int length)
859 {
860 if (array == null)
861 throw new ArgumentNullException ("array");
862
863 if (array.Rank > 1)
864 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
865
866 if (index < array.GetLowerBound (0) || length < 0)
867 throw new ArgumentOutOfRangeException ();
868
869 // re-ordered to avoid possible integer overflow
870 if (index > array.GetUpperBound (0) + 1 - length)
871 throw new ArgumentException ();
872
873 for (int i = 0; i < length / 2; i++)
874 {
875 object tmp;
876
877 tmp = array.GetValueImpl (index + i);
878 array.SetValueImpl (array.GetValueImpl (index + length - i - 1), index + i);
879 array.SetValueImpl (tmp, index + length - i - 1);
880 }
881 }
882
883 public static void Sort (Array array)
884 {
885 if (array == null)
886 throw new ArgumentNullException ("array");
887
888 Sort (array, null, array.GetLowerBound (0), array.GetLength (0), null);
889 }
890
891 public static void Sort (Array keys, Array items)
892 {
893 if (keys == null)
894 throw new ArgumentNullException ("keys");
895
896 Sort (keys, items, keys.GetLowerBound (0), keys.GetLength (0), null);
897 }
898
899 public static void Sort (Array array, IComparer comparer)
900 {
901 if (array == null)
902 throw new ArgumentNullException ("array");
903
904 Sort (array, null, array.GetLowerBound (0), array.GetLength (0), comparer);
905 }
906
907 public static void Sort (Array array, int index, int length)
908 {
909 Sort (array, null, index, length, null);
910 }
911
912 public static void Sort (Array keys, Array items, IComparer comparer)
913 {
914 if (keys == null)
915 throw new ArgumentNullException ("keys");
916
917 Sort (keys, items, keys.GetLowerBound (0), keys.GetLength (0), comparer);
918 }
919
920 public static void Sort (Array keys, Array items, int index, int length)
921 {
922 Sort (keys, items, index, length, null);
923 }
924
925 public static void Sort (Array array, int index, int length, IComparer comparer)
926 {
927 Sort (array, null, index, length, comparer);
928 }
929
930 public static void Sort (Array keys, Array items, int index, int length, IComparer comparer)
931 {
932 if (keys == null)
933 throw new ArgumentNullException ("keys");
934
935 if (keys.Rank > 1 || (items != null && items.Rank > 1))
936 throw new RankException ();
937
938 if (items != null && keys.GetLowerBound (0) != items.GetLowerBound (0))
939 throw new ArgumentException ();
940
941 if (index < keys.GetLowerBound (0))
942 throw new ArgumentOutOfRangeException ("index");
943
944 if (length < 0)
945 throw new ArgumentOutOfRangeException ("length", Locale.GetText (
946 "Value has to be >= 0."));
947
948 if (keys.Length - (index + keys.GetLowerBound (0)) < length
949 || (items != null && index > items.Length - length))
950 throw new ArgumentException ();
951
952 try {
953 int low0 = index;
954 int high0 = index + length - 1;
955 qsort (keys, items, low0, high0, comparer);
956 }
957 catch (Exception e) {
958 throw new InvalidOperationException (Locale.GetText ("The comparer threw an exception."), e);
959 }
960 }
961
962 private static void qsort (Array keys, Array items, int low0, int high0, IComparer comparer)
963 {
964 if (low0 >= high0)
965 return;
966
967 int low = low0;
968 int high = high0;
969
970 object objPivot = keys.GetValueImpl ((low + high) / 2);
971
972 while (low <= high) {
973 // Move the walls in
974 while (low < high0 && compare (keys.GetValueImpl (low), objPivot, comparer) < 0)
975 ++low;
976 while (high > low0 && compare (objPivot, keys.GetValueImpl (high), comparer) < 0)
977 --high;
978
979 if (low <= high) {
980 swap (keys, items, low, high);
981 ++low;
982 --high;
983 }
984 }
985
986 if (low0 < high)
987 qsort (keys, items, low0, high, comparer);
988 if (low < high0)
989 qsort (keys, items, low, high0, comparer);
990 }
991
992 private static void swap (Array keys, Array items, int i, int j)
993 {
994 object tmp;
995
996 tmp = keys.GetValueImpl (i);
997 keys.SetValueImpl (keys.GetValue (j), i);
998 keys.SetValueImpl (tmp, j);
999
1000 if (items != null) {
1001 tmp = items.GetValueImpl (i);
1002 items.SetValueImpl (items.GetValueImpl (j), i);
1003 items.SetValueImpl (tmp, j);
1004 }
1005 }
1006
1007 private static int compare (object value1, object value2, IComparer comparer)
1008 {
1009 if (value1 == null)
1010 return value2 == null ? 0 : -1;
1011 else if (value2 == null)
1012 return 1;
1013 else if (comparer == null)
1014 return ((IComparable) value1).CompareTo (value2);
1015 else
1016 return comparer.Compare (value1, value2);
1017 }
1018
1019 public virtual void CopyTo (Array array, int index)
1020 {
1021 if (array == null)
1022 throw new ArgumentNullException ("array");
1023
1024 // The order of these exception checks may look strange,
1025 // but that's how the microsoft runtime does it.
1026 if (this.Rank > 1)
1027 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
1028 if (index + this.GetLength (0) > array.GetLowerBound (0) + array.GetLength (0))
1029 throw new ArgumentException ();
1030 if (array.Rank > 1)
1031 throw new RankException (Locale.GetText ("Only single dimension arrays are supported."));
1032 if (index < 0)
1033 throw new ArgumentOutOfRangeException ("index", Locale.GetText (
1034 "Value has to be >= 0."));
1035
1036 Copy (this, this.GetLowerBound (0), array, index, this.GetLength (0));
1037 }
1038
1039 #if NET_1_1
1040 [ComVisible (false)]
1041 public virtual void CopyTo (Array array, long index)
1042 {
1043 if (index < 0 || index > Int32.MaxValue)
1044 throw new ArgumentOutOfRangeException ("index", Locale.GetText (
1045 "Value must be >= 0 and <= Int32.MaxValue."));
1046
1047 CopyTo (array, (int) index);
1048 }
1049 #endif
1050
1051 internal class SimpleEnumerator : IEnumerator, ICloneable
1052 {
1053 Array enumeratee;
1054 int currentpos;
1055 int length;
1056
1057 public SimpleEnumerator (Array arrayToEnumerate)
1058 {
1059 this.enumeratee = arrayToEnumerate;
1060 this.currentpos = -1;
1061 this.length = arrayToEnumerate.Length;
1062 }
1063
1064 public object Current {
1065 get {
1066 // Exception messages based on MS implementation
1067 if (currentpos < 0 )
1068 throw new InvalidOperationException (Locale.GetText (
1069 "Enumeration has not started."));
1070 if (currentpos >= length)
1071 throw new InvalidOperationException (Locale.GetText (
1072 "Enumeration has already ended"));
1073 // Current should not increase the position. So no ++ over here.
1074 return enumeratee.GetValueImpl (currentpos);
1075 }
1076 }
1077
1078 public bool MoveNext()
1079 {
1080 //The docs say Current should throw an exception if last
1081 //call to MoveNext returned false. This means currentpos
1082 //should be set to length when returning false.
1083 if (currentpos < length)
1084 currentpos++;
1085 if(currentpos < length)
1086 return true;
1087 else
1088 return false;
1089 }
1090
1091 public void Reset()
1092 {
1093 currentpos = -1;
1094 }
1095
1096 public object Clone ()
1097 {
1098 return MemberwiseClone ();
1099 }
1100 }
1101 #if NET_2_0
1102 [CLSCompliant (false)]
1103 public static void Resize <T> (ref T [] arr, int sz) {
1104 if (sz < 0)
1105 throw new ArgumentOutOfRangeException ();
1106
1107 if (arr == null) {
1108 arr = new T [sz];
1109 return;
1110 }
1111
1112 if (arr.Length == sz)
1113 return;
1114
1115 T [] a = new T [sz];
1116 Array.Copy (arr, a, Math.Min (sz, arr.Length));
1117 arr = a;
1118 }
1119
1120 [CLSCompliant (false)]
1121 public static bool TrueForAll <T> (T [] array, Predicate <T> p)
1122 {
1123 if (array == null || p == null)
1124 throw new ArgumentNullException ();
1125
1126 foreach (T t in array)
1127 if (! p (t))
1128 return false;
1129
1130 return true;
1131 }
1132 [CLSCompliant (false)]
1133 public static void ForEach <T> (T [] array, Action <T> a)
1134 {
1135 if (array == null || a == null)
1136 throw new ArgumentNullException ();
1137
1138 foreach (T t in array)
1139 a (t);
1140 }
1141
1142 [CLSCompliant (false)]
1143 public static U [] ConvertAll <T, U> (T [] s, Converter <T, U> c)
1144 {
1145 if (s == null || c == null)
1146 throw new ArgumentNullException ();
1147
1148 U [] r = new U [s.Length];
1149
1150 for (int i = 0; i < s.Length; i ++)
1151 r [i] = c (s [i]);
1152
1153 return r;
1154 }
1155
1156 [CLSCompliant (false)]
1157 public static int FindLastIndex <T> (T [] a, Predicate <T> c)
1158 {
1159 if (a == null)
1160 throw new ArgumentNullException ();
1161
1162 return FindLastIndex <T> (a, 0, a.Length, c);
1163 }
1164
1165 [CLSCompliant (false)]
1166 public static int FindLastIndex <T> (T [] a, int idx, Predicate <T> c)
1167 {
1168 if (a == null)
1169 throw new ArgumentNullException ();
1170
1171 return FindLastIndex <T> (a, idx, a.Length - idx, c);
1172 }
1173
1174 [CLSCompliant (false)]
1175 public static int FindLastIndex <T> (T [] a, int idx, int cnt, Predicate <T> c)
1176 {
1177 if (a == null || c == null)
1178 throw new ArgumentNullException ();
1179
1180 if (idx > a.Length || idx + cnt > a.Length)
1181 throw new ArgumentOutOfRangeException ();
1182
1183 for (int i = idx + cnt - 1; i >= idx; i --)
1184 if (c (a [i]))
1185 return i;
1186
1187 return -1;
1188 }
1189
1190 [CLSCompliant (false)]
1191 public static int FindIndex <T> (T [] a, Predicate <T> c)
1192 {
1193 if (a == null)
1194 throw new ArgumentNullException ();
1195
1196 return FindIndex <T> (a, 0, a.Length, c);
1197 }
1198
1199 [CLSCompliant (false)]
1200 public static int FindIndex <T> (T [] a, int idx, Predicate <T> c)
1201 {
1202 if (a == null)
1203 throw new ArgumentNullException ();
1204
1205 return FindIndex <T> (a, idx, a.Length - idx, c);
1206 }
1207
1208 [CLSCompliant (false)]
1209 public static int FindIndex <T> (T [] a, int idx, int cnt, Predicate <T> c)
1210 {
1211 if (a == null || c == null)
1212 throw new ArgumentNullException ();
1213
1214 if (idx > a.Length || idx + cnt > a.Length)
1215 throw new ArgumentOutOfRangeException ();
1216
1217 for (int i = idx; i < idx + cnt; i ++)
1218 if (c (a [i]))
1219 return i;
1220
1221 return -1;
1222 }
1223
1224 [CLSCompliant (false)]
1225 public static int BinarySearch <T> (T [] a, T x)
1226 {
1227 if (a == null)
1228 throw new ArgumentNullException ("a");
1229
1230 return BinarySearch <T> (a, 0, a.Length, x, null);
1231 }
1232
1233 [CLSCompliant (false)]
1234 public static int BinarySearch <T> (T [] a, T x, IComparer <T> c)
1235 {
1236 if (a == null)
1237 throw new ArgumentNullException ("a");
1238
1239 return BinarySearch <T> (a, 0, a.Length, x, c);
1240 }
1241
1242 [CLSCompliant (false)]
1243 public static int BinarySearch <T> (T [] a, int offset, int length, T x)
1244 {
1245 return BinarySearch <T> (a, offset, length, x, null);
1246 }
1247
1248 [CLSCompliant (false)]
1249 public static int BinarySearch <T> (T [] a, int offset, int length, T x, IComparer <T> c)
1250 {
1251 if (a == null)
1252 throw new ArgumentNullException ("a");
1253 if (offset > a.Length || (offset + length) > a.Length || offset < 0)
1254 throw new ArgumentOutOfRangeException ();
1255
1256 if (c == null)
1257 c = Comparer <T>.Default;
1258
1259 int iMin = offset;
1260 int iMax = offset + length - 1;
1261 int iCmp = 0;
1262 try {
1263 while (iMin <= iMax) {
1264 int iMid = (iMin + iMax) / 2;
1265 iCmp = c.Compare (x, a [iMid]);
1266
1267 if (iCmp == 0)
1268 return iMid;
1269 else if (iCmp < 0)
1270 iMax = iMid - 1;
1271 else
1272 iMin = iMid + 1; // compensate for the rounding down
1273 }
1274 }
1275 catch (Exception e) {
1276 throw new InvalidOperationException (Locale.GetText ("Comparer threw an exception."), e);
1277 }
1278
1279 return ~iMin;
1280 }
1281
1282 [CLSCompliant (false)]
1283 public static int IndexOf <T> (T [] array, T value)
1284 {
1285 if (array == null)
1286 throw new ArgumentNullException ("array");
1287
1288 return IndexOf (array, value, 0, array.Length);
1289 }
1290
1291 [CLSCompliant (false)]
1292 public static int IndexOf <T> (T [] array, T value, int startIndex)
1293 {
1294 if (array == null)
1295 throw new ArgumentNullException ("array");
1296
1297 return IndexOf (array, value, startIndex, array.Length - startIndex);
1298 }
1299
1300 [CLSCompliant (false)]
1301 public static int IndexOf <T> (T [] array, T value, int startIndex, int count)
1302 {
1303 if (array == null)
1304 throw new ArgumentNullException ("array");
1305
1306 // re-ordered to avoid possible integer overflow
1307 if (count < 0 || startIndex < array.GetLowerBound (0) || startIndex - 1 > array.GetUpperBound (0) - count)
1308 throw new ArgumentOutOfRangeException ();
1309
1310 int max = startIndex + count;
1311 for (int i = startIndex; i < max; i++) {
1312 if (Object.Equals (array [i], value))
1313 if (Object.Equals (array [i], value))
1314 return i;
1315 }
1316
1317 return -1;
1318 }
1319
1320 [CLSCompliant (false)]
1321 public static int LastIndexOf <T> (T [] array, T value)
1322 {
1323 if (array == null)
1324 throw new ArgumentNullException ("array");
1325
1326 return LastIndexOf (array, value, array.Length - 1);
1327 }
1328
1329 [CLSCompliant (false)]
1330 public static int LastIndexOf <T> (T [] array, T value, int startIndex)
1331 {
1332 if (array == null)
1333 throw new ArgumentNullException ("array");
1334
1335 return LastIndexOf (array, value, startIndex, startIndex - array.Length + 1);
1336 }
1337
1338 [CLSCompliant (false)]
1339 public static int LastIndexOf <T> (T [] array, T value, int startIndex, int count)
1340 {
1341 if (array == null)
1342 throw new ArgumentNullException ("array");
1343
1344 if (count < 0 || startIndex > array.Length || startIndex - count + 1 < 0)
1345 throw new ArgumentOutOfRangeException ();
1346
1347 for (int i = startIndex; i >= startIndex - count + 1; i--) {
1348 if (Object.Equals (array [i], value))
1349 return i;
1350 }
1351
1352 return -1;
1353 }
1354
1355 [CLSCompliant (false)]
1356 public static T [] FindAll <T> (T [] a, Predicate <T> p)
1357 {
1358 if (a == null || p == null)
1359 throw new ArgumentNullException ();
1360
1361 int pos = 0;
1362 T [] d = new T [a.Length];
1363 foreach (T t in a)
1364 if (p (t))
1365 d [pos ++] = t;
1366
1367 Resize <T> (ref a, pos);
1368 return a;
1369 }
1370
1371 [CLSCompliant (false)]
1372 public static bool Exists <T> (T [] a, Predicate <T> p)
1373 {
1374 if (a == null || p == null)
1375 throw new ArgumentNullException ();
1376
1377 foreach (T t in a)
1378 if (p (t))
1379 return true;
1380 return false;
1381 }
1382
1383 [CLSCompliant (false)]
1384 [MonoTODO]
1385 public static IList<T> AsReadOnly<T> (T[] array)
1386 {
1387 throw new NotImplementedException ();
1388 }
1389
1390 #if FIXME
1391 [CLSCompliant (false)]
1392 public static Nullable <T> Find <T> (T [] a, Predicate <T> p)
1393 {
1394 if (a == null || p == null)
1395 throw new ArgumentNullException ();
1396
1397 foreach (T t in a)
1398 if (p (t))
1399 return new Nullable <T> (t);
1400
1401 return default (Nullable <T>);
1402 }
1403
1404 [CLSCompliant (false)]
1405 public static Nullable <T> FindLast <T> (T [] a, Predicate <T> p)
1406 {
1407 if (a == null || p == null)
1408 throw new ArgumentNullException ();
1409
1410 for (int i = a.Length - 1; i >= 0; i--)
1411 if (p (a [i]))
1412 return new Nullable <T> (a [i]);
1413
1414 return default (Nullable <T>);
1415 }
1416 #endif
1417
1418 // Fixme: wtf is constrained about this
1419 public static void ConstrainedCopy (Array s, int s_i, Array d, int d_i, int c)
1420 {
1421 Copy (s, s_i, d, d_i, c);
1422 }
1423 #endif
1424 }
1425 }
Mirror of the official Mono project git repository