/[dotgnu-pnet]/pnetlib/System/Text/RegularExpressions/GroupCollection.cs
ViewVC logotype

Diff of /pnetlib/System/Text/RegularExpressions/GroupCollection.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by ktreichel, Wed Jun 9 17:01:09 2004 UTC revision 1.2 by t3rmin4t0r, Fri Aug 19 23:36:38 2005 UTC
# Line 9  Line 9 
9  // (C) 2004 Novell, Inc.  // (C) 2004 Novell, Inc.
10  //  //
11    
12    //
13    // Permission is hereby granted, free of charge, to any person obtaining
14    // a copy of this software and associated documentation files (the
15    // "Software"), to deal in the Software without restriction, including
16    // without limitation the rights to use, copy, modify, merge, publish,
17    // distribute, sublicense, and/or sell copies of the Software, and to
18    // permit persons to whom the Software is furnished to do so, subject to
19    // the following conditions:
20    //
21    // The above copyright notice and this permission notice shall be
22    // included in all copies or substantial portions of the Software.
23    //
24    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25    // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27    // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28    // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29    // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30    // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31    //
32    
33  using System;  using System;
34  using System.Collections;  using System.Collections;
35    
# Line 17  namespace System.Text.RegularExpressions Line 38  namespace System.Text.RegularExpressions
38          [Serializable]          [Serializable]
39          public class GroupCollection: ICollection, IEnumerable          public class GroupCollection: ICollection, IEnumerable
40          {          {
41                  private ArrayList list;                  private Group [] list;
42    
43                  /* No public constructor */                  /* No public constructor */
44                  internal GroupCollection () {                  internal GroupCollection (int n)
45                          list = new ArrayList ();                  {
46                            list = new Group [n];
47                  }                  }
48    
49                  public virtual int Count {                  public virtual int Count {
50                          get {                          get { return list.Length; }
                                 return(list.Count);  
                         }  
51                  }                  }
52    
53                  public bool IsReadOnly {                  public bool IsReadOnly {
54                          get {                          get { return true; }
                                 return(true);  
                         }  
55                  }                  }
56    
57                  public virtual bool IsSynchronized {                  public virtual bool IsSynchronized {
58                          get {                          get { return false; }
                                 return(false);  
                         }  
59                  }                  }
60    
61                  public Group this[int i] {                  public Group this [int i] {
62                          get {                          get {
63                                  if (i < list.Count &&                                  if (i < list.Length && i >= 0)
64                                      i >= 0) {                                          return list [i];
65                                          return((Group)list[i]);                                  else
66                                  } else {                                          return Group.Fail;
                                         return(new Group ());  
                                 }  
67                          }                          }
68                  }                  }
69    
70                  public Group this[string groupName] {                  internal void SetValue (Group g, int i)
71                          get {                  {
72                                  foreach (object o in list) {                          list [i] = g;
                                         if (!(o is Match)) {  
                                                 continue;  
                                         }  
   
                                         int index = ((Match)o).Regex.GroupNumberFromName (groupName);  
   
                                         if (index != -1) {  
                                                 return(this[index]);  
                                         }  
                                 }  
   
                                 return(new Group ());  
                         }  
73                  }                  }
74    
75                  public virtual object SyncRoot {                  public Group this [string groupName] {
76                          get {                          get {
77                                  return(list);                                  // The 0th group is the match.
78                          }                                  Match m = (Match) list [0];
79                  }                                  if (m != Match.Empty) {
80                                            int index = m.Regex.GroupNumberFromName (groupName);
81                  public virtual void CopyTo (Array array, int index) {                                          if (index != -1)
82                          foreach (object o in list) {                                                  return this [index];
                                 if (index > array.Length) {  
                                         break;  
83                                  }                                  }
84    
85                                  array.SetValue (o, index++);                                  return Group.Fail;
86                          }                          }
87                  }                  }
88    
89                  public virtual IEnumerator GetEnumerator () {                  public virtual object SyncRoot {
90                          return(new Enumerator (list));                          get { return list; }
                 }  
   
                 internal void Add (object o) {  
                         list.Add (o);  
91                  }                  }
92    
93                  internal void Reverse () {                  public virtual void CopyTo (Array array, int index)
94                          list.Reverse ();                  {
95                            list.CopyTo (array, index);
96                  }                  }
97    
98                  private class Enumerator: IEnumerator {                  public virtual IEnumerator GetEnumerator ()
99                          private IList list;                  {
100                          private int ptr;                          return list.GetEnumerator ();
   
                         public Enumerator (IList list) {  
                                 this.list = list;  
                                 Reset ();  
                         }  
   
                         public object Current {  
                                 get {  
                                         if (ptr >= list.Count) {  
                                                 throw new InvalidOperationException ();  
                                         }  
   
                                         return(list[ptr]);  
                                 }  
                         }  
   
                         public bool MoveNext () {  
                                 if (ptr > list.Count) {  
                                         throw new InvalidOperationException ();  
                                 }  
   
                                 return(++ptr < list.Count);  
                         }  
   
                         public void Reset () {  
                                 ptr = -1;  
                         }  
101                  }                  }
102          }          }
103  }  }

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26