merge from 2_4_Release branch

[jalview.git] / src / com / stevesoft / pat / PartialBuffer.java

diff --git a/src/com/stevesoft/pat/PartialBuffer.java b/src/com/stevesoft/pat/PartialBuffer.java
index 121dd32..c53d6df 100755 (executable)
--- a/src/com/stevesoft/pat/PartialBuffer.java
+++ b/src/com/stevesoft/pat/PartialBuffer.java
@@ -1,106 +1,109 @@
-//\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
-/** This class allows you to match on a partial string.\r
-    If the allowOverRun flag is true, then the\r
-    length() method returns a number 1 larger than\r
-    is actually contained by the class.\r
-    <p>\r
-    If one attempts to access the last character as\r
-    follows:\r
-    <pre>\r
-    StringBuffer sb = ...;\r
-    ...\r
-    PartialBuffer pb = new PartialBuffer(sb);\r
-    char c = pb.charAt(pb.length()-1);\r
-    </pre>\r
-    then two things happen.  First, a zero is returned\r
-    into the variable c.  Second, the overRun flag is\r
-    set to "true."  Accessing data beyond the end of\r
-    the buffer is considered an "overRun" of the data.\r
-    <p>\r
-    This can be helpful in determining whether more\r
-    characters are required for a match to occur, as\r
-    the pseudo-code below illustrates.\r
-    <pre>\r
-    int i = ...;\r
-    Regex r = new Regex("some pattern");\r
-    pb.allowOverRun = true;\r
-    pb.overRun = true;\r
-    boolean result = r.matchAt(pb,i);\r
-    if(pb.overRun) {\r
-      // The result of the match is not relevant, regardless\r
-      // of whether result is true or false.  We need to\r
-      // append more data to the buffer and try again.\r
-      ....\r
-      sb.append(more data);\r
-    }\r
-    </pre>\r
- */\r
-class PartialBuffer\r
-    implements StringLike\r
-{\r
-  int off;\r
-  public boolean allowOverRun = true;\r
-  public boolean overRun = false;\r
-  StringBuffer sb;\r
-  PartialBuffer(StringBuffer sb)\r
-  {\r
-    this.sb = sb;\r
-  }\r
-\r
-  public char charAt(int n)\r
-  {\r
-    n += off;\r
-    if (n == sb.length())\r
-    {\r
-      overRun = true;\r
-      return 0;\r
-    }\r
-    return sb.charAt(n);\r
-  }\r
-\r
-  public int length()\r
-  {\r
-    return allowOverRun ? sb.length() + 1 : sb.length();\r
-  }\r
-\r
-  public int indexOf(char c)\r
-  {\r
-    for (int i = 0; i < sb.length(); i++)\r
-    {\r
-      if (sb.charAt(i) == c)\r
-      {\r
-        return i;\r
-      }\r
-    }\r
-    return -1;\r
-  }\r
-\r
-  public Object unwrap()\r
-  {\r
-    return sb;\r
-  }\r
-\r
-  public String substring(int i1, int i2)\r
-  {\r
-    StringBuffer sb = new StringBuffer(i2 - i1);\r
-    for (int i = i1; i < i2; i++)\r
-    {\r
-      sb.append(charAt(i));\r
-    }\r
-    return sb.toString();\r
-  }\r
-\r
-  /** Just returns null. */\r
-  public BasicStringBufferLike newStringBufferLike()\r
-  {\r
-    return null;\r
-  }\r
-}\r
+//
+// 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;
+
+/**
+ * This class allows you to match on a partial string. If the allowOverRun flag
+ * is true, then the length() method returns a number 1 larger than is actually
+ * contained by the class.
+ * <p>
+ * If one attempts to access the last character as follows:
+ * 
+ * <pre>
+ *  StringBuffer sb = ...;
+ *  ...
+ *  PartialBuffer pb = new PartialBuffer(sb);
+ *  char c = pb.charAt(pb.length()-1);
+ * </pre>
+ * 
+ * then two things happen. First, a zero is returned into the variable c.
+ * Second, the overRun flag is set to "true." Accessing data beyond the end of
+ * the buffer is considered an "overRun" of the data.
+ * <p>
+ * This can be helpful in determining whether more characters are required for a
+ * match to occur, as the pseudo-code below illustrates.
+ * 
+ * <pre>
+ *  int i = ...;
+ *  Regex r = new Regex(&quot;some pattern&quot;);
+ *  pb.allowOverRun = true;
+ *  pb.overRun = true;
+ *  boolean result = r.matchAt(pb,i);
+ *  if(pb.overRun) {
+ *  // The result of the match is not relevant, regardless
+ *  // of whether result is true or false.  We need to
+ *  // append more data to the buffer and try again.
+ *  ....
+ *  sb.append(more data);
+ *  }
+ * </pre>
+ */
+class PartialBuffer implements StringLike
+{
+  int off;
+
+  public boolean allowOverRun = true;
+
+  public boolean overRun = false;
+
+  StringBuffer sb;
+
+  PartialBuffer(StringBuffer sb)
+  {
+    this.sb = sb;
+  }
+
+  public char charAt(int n)
+  {
+    n += off;
+    if (n == sb.length())
+    {
+      overRun = true;
+      return 0;
+    }
+    return sb.charAt(n);
+  }
+
+  public int length()
+  {
+    return allowOverRun ? sb.length() + 1 : sb.length();
+  }
+
+  public int indexOf(char c)
+  {
+    for (int i = 0; i < sb.length(); i++)
+    {
+      if (sb.charAt(i) == c)
+      {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  public Object unwrap()
+  {
+    return sb;
+  }
+
+  public String substring(int i1, int i2)
+  {
+    StringBuffer sb = new StringBuffer(i2 - i1);
+    for (int i = i1; i < i2; i++)
+    {
+      sb.append(charAt(i));
+    }
+    return sb.toString();
+  }
+
+  /** Just returns null. */
+  public BasicStringBufferLike newStringBufferLike()
+  {
+    return null;
+  }
+}