update to Jaba_r1 minimal client distribution, and resolve issues JAL-602
[jalview.git] / src / com / stevesoft / pat / RegexTokenizer.java
1 //
2 // This software is now distributed according to
3 // the Lesser Gnu Public License.  Please see
4 // http://www.gnu.org/copyleft/lesser.txt for
5 // the details.
6 //    -- Happy Computing!
7 //
8 package com.stevesoft.pat;
9
10 import java.util.*;
11
12 /**
13  Shareware: package pat
14  <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
15  */
16 /**
17  * The RegexTokenizer is similar to the StringTokenizer class provided with
18  * java, but allows one to tokenize using regular expressions, rather than a
19  * simple list of characters. Tokens are any strings between the supplied
20  * regular expression, as well as any backreferences (things in parenthesis)
21  * contained within the regular expression.
22  */
23 public class RegexTokenizer implements Enumeration
24 {
25   String toParse;
26
27   Regex r;
28
29   int count = 0;
30
31   Vector v = new Vector();
32
33   Vector vi = new Vector();
34
35   int pos = 0;
36
37   int offset = 1;
38
39   void getMore()
40   {
41     String s = r.right();
42     if (r.searchFrom(toParse, pos))
43     {
44       v.addElement(r.left().substring(pos));
45       vi.addElement(new Integer(r.matchFrom() + r.charsMatched()));
46       for (int i = 0; i < r.numSubs(); i++)
47       {
48         if (r.substring() != null)
49         {
50           v.addElement(r.substring(i + offset));
51           vi.addElement(new Integer(r.matchFrom(i + offset)
52                   + r.charsMatched(i + offset)));
53         }
54       }
55       pos = r.matchFrom() + r.charsMatched();
56     }
57     else if (s != null)
58     {
59       v.addElement(s);
60     }
61   }
62
63   /** Initialize the tokenizer with a string of text and a pattern */
64   public RegexTokenizer(String txt, String ptrn)
65   {
66     toParse = txt;
67     r = new Regex(ptrn);
68     offset = Regex.BackRefOffset;
69     getMore();
70   }
71
72   /** Initialize the tokenizer with a Regex object. */
73   public RegexTokenizer(String txt, Regex r)
74   {
75     toParse = txt;
76     this.r = r;
77     offset = Regex.BackRefOffset;
78     getMore();
79   }
80
81   /**
82    * This should always be cast to a String, as in StringTokenizer, and as in
83    * StringTokenizer one can do this by calling nextString().
84    */
85   public Object nextElement()
86   {
87     if (count >= v.size())
88     {
89       getMore();
90     }
91     return v.elementAt(count++);
92   }
93
94   /** This is the equivalent (String)nextElement(). */
95   public String nextToken()
96   {
97     return (String) nextElement();
98   }
99
100   /**
101    * This asks for the next token, and changes the pattern being used at the
102    * same time.
103    */
104   public String nextToken(String newpat)
105   {
106     try
107     {
108       r.compile(newpat);
109     } catch (RegSyntax r_)
110     {
111     }
112     return nextToken(r);
113   }
114
115   /**
116    * This asks for the next token, and changes the pattern being used at the
117    * same time.
118    */
119   public String nextToken(Regex nr)
120   {
121     r = nr;
122     if (vi.size() > count)
123     {
124       pos = ((Integer) vi.elementAt(count)).intValue();
125       v.setSize(count);
126       vi.setSize(count);
127     }
128     getMore();
129     return nextToken();
130   }
131
132   /** Tells whether there are more tokens in the pattern. */
133   public boolean hasMoreElements()
134   {
135     if (count >= v.size())
136     {
137       getMore();
138     }
139     return count < v.size();
140   }
141
142   /**
143    * Tells whether there are more tokens in the pattern, but in the fashion of
144    * StringTokenizer.
145    */
146   public boolean hasMoreTokens()
147   {
148     return hasMoreElements();
149   }
150
151   /** Determines the # of remaining tokens */
152   public int countTokens()
153   {
154     int _count = count;
155     while (hasMoreTokens())
156     {
157       nextToken();
158     }
159     count = _count;
160     return v.size() - count;
161   }
162
163   /** Returns all tokens in the String */
164   public String[] allTokens()
165   {
166     countTokens();
167     String[] ret = new String[v.size()];
168     v.copyInto(ret);
169     return ret;
170   }
171 };