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