JAL-2629 can now filter by sequence e-value or bit score
[jalview.git] / src / com / stevesoft / pat / StrPos.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 /**
11  Shareware: package pat
12  <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
13  */
14 /**
15  * StrPos is used internally by regex to parse the regular expression.
16  */
17 public class StrPos
18 {
19   String s;
20
21   int pos;
22
23   /** Return the position in the string pointed to */
24   public int pos()
25   {
26     return pos;
27   }
28
29   /** This contains the escape character, which is \ by default. */
30   public char esc = Pattern.ESC;
31
32   char c;
33
34   /** Returns the current, possibly escaped, character. */
35   public char thisChar()
36   {
37     return c;
38   }
39
40   boolean dontMatch, eos;
41
42   /** tell whether we are at end of string */
43   public boolean eos()
44   {
45     return eos;
46   }
47
48   /** initialize a StrPos from another StrPos. */
49   public StrPos(StrPos sp)
50   {
51     dup(sp);
52   }
53
54   /** copy a StrPos from sp to this. */
55   public void dup(StrPos sp)
56   {
57     s = sp.s;
58     pos = sp.pos;
59     c = sp.c;
60     dontMatch = sp.dontMatch;
61     eos = sp.eos;
62   }
63
64   /**
65    * Initialize a StrPos by giving it a String, and a position within the
66    * String.
67    */
68   public StrPos(String s, int pos)
69   {
70     this.s = s;
71     this.pos = pos - 1;
72     inc();
73   }
74
75   /**
76    * Advance the place where StrPos points within the String. Counts a backslash
77    * as part of the next character.
78    */
79   public StrPos inc()
80   {
81     pos++;
82     if (pos >= s.length())
83     {
84       eos = true;
85       return this;
86     }
87     eos = false;
88     c = s.charAt(pos);
89     if (c == esc && pos + 1 < s.length())
90     {
91       pos++;
92       c = s.charAt(pos);
93       if (c != esc)
94       {
95         dontMatch = true;
96       }
97       else
98       {
99         dontMatch = false;
100       }
101     }
102     else
103     {
104       dontMatch = false;
105     }
106     return this;
107   }
108
109   /**
110    * Compare the (possibly escaped) character pointed to by StrPos. Return true
111    * if they are the same, but lways return if character pointed to is escaped.
112    */
113   public boolean match(char ch)
114   {
115     if (dontMatch || eos)
116     {
117       return false;
118     }
119     return c == ch;
120   }
121
122   /** As match, but only matches if the character is escaped. */
123   public boolean escMatch(char ch)
124   {
125     if (!dontMatch || eos)
126     {
127       return false;
128     }
129     return c == ch;
130   }
131
132   /**
133    * Returns true if the current character is escaped (preceeded by "\").
134    */
135   public boolean escaped()
136   {
137     return dontMatch;
138   }
139
140   /**
141    * Increment the string pointer by each character in
142    * 
143    * <pre>
144    * st
145    * </pre>
146    * 
147    * that matches a non-escaped character.
148    */
149   public boolean incMatch(String st)
150   {
151     StrPos sp = new StrPos(this);
152     int i;
153     for (i = 0; i < st.length(); i++)
154     {
155       if (!sp.match(st.charAt(i)))
156       {
157         return false;
158       }
159       sp.inc();
160     }
161     dup(sp);
162     return true;
163   }
164
165   /** Read in an integer. */
166   public patInt getPatInt()
167   {
168     if (incMatch("inf"))
169     {
170       return new patInf();
171     }
172     int i, cnt = 0;
173     StrPos sp = new StrPos(this);
174     for (i = 0; !sp.eos && sp.c >= '0' && sp.c <= '9'; i++)
175     {
176       cnt = 10 * cnt + sp.c - '0';
177       sp.inc();
178     }
179     if (i == 0)
180     {
181       return null;
182     }
183     dup(sp);
184     return new patInt(cnt);
185   }
186
187   /** get the string that we are processing. */
188   public String getString()
189   {
190     return s;
191   }
192 };