Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System/regex/system/text/regularexpressions/RegexMatchCollection.cs

@@ -0,0 +1,265 @@
+//------------------------------------------------------------------------------
+// <copyright file="RegexMatchCollection.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+// The MatchCollection lists the successful matches that
+// result when searching a string for a regular expression.
+
+namespace System.Text.RegularExpressions {
+
+    using System.Collections;
+    using System.Collections.Generic;
+
+
+    /*
+     * This collection returns a sequence of successful match results, either
+     * from GetMatchCollection() or GetExecuteCollection(). It stops when the
+     * first failure is encountered (it does not return the failed match).
+     */
+    /// <devdoc>
+    ///    <para>
+    ///       Represents the set of names appearing as capturing group
+    ///       names in a regular expression.
+    ///    </para>
+    /// </devdoc>
+#if !SILVERLIGHT
+    [ Serializable() ] 
+#endif
+    public class MatchCollection : ICollection {
+        internal Regex _regex;
+#if SILVERLIGHT
+        internal List<Match> _matches;
+#else
+        internal ArrayList _matches;
+#endif
+        internal bool _done;
+        internal String _input;
+        internal int _beginning;
+        internal int _length;
+        internal int _startat;
+        internal int _prevlen;
+
+        private static int infinite = 0x7FFFFFFF;
+
+        /*
+         * Nonpublic constructor
+         */
+        internal MatchCollection(Regex regex, String input, int beginning, int length, int startat) {
+            if (startat < 0 || startat > input.Length)
+                throw new ArgumentOutOfRangeException("startat", SR.GetString(SR.BeginIndexNotNegative));
+
+            _regex = regex;
+            _input = input;
+            _beginning = beginning;
+            _length = length;
+            _startat = startat;
+            _prevlen = -1;
+#if SILVERLIGHT
+            _matches = new List<Match>();
+#else
+            _matches = new ArrayList();
+#endif
+            _done = false;
+        }
+
+        internal Match GetMatch(int i) {
+            if (i < 0)
+                return null;
+
+            if (_matches.Count > i)
+                return (Match)_matches[i];
+
+            if (_done)
+                return null;
+
+            Match match;
+
+            do {
+                match = _regex.Run(false, _prevlen, _input, _beginning, _length, _startat);
+
+                if (!match.Success) {
+                    _done = true;
+                    return null;
+                }
+
+                _matches.Add(match);
+
+                _prevlen = match._length;
+                _startat = match._textpos;
+
+            } while (_matches.Count <= i);
+
+            return match;
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Returns the number of captures.
+        ///    </para>
+        /// </devdoc>
+        public int Count {
+            get {
+                if (_done)
+                    return _matches.Count;
+
+                GetMatch(infinite);
+
+                return _matches.Count;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public Object SyncRoot {
+            get {
+                return this;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool IsSynchronized {
+            get {
+                return false;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool IsReadOnly {
+            get {
+                return true;
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>
+        ///       Returns the ith Match in the collection.
+        ///    </para>
+        /// </devdoc>
+        public virtual Match this[int i]
+        {
+            get {
+                Match match;
+
+                match = GetMatch(i);
+
+                if (match == null)
+                    throw new ArgumentOutOfRangeException("i");
+
+                return match;
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Copies all the elements of the collection to the given array
+        ///       starting at the given index.
+        ///    </para>
+        /// </devdoc>
+        public void CopyTo(Array array, int arrayIndex) {
+            if ((array != null) && (array.Rank != 1))
+            {
+                throw new ArgumentException(SR.GetString(SR.Arg_RankMultiDimNotSupported));
+            }
+
+            // property access to force computation of whole array
+            int count = Count;
+            try
+            {
+#if SILVERLIGHT
+                // Array.Copy will check for null.
+                Array.Copy(_matches.ToArray(), 0, array, arrayIndex, count);
+#else
+                _matches.CopyTo(array, arrayIndex);
+#endif
+            }
+            catch (ArrayTypeMismatchException ex)
+            {
+#if FEATURE_LEGACYNETCF
+                if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8)
+                    throw;
+#endif
+                throw new ArgumentException(SR.GetString(SR.Arg_InvalidArrayType), ex);
+            }
+        }
+
+        /// <devdoc>
+        ///    <para>
+        ///       Provides an enumerator in the same order as Item[i].
+        ///    </para>
+        /// </devdoc>
+        public IEnumerator GetEnumerator() {
+            return new MatchEnumerator(this);
+        }
+    }
+
+    /*
+     * This non-public enumerator lists all the group matches.
+     * Should it be public?
+     */
+#if !SILVERLIGHT
+    [ Serializable() ] 
+#endif
+    internal class MatchEnumerator : IEnumerator {
+        internal MatchCollection _matchcoll;
+        internal Match _match = null;
+        internal int _curindex;
+        internal bool _done;
+
+        /*
+         * Nonpublic constructor
+         */
+        internal MatchEnumerator(MatchCollection matchcoll) {
+            _matchcoll = matchcoll;
+        }
+
+        /*
+         * Advance to the next match
+         */
+        public bool MoveNext() {
+            if (_done)
+                return false;
+
+            _match = _matchcoll.GetMatch(_curindex);
+            _curindex++;
+
+            if (_match == null) {
+                _done = true;
+                return false;
+            }
+
+            return true;
+        }
+
+        /*
+         * The current match
+         */
+        public Object Current {
+            get { 
+                if (_match == null)
+                    throw new InvalidOperationException(SR.GetString(SR.EnumNotStarted));
+                return _match;
+            }
+        }
+
+        /*
+         * Position before the first item
+         */
+        public void Reset() {
+            _curindex = 0;
+            _done = false;
+            _match = null;
+        }
+    }
+
+
+
+
+}