The Labs \ Source Viewer \ SSCLI \ System.Text.RegularExpressions \ MatchCollection

  1. //------------------------------------------------------------------------------
  2. // <copyright file="RegexMatchCollection.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. // The MatchCollection lists the successful matches that
  16. // result when searching a string for a regular expression.
  17. namespace System.Text.RegularExpressions
  18. {
  19.    
  20.     using System.Collections;
  21.    
  22.    
  23. /*
  24.     * This collection returns a sequence of successful match results, either
  25.     * from GetMatchCollection() or GetExecuteCollection(). It stops when the
  26.     * first failure is encountered (it does not return the failed match).
  27.     */   
  28.     /// <devdoc>
  29.     /// <para>
  30.     /// Represents the set of names appearing as capturing group
  31.     /// names in a regular expression.
  32.     /// </para>
  33.     /// </devdoc>
  34.     [Serializable()]
  35.     public class MatchCollection : ICollection
  36.     {
  37.         internal Regex _regex;
  38.         internal ArrayList _matches;
  39.         internal bool _done;
  40.         internal string _input;
  41.         internal int _beginning;
  42.         internal int _length;
  43.         internal int _startat;
  44.         internal int _prevlen;
  45.        
  46.         private static int infinite = 2147483647;
  47.        
  48. /*
  49.         * Nonpublic constructor
  50.         */       
  51.         internal MatchCollection(Regex regex, string input, int beginning, int length, int startat)
  52.         {
  53.             if (startat < 0 || startat > input.Length)
  54.                 throw new ArgumentOutOfRangeException("startat", SR.GetString(SR.BeginIndexNotNegative));
  55.            
  56.             _regex = regex;
  57.             _input = input;
  58.             _beginning = beginning;
  59.             _length = length;
  60.             _startat = startat;
  61.             _prevlen = -1;
  62.             _matches = new ArrayList();
  63.             _done = false;
  64.         }
  65.        
  66.         internal Match GetMatch(int i)
  67.         {
  68.             if (i < 0)
  69.                 return null;
  70.            
  71.             if (_matches.Count > i)
  72.                 return (Match)_matches[i];
  73.            
  74.             if (_done)
  75.                 return null;
  76.            
  77.             Match match;
  78.            
  79.             do {
  80.                 match = _regex.Run(false, _prevlen, _input, _beginning, _length, _startat);
  81.                
  82.                 if (!match.Success) {
  83.                     _done = true;
  84.                     return null;
  85.                 }
  86.                
  87.                 _matches.Add(match);
  88.                
  89.                 _prevlen = match._length;
  90.                 _startat = match._textpos;
  91.                
  92.             }
  93.             while (_matches.Count <= i);
  94.            
  95.             return match;
  96.         }
  97.        
  98.         /// <devdoc>
  99.         /// <para>
  100.         /// Returns the number of captures.
  101.         /// </para>
  102.         /// </devdoc>
  103.         public int Count {
  104.             get {
  105.                 if (_done)
  106.                     return _matches.Count;
  107.                
  108.                 GetMatch(infinite);
  109.                
  110.                 return _matches.Count;
  111.             }
  112.         }
  113.        
  114.         /// <devdoc>
  115.         /// <para>[To be supplied.]</para>
  116.         /// </devdoc>
  117.         public object SyncRoot {
  118.             get { return this; }
  119.         }
  120.        
  121.         /// <devdoc>
  122.         /// <para>[To be supplied.]</para>
  123.         /// </devdoc>
  124.         public bool IsSynchronized {
  125.             get { return false; }
  126.         }
  127.        
  128.         /// <devdoc>
  129.         /// <para>[To be supplied.]</para>
  130.         /// </devdoc>
  131.         public bool IsReadOnly {
  132.             get { return true; }
  133.         }
  134.        
  135.        
  136.         /// <devdoc>
  137.         /// <para>
  138.         /// Returns the ith Match in the collection.
  139.         /// </para>
  140.         /// </devdoc>
  141.         public virtual Match this[int i]
  142.         {
  143.             get {
  144.                 Match match;
  145.                
  146.                 match = GetMatch(i);
  147.                
  148.                 if (match == null)
  149.                     throw new ArgumentOutOfRangeException("i");
  150.                
  151.                 return match;
  152.             }
  153.         }
  154.        
  155.         /// <devdoc>
  156.         /// <para>
  157.         /// Copies all the elements of the collection to the given array
  158.         /// starting at the given index.
  159.         /// </para>
  160.         /// </devdoc>
  161.         public void CopyTo(Array array, int arrayIndex)
  162.         {
  163.             // property access to force computation of whole array
  164.             int count = Count;
  165.            
  166.             _matches.CopyTo(array, arrayIndex);
  167.         }
  168.        
  169.         /// <devdoc>
  170.         /// <para>
  171.         /// Provides an enumerator in the same order as Item[i].
  172.         /// </para>
  173.         /// </devdoc>
  174.         public IEnumerator GetEnumerator()
  175.         {
  176.             return new MatchEnumerator(this);
  177.         }
  178.     }
  179.    
  180. /*
  181.     * This non-public enumerator lists all the group matches.
  182.     * Should it be public?
  183.     */   
  184.     [Serializable()]
  185.     internal class MatchEnumerator : IEnumerator
  186.     {
  187.         internal MatchCollection _matchcoll;
  188.         internal Match _match = null;
  189.         internal int _curindex;
  190.         internal bool _done;
  191.        
  192. /*
  193.         * Nonpublic constructor
  194.         */       
  195.         internal MatchEnumerator(MatchCollection matchcoll)
  196.         {
  197.             _matchcoll = matchcoll;
  198.         }
  199.        
  200. /*
  201.         * Advance to the next match
  202.         */       
  203.         public bool MoveNext()
  204.         {
  205.             if (_done)
  206.                 return false;
  207.            
  208.             _match = _matchcoll.GetMatch(_curindex++);
  209.            
  210.             if (_match == null) {
  211.                 _done = true;
  212.                 return false;
  213.             }
  214.            
  215.             return true;
  216.         }
  217.        
  218. /*
  219.         * The current match
  220.         */       
  221.         public object Current {
  222.             get {
  223.                 if (_match == null)
  224.                     throw new InvalidOperationException(SR.GetString(SR.EnumNotStarted));
  225.                 return _match;
  226.             }
  227.         }
  228.        
  229. /*
  230.         * Position before the first item
  231.         */       
  232.         public void Reset()
  233.         {
  234.             _curindex = 0;
  235.             _done = false;
  236.             _match = null;
  237.         }
  238.     }
  239.    
  240.    
  241.    
  242.    
  243. }

Developer Fusion