-//
-// This software is now distributed according to
-// the Lesser Gnu Public License. Please see
-// http://www.gnu.org/copyleft/lesser.txt for
-// the details.
-// -- Happy Computing!
-//
-package com.stevesoft.pat;
-
-import java.util.*;
-
-/**
- Shareware: package pat
- <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
- */
-/**
- * The RegexTokenizer is similar to the StringTokenizer class provided with
- * java, but allows one to tokenize using regular expressions, rather than a
- * simple list of characters. Tokens are any strings between the supplied
- * regular expression, as well as any backreferences (things in parenthesis)
- * contained within the regular expression.
- */
-public class RegexTokenizer implements Enumeration
-{
- String toParse;
-
- Regex r;
-
- int count = 0;
-
- Vector v = new Vector();
-
- Vector vi = new Vector();
-
- int pos = 0;
-
- int offset = 1;
-
- void getMore()
- {
- String s = r.right();
- if (r.searchFrom(toParse, pos))
- {
- v.addElement(r.left().substring(pos));
- vi.addElement(new Integer(r.matchFrom() + r.charsMatched()));
- for (int i = 0; i < r.numSubs(); i++)
- {
- if (r.substring() != null)
- {
- v.addElement(r.substring(i + offset));
- vi.addElement(new Integer(r.matchFrom(i + offset)
- + r.charsMatched(i + offset)));
- }
- }
- pos = r.matchFrom() + r.charsMatched();
- }
- else if (s != null)
- {
- v.addElement(s);
- }
- }
-
- /** Initialize the tokenizer with a string of text and a pattern */
- public RegexTokenizer(String txt, String ptrn)
- {
- toParse = txt;
- r = new Regex(ptrn);
- offset = Regex.BackRefOffset;
- getMore();
- }
-
- /** Initialize the tokenizer with a Regex object. */
- public RegexTokenizer(String txt, Regex r)
- {
- toParse = txt;
- this.r = r;
- offset = Regex.BackRefOffset;
- getMore();
- }
-
- /**
- * This should always be cast to a String, as in StringTokenizer, and as in
- * StringTokenizer one can do this by calling nextString().
- */
- public Object nextElement()
- {
- if (count >= v.size())
- {
- getMore();
- }
- return v.elementAt(count++);
- }
-
- /** This is the equivalent (String)nextElement(). */
- public String nextToken()
- {
- return (String) nextElement();
- }
-
- /**
- * This asks for the next token, and changes the pattern being used at the
- * same time.
- */
- public String nextToken(String newpat)
- {
- try
- {
- r.compile(newpat);
- } catch (RegSyntax r_)
- {
- }
- return nextToken(r);
- }
-
- /**
- * This asks for the next token, and changes the pattern being used at the
- * same time.
- */
- public String nextToken(Regex nr)
- {
- r = nr;
- if (vi.size() > count)
- {
- pos = ((Integer) vi.elementAt(count)).intValue();
- v.setSize(count);
- vi.setSize(count);
- }
- getMore();
- return nextToken();
- }
-
- /** Tells whether there are more tokens in the pattern. */
- public boolean hasMoreElements()
- {
- if (count >= v.size())
- {
- getMore();
- }
- return count < v.size();
- }
-
- /**
- * Tells whether there are more tokens in the pattern, but in the fashion of
- * StringTokenizer.
- */
- public boolean hasMoreTokens()
- {
- return hasMoreElements();
- }
-
- /** Determines the # of remaining tokens */
- public int countTokens()
- {
- int _count = count;
- while (hasMoreTokens())
- {
- nextToken();
- }
- count = _count;
- return v.size() - count;
- }
-
- /** Returns all tokens in the String */
- public String[] allTokens()
- {
- countTokens();
- String[] ret = new String[v.size()];
- v.copyInto(ret);
- return ret;
- }
-};
+//\r
+// This software is now distributed according to\r
+// the Lesser Gnu Public License. Please see\r
+// http://www.gnu.org/copyleft/lesser.txt for\r
+// the details.\r
+// -- Happy Computing!\r
+//\r
+package com.stevesoft.pat;\r
+\r
+import java.util.*;\r
+\r
+/**\r
+ Shareware: package pat\r
+ <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>\r
+ */\r
+/**\r
+ * The RegexTokenizer is similar to the StringTokenizer class provided with\r
+ * java, but allows one to tokenize using regular expressions, rather than a\r
+ * simple list of characters. Tokens are any strings between the supplied\r
+ * regular expression, as well as any backreferences (things in parenthesis)\r
+ * contained within the regular expression.\r
+ */\r
+public class RegexTokenizer implements Enumeration\r
+{\r
+ String toParse;\r
+\r
+ Regex r;\r
+\r
+ int count = 0;\r
+\r
+ Vector v = new Vector();\r
+\r
+ Vector vi = new Vector();\r
+\r
+ int pos = 0;\r
+\r
+ int offset = 1;\r
+\r
+ void getMore()\r
+ {\r
+ String s = r.right();\r
+ if (r.searchFrom(toParse, pos))\r
+ {\r
+ v.addElement(r.left().substring(pos));\r
+ vi.addElement(new Integer(r.matchFrom() + r.charsMatched()));\r
+ for (int i = 0; i < r.numSubs(); i++)\r
+ {\r
+ if (r.substring() != null)\r
+ {\r
+ v.addElement(r.substring(i + offset));\r
+ vi.addElement(new Integer(r.matchFrom(i + offset)\r
+ + r.charsMatched(i + offset)));\r
+ }\r
+ }\r
+ pos = r.matchFrom() + r.charsMatched();\r
+ }\r
+ else if (s != null)\r
+ {\r
+ v.addElement(s);\r
+ }\r
+ }\r
+\r
+ /** Initialize the tokenizer with a string of text and a pattern */\r
+ public RegexTokenizer(String txt, String ptrn)\r
+ {\r
+ toParse = txt;\r
+ r = new Regex(ptrn);\r
+ offset = Regex.BackRefOffset;\r
+ getMore();\r
+ }\r
+\r
+ /** Initialize the tokenizer with a Regex object. */\r
+ public RegexTokenizer(String txt, Regex r)\r
+ {\r
+ toParse = txt;\r
+ this.r = r;\r
+ offset = Regex.BackRefOffset;\r
+ getMore();\r
+ }\r
+\r
+ /**\r
+ * This should always be cast to a String, as in StringTokenizer, and as in\r
+ * StringTokenizer one can do this by calling nextString().\r
+ */\r
+ public Object nextElement()\r
+ {\r
+ if (count >= v.size())\r
+ {\r
+ getMore();\r
+ }\r
+ return v.elementAt(count++);\r
+ }\r
+\r
+ /** This is the equivalent (String)nextElement(). */\r
+ public String nextToken()\r
+ {\r
+ return (String) nextElement();\r
+ }\r
+\r
+ /**\r
+ * This asks for the next token, and changes the pattern being used at the\r
+ * same time.\r
+ */\r
+ public String nextToken(String newpat)\r
+ {\r
+ try\r
+ {\r
+ r.compile(newpat);\r
+ } catch (RegSyntax r_)\r
+ {\r
+ }\r
+ return nextToken(r);\r
+ }\r
+\r
+ /**\r
+ * This asks for the next token, and changes the pattern being used at the\r
+ * same time.\r
+ */\r
+ public String nextToken(Regex nr)\r
+ {\r
+ r = nr;\r
+ if (vi.size() > count)\r
+ {\r
+ pos = ((Integer) vi.elementAt(count)).intValue();\r
+ v.setSize(count);\r
+ vi.setSize(count);\r
+ }\r
+ getMore();\r
+ return nextToken();\r
+ }\r
+\r
+ /** Tells whether there are more tokens in the pattern. */\r
+ public boolean hasMoreElements()\r
+ {\r
+ if (count >= v.size())\r
+ {\r
+ getMore();\r
+ }\r
+ return count < v.size();\r
+ }\r
+\r
+ /**\r
+ * Tells whether there are more tokens in the pattern, but in the fashion of\r
+ * StringTokenizer.\r
+ */\r
+ public boolean hasMoreTokens()\r
+ {\r
+ return hasMoreElements();\r
+ }\r
+\r
+ /** Determines the # of remaining tokens */\r
+ public int countTokens()\r
+ {\r
+ int _count = count;\r
+ while (hasMoreTokens())\r
+ {\r
+ nextToken();\r
+ }\r
+ count = _count;\r
+ return v.size() - count;\r
+ }\r
+\r
+ /** Returns all tokens in the String */\r
+ public String[] allTokens()\r
+ {\r
+ countTokens();\r
+ String[] ret = new String[v.size()];\r
+ v.copyInto(ret);\r
+ return ret;\r
+ }\r
+};\r
git://source.jalview.org / jalviewjs.git / blobdiff