X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=unused%2Fjavajs%2Futil%2FSB.java;fp=unused%2Fjavajs%2Futil%2FSB.java;h=aed71f38678aa1a629b64821b6fccb1dbb4d1e84;hb=ec8f3cedf60fb1feed6d34de6b49f6bfa78b9dd8;hp=0000000000000000000000000000000000000000;hpb=056dad85a910551cc95e44d451a61f6b8c4dd35d;p=jalview.git

diff --git a/unused/javajs/util/SB.java b/unused/javajs/util/SB.java
new file mode 100644
index 0000000..aed71f3
--- /dev/null
+++ b/unused/javajs/util/SB.java
@@ -0,0 +1,354 @@
+
+package javajs.util;
+
+import java.nio.charset.Charset;
+
+/**
+ * Interesting thing here is that JavaScript is 3x faster than Java in handling strings.
+ * 
+ * Java StringBuilder is final, unfortunately. I guess they weren't thinking about Java2Script!
+ * 
+ * The reason we have to do this that several overloaded append methods is WAY too expensive
+ * 
+ */
+
+public class SB {
+  
+  private java.lang.StringBuilder sb;
+  String s; // used by JavaScript only; no Java references
+  
+  //TODO: JS experiment with using array and .push() here
+
+  public SB() {
+    /**
+     * @j2sNative
+     * 
+     *            this.s = "";
+     * 
+     */
+    {
+      sb = new java.lang.StringBuilder();
+    }
+  }
+
+  public static SB newN(int n) {
+    /**
+     * @j2sNative
+     *            return new javajs.util.SB(); 
+     */
+    {
+      // not perfect, because it requires defining sb twice. 
+      // We can do better...
+      SB sb = new SB();
+      sb.sb = new java.lang.StringBuilder(n);
+      return sb;
+    }
+  }
+
+  public static SB newS(String s) {
+    /**
+     * @j2sNative 
+     * 
+     * var sb = new javajs.util.SB();
+     * sb.s = s;
+     * return sb; 
+     * 
+     */
+    {
+    SB sb = new SB();
+    sb.sb = new java.lang.StringBuilder(s);
+    return sb;
+    }
+  }
+
+  public SB append(String s) {
+    /**
+     * @j2sNative
+     * 
+     *            this.s += s
+     * 
+     */
+    {
+      sb.append(s);
+    }
+    return this;
+  }
+  
+  public SB appendC(char c) {
+    /**
+     * @j2sNative
+     * 
+     *            this.s += c;
+     */
+    {
+      sb.append(c);
+    }
+    return this;
+    
+  }
+
+  public SB appendI(int i) {
+    /**
+     * @j2sNative
+     * 
+     *            this.s += i
+     * 
+     */
+    {
+      sb.append(i);
+    }
+    return this;
+  }
+
+  public SB appendB(boolean b) {
+    /**
+     * @j2sNative
+     * 
+     *            this.s += b
+     * 
+     */
+    {
+      sb.append(b);
+    }
+    return this;
+  }
+
+  /**
+   * note that JavaScript could drop off the ".0" in "1.0"
+   * @param f
+   * @return this
+   */
+  public SB appendF(float f) {
+    /**
+     * @j2sNative
+     * 
+     * var sf = "" + f;
+     * if (sf.indexOf(".") < 0 && sf.indexOf("e") < 0)
+     *   sf += ".0" ;
+     *            this.s += sf;
+     * 
+     */
+    {
+      sb.append(f);
+    }
+    return this;
+  }
+
+  public SB appendD(double d) {
+    /**
+     * @j2sNative
+     * 
+     * var sf = "" + d;
+     * if (sf.indexOf(".") < 0 && sf.indexOf("e") < 0)
+     *   sf += ".0" ;
+     *            this.s += sf;
+     * 
+     */
+    {
+      sb.append(d);
+    }
+    return this;
+  }
+
+  public SB appendSB(SB buf) {
+    /**
+     * @j2sNative
+     * 
+     *            this.s += buf.s;
+     * 
+     */
+    {
+      sb.append(buf.sb);
+    }
+    return this;
+  }
+
+  public SB appendO(Object data) {
+    if (data != null) {
+      /**
+       * @j2sNative
+       * 
+       *            this.s += data.toString();
+       * 
+       */
+      {
+        sb.append(data);
+      }
+    }
+    return this;
+  }
+
+  public void appendCB(char[] cb, int off, int len) {
+    /**
+     * @j2sNative
+     * 
+     * this.s += cb.slice(off,off+len).join("");
+     * 
+     */
+    {
+       sb.append(cb, off, len);
+    }
+  }
+
+  @Override
+  public String toString() {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s;
+     * 
+     */
+    {
+      return sb.toString();
+    }
+  }
+
+  public int length() {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.length;
+     * 
+     */
+    {
+      return sb.length();
+    }
+  }
+
+  public int indexOf(String s) {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.indexOf(s);
+     * 
+     */
+    {
+      return sb.indexOf(s);
+    }
+  }
+
+  public char charAt(int i) {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.charAt(i);
+     * 
+     */
+    {
+      return sb.charAt(i);
+    }
+  }
+
+  public int charCodeAt(int i) {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.charCodeAt(i);
+     * 
+     */
+    {
+      return sb.codePointAt(i);
+    }
+  }
+
+  public void setLength(int n) {
+    /**
+     * @j2sNative
+     * 
+     *            this.s = this.s.substring(0, n);
+     */
+    {
+      sb.setLength(n);
+    }
+  }
+
+  public int lastIndexOf(String s) {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.lastIndexOf(s);
+     */
+    {
+      return sb.lastIndexOf(s);
+    }
+  }
+
+  public int indexOf2(String s, int i) {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.indexOf(s, i);
+     */
+    {
+      return sb.indexOf(s, i);
+    }
+  }
+
+  public String substring(int i) {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.substring(i);
+     */
+    {
+      return sb.substring(i);
+    }
+  }
+
+  public String substring2(int i, int j) {
+    /**
+     * @j2sNative
+     * 
+     *            return this.s.substring(i, j);
+     */
+    {
+      return sb.substring(i, j);
+    }
+  }
+
+  /**
+   * simple byte conversion properly implementing UTF-8. * Used for base64
+   * conversion and allows for offset
+   * 
+   * @param off
+   * @param len
+   *        or -1 for full length (then off must = 0)
+   * @return byte[]
+   */
+  public byte[] toBytes(int off, int len) {
+    if (len == 0)
+      return new byte[0];
+    Charset cs;
+    /**
+     * 
+     * just a string in JavaScript
+     * 
+     * @j2sNative
+     * 
+     *            cs = "UTF-8";
+     * 
+     */
+    {
+      cs = Charset.forName("UTF-8");
+    }
+    return (len > 0 ? substring2(off, off + len) 
+        : off == 0 ? toString()
+        : substring2(off, length() - off)).getBytes(cs);
+  }
+
+	public void replace(int start, int end, String str) {
+		/**
+		 * @j2sNative
+		 * 
+		 * this.s = this.s.substring(0, start) + str + this.s.substring(end);
+		 */
+		{
+			sb.replace(start, end, str);
+		}
+	}
+
+	public void insert(int offset, String str) {
+		replace(offset, offset, str);
+	}
+
+}