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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="RegexGroupCollection.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 GroupCollection lists the captured Capture numbers
  16. // contained in a compiled Regex.
  17. namespace System.Text.RegularExpressions
  18. {
  19.    
  20.     using System.Collections;
  21.    
  22.     /// <devdoc>
  23.     /// <para>
  24.     /// Represents a sequence of capture substrings. The object is used
  25.     /// to return the set of captures done by a single capturing group.
  26.     /// </para>
  27.     /// </devdoc>
  28.     [Serializable()]
  29.     public class GroupCollection : ICollection
  30.     {
  31.         internal Match _match;
  32.         internal Hashtable _captureMap;
  33.        
  34.         // cache of Group objects fed to the user
  35.         internal Group[] _groups;
  36.        
  37. /*
  38.         * Nonpublic constructor
  39.         */       
  40.         internal GroupCollection(Match match, Hashtable caps)
  41.         {
  42.             _match = match;
  43.             _captureMap = caps;
  44.         }
  45.        
  46. /*
  47.         * The object on which to synchronize
  48.         */       
  49.         /// <devdoc>
  50.         /// <para>[To be supplied.]</para>
  51.         /// </devdoc>
  52.         public object SyncRoot {
  53.             get { return _match; }
  54.         }
  55.        
  56. /*
  57.         * ICollection
  58.         */       
  59.         /// <devdoc>
  60.         /// <para>[To be supplied.]</para>
  61.         /// </devdoc>
  62.         public bool IsSynchronized {
  63.             get { return false; }
  64.         }
  65.        
  66. /*
  67.         * ICollection
  68.         */       
  69.         /// <devdoc>
  70.         /// <para>[To be supplied.]</para>
  71.         /// </devdoc>
  72.         public bool IsReadOnly {
  73.             get { return true; }
  74.         }
  75.        
  76.         /// <devdoc>
  77.         /// <para>
  78.         /// Returns the number of groups.
  79.         /// </para>
  80.         /// </devdoc>
  81.         public int Count {
  82.             get { return _match._matchcount.Length; }
  83.         }
  84.        
  85.         /// <devdoc>
  86.         /// <para>[To be supplied.]</para>
  87.         /// </devdoc>
  88.         public Group this[int groupnum]
  89.         {
  90.             get { return GetGroup(groupnum); }
  91.         }
  92.        
  93.         /// <devdoc>
  94.         /// <para>[To be supplied.]</para>
  95.         /// </devdoc>
  96.         public Group this[string groupname]
  97.         {
  98.             get {
  99.                 if (_match._regex == null)
  100.                     return Group._emptygroup;
  101.                
  102.                 return GetGroup(_match._regex.GroupNumberFromName(groupname));
  103.             }
  104.         }
  105.        
  106.         internal Group GetGroup(int groupnum)
  107.         {
  108.             if (_captureMap != null) {
  109.                 object o;
  110.                
  111.                 o = _captureMap[groupnum];
  112.                 if (o == null)
  113.                     return Group._emptygroup;
  114.                 //throw new ArgumentOutOfRangeException("groupnum");
  115.                
  116.                 return GetGroupImpl((int)o);
  117.             }
  118.             else {
  119.                 //if (groupnum >= _match._regex.CapSize || groupnum < 0)
  120.                 // throw new ArgumentOutOfRangeException("groupnum");
  121.                 if (groupnum >= _match._matchcount.Length || groupnum < 0)
  122.                     return Group._emptygroup;
  123.                
  124.                 return GetGroupImpl(groupnum);
  125.             }
  126.         }
  127.        
  128.        
  129. /*
  130.         * Caches the group objects
  131.         */       
  132.         internal Group GetGroupImpl(int groupnum)
  133.         {
  134.             if (groupnum == 0)
  135.                 return _match;
  136.            
  137.             // Construct all the Group objects the first time GetGroup is called
  138.            
  139.             if (_groups == null) {
  140.                 _groups = new Group[_match._matchcount.Length - 1];
  141.                 for (int i = 0; i < _groups.Length; i++) {
  142.                     _groups[i] = new Group(_match._text, _match._matches[i + 1], _match._matchcount[i + 1]);
  143.                 }
  144.             }
  145.            
  146.             return _groups[groupnum - 1];
  147.         }
  148.        
  149. /*
  150.         * As required by ICollection
  151.         */       
  152.         /// <devdoc>
  153.         /// <para>
  154.         /// Copies all the elements of the collection to the given array
  155.         /// beginning at the given index.
  156.         /// </para>
  157.         /// </devdoc>
  158.         public void CopyTo(Array array, int arrayIndex)
  159.         {
  160.             if (array == null)
  161.                 throw new ArgumentNullException("array");
  162.            
  163.             for (int i = arrayIndexint j = 0; j < Count; i++,j++) {
  164.                 array.SetValue(this[j], i);
  165.             }
  166.         }
  167.        
  168. /*
  169.         * As required by ICollection
  170.         */       
  171.         /// <devdoc>
  172.         /// <para>
  173.         /// Provides an enumerator in the same order as Item[].
  174.         /// </para>
  175.         /// </devdoc>
  176.         public IEnumerator GetEnumerator()
  177.         {
  178.             return new GroupEnumerator(this);
  179.         }
  180.     }
  181.    
  182.    
  183. /*
  184.     * This non-public enumerator lists all the captures
  185.     * Should it be public?
  186.     */   
  187.     internal class GroupEnumerator : IEnumerator
  188.     {
  189.         internal GroupCollection _rgc;
  190.         internal int _curindex;
  191.        
  192. /*
  193.         * Nonpublic constructor
  194.         */       
  195.         internal GroupEnumerator(GroupCollection rgc)
  196.         {
  197.             _curindex = -1;
  198.             _rgc = rgc;
  199.         }
  200.        
  201. /*
  202.         * As required by IEnumerator
  203.         */       
  204.         public bool MoveNext()
  205.         {
  206.             int size = _rgc.Count;
  207.            
  208.             if (_curindex >= size)
  209.                 return false;
  210.            
  211.             _curindex++;
  212.            
  213.             return (_curindex < size);
  214.         }
  215.        
  216. /*
  217.         * As required by IEnumerator
  218.         */       
  219.         public object Current {
  220.             get { return Capture; }
  221.         }
  222.        
  223. /*
  224.         * Returns the current capture
  225.         */       
  226.         public Capture Capture {
  227.             get {
  228.                 if (_curindex < 0 || _curindex >= _rgc.Count)
  229.                     throw new InvalidOperationException(SR.GetString(SR.EnumNotStarted));
  230.                
  231.                 return _rgc[_curindex];
  232.             }
  233.         }
  234.        
  235. /*
  236.         * Reset to before the first item
  237.         */       
  238.         public void Reset()
  239.         {
  240.             _curindex = -1;
  241.         }
  242.     }
  243.    
  244. }

Developer Fusion