internal IEnumerator<T> InternalArray__IEnumerable_GetEnumerator<T> ()
{
- return new InternalEnumerator<T> (this);
+ if (Length == 0)
+ return EmptyInternalEnumerator<T>.Value;
+ else
+ return new InternalEnumerator<T> (this);
}
internal void InternalArray__ICollection_Clear ()
// we just decr the size, so, 0 - 1 == FINISHED
const int FINISHED = -1;
- Array array;
+ readonly Array array;
int idx;
internal InternalEnumerator (Array array)
public void Dispose ()
{
- idx = NOT_STARTED;
}
public bool MoveNext ()
}
}
+ internal class EmptyInternalEnumerator<T> : IEnumerator<T>
+ {
+ public static readonly EmptyInternalEnumerator<T> Value = new EmptyInternalEnumerator<T> ();
+
+ public void Dispose ()
+ {
+ return;
+ }
+
+ public bool MoveNext ()
+ {
+ return false;
+ }
+
+ public T Current {
+ get {
+ throw new InvalidOperationException ("Enumeration has not started. Call MoveNext");
+ }
+ }
+
+ object IEnumerator.Current {
+ get {
+ return Current;
+ }
+ }
+
+ void IEnumerator.Reset ()
+ {
+ return;
+ }
+ }
+
// InternalCall Methods
[MethodImplAttribute (MethodImplOptions.InternalCall)]
extern int GetRank ();
public object GetValue (int index)
{
if (Rank != 1)
- throw new ArgumentException (Locale.GetText ("Array was not a one-dimensional array."));
- if (index < GetLowerBound (0) || index > GetUpperBound (0))
+ throw new ArgumentException (SR.Arg_RankMultiDimNotSupported);
+
+ var lb = GetLowerBound (0);
+ if (index < lb || index > GetUpperBound (0))
throw new IndexOutOfRangeException (Locale.GetText (
"Index has to be between upper and lower bound of the array."));
- return GetValueImpl (index - GetLowerBound (0));
+ if (GetType ().GetElementType ().IsPointer)
+ throw new NotSupportedException ("Type is not supported");
+
+ return GetValueImpl (index - lb);
}
public object GetValue (int index1, int index2)
public void SetValue (object value, int index)
{
if (Rank != 1)
- throw new ArgumentException (Locale.GetText ("Array was not a one-dimensional array."));
- if (index < GetLowerBound (0) || index > GetUpperBound (0))
+ throw new ArgumentException (SR.Arg_RankMultiDimNotSupported);
+
+ var lb = GetLowerBound (0);
+ if (index < lb || index > GetUpperBound (0))
throw new IndexOutOfRangeException (Locale.GetText (
"Index has to be >= lower bound and <= upper bound of the array."));
- SetValueImpl (value, index - GetLowerBound (0));
+ if (GetType ().GetElementType ().IsPointer)
+ throw new NotSupportedException ("Type is not supported");
+
+ SetValueImpl (value, index - lb);
}
public void SetValue (object value, int index1, int index2)
return source.IsAssignableFrom (target) || target.IsAssignableFrom (source);
}
- public static T[] FindAll<T> (T[] array, Predicate<T> match)
- {
- if (array == null)
- throw new ArgumentNullException ("array");
-
- if (match == null)
- throw new ArgumentNullException ("match");
-
- int pos = 0;
- T[] d = Empty<T>();
- for (int i = 0; i < array.Length; i++) {
- if (match (array [i])) {
- if (pos == d.Length)
- Resize (ref d, pos == 0 ? 4 : pos * 2);
-
- d [pos++] = array [i];
- }
- }
-
- if (pos != d.Length)
- Resize (ref d, pos);
-
- return d;
- }
-
[ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
//
// The constrained copy should guarantee that if there is an exception thrown
Copy (sourceArray, sourceIndex, destinationArray, destinationIndex, length);
}
- object GetValueWithFlattenedIndex_NoErrorCheck (int flattenedIndex)
+ public static T[] Empty<T>()
+ {
+ return EmptyArray<T>.Value;
+ }
+
+ public void Initialize()
+ {
+ return;
+ }
+
+ static int IndexOfImpl<T>(T[] array, T value, int startIndex, int count)
+ {
+ return EqualityComparer<T>.Default.IndexOf (array, value, startIndex, count);
+ }
+
+ static int LastIndexOfImpl<T>(T[] array, T value, int startIndex, int count)
+ {
+ return EqualityComparer<T>.Default.LastIndexOf (array, value, startIndex, count);
+ }
+
+ static void SortImpl (Array keys, Array items, int index, int length, IComparer comparer)
{
- return GetValueImpl (flattenedIndex);
+ Object[] objKeys = keys as Object[];
+ Object[] objItems = null;
+ if (objKeys != null)
+ objItems = items as Object[];
+
+ if (objKeys != null && (items == null || objItems != null)) {
+ SorterObjectArray sorter = new SorterObjectArray(objKeys, objItems, comparer);
+ sorter.Sort(index, length);
+ } else {
+ SorterGenericArray sorter = new SorterGenericArray(keys, items, comparer);
+ sorter.Sort(index, length);
+ }
}
#region Unsafe array operations
return comparison(x, y);
}
}
+
+ partial class ArrayEnumerator
+ {
+ public Object Current {
+ get {
+ if (_index < 0) throw new InvalidOperationException (SR.InvalidOperation_EnumNotStarted);
+ if (_index >= _endIndex) throw new InvalidOperationException (SR.InvalidOperation_EnumEnded);
+ if (_index == 0 && _array.GetType ().GetElementType ().IsPointer) throw new NotSupportedException ("Type is not supported");
+ return _array.GetValueImpl(_index);
+ }
+ }
+ }
}
}
projects / mono.git / blobdiff