Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / SB.java
1
2 package javajs.util;
3
4 import java.nio.charset.Charset;
5
6 /**
7  * Interesting thing here is that JavaScript is 3x faster than Java in handling strings.
8  * 
9  * Java StringBuilder is final, unfortunately. I guess they weren't thinking about Java2Script!
10  * 
11  * The reason we have to do this that several overloaded append methods is WAY too expensive
12  * 
13  */
14
15 public class SB {
16   
17   private java.lang.StringBuilder sb;
18   String s; // used by JavaScript only; no Java references
19   
20   //TODO: JS experiment with using array and .push() here
21
22   public SB() {
23     /**
24      * @j2sNative
25      * 
26      *            this.s = "";
27      * 
28      */
29     {
30       sb = new java.lang.StringBuilder();
31     }
32   }
33
34   public static SB newN(int n) {
35     /**
36      * @j2sNative
37      *            return new javajs.util.SB(); 
38      */
39     {
40       // not perfect, because it requires defining sb twice. 
41       // We can do better...
42       SB sb = new SB();
43       sb.sb = new java.lang.StringBuilder(n);
44       return sb;
45     }
46   }
47
48   public static SB newS(String s) {
49     /**
50      * @j2sNative 
51      * 
52      * var sb = new javajs.util.SB();
53      * sb.s = s;
54      * return sb; 
55      * 
56      */
57     {
58     SB sb = new SB();
59     sb.sb = new java.lang.StringBuilder(s);
60     return sb;
61     }
62   }
63
64   public SB append(String s) {
65     /**
66      * @j2sNative
67      * 
68      *            this.s += s
69      * 
70      */
71     {
72       sb.append(s);
73     }
74     return this;
75   }
76   
77   public SB appendC(char c) {
78     /**
79      * @j2sNative
80      * 
81      *            this.s += c;
82      */
83     {
84       sb.append(c);
85     }
86     return this;
87     
88   }
89
90   public SB appendI(int i) {
91     /**
92      * @j2sNative
93      * 
94      *            this.s += i
95      * 
96      */
97     {
98       sb.append(i);
99     }
100     return this;
101   }
102
103   public SB appendB(boolean b) {
104     /**
105      * @j2sNative
106      * 
107      *            this.s += b
108      * 
109      */
110     {
111       sb.append(b);
112     }
113     return this;
114   }
115
116   /**
117    * note that JavaScript could drop off the ".0" in "1.0"
118    * @param f
119    * @return this
120    */
121   public SB appendF(float f) {
122     /**
123      * @j2sNative
124      * 
125      * var sf = "" + f;
126      * if (sf.indexOf(".") < 0 && sf.indexOf("e") < 0)
127      *   sf += ".0" ;
128      *            this.s += sf;
129      * 
130      */
131     {
132       sb.append(f);
133     }
134     return this;
135   }
136
137   public SB appendD(double d) {
138     /**
139      * @j2sNative
140      * 
141      * var sf = "" + d;
142      * if (sf.indexOf(".") < 0 && sf.indexOf("e") < 0)
143      *   sf += ".0" ;
144      *            this.s += sf;
145      * 
146      */
147     {
148       sb.append(d);
149     }
150     return this;
151   }
152
153   public SB appendSB(SB buf) {
154     /**
155      * @j2sNative
156      * 
157      *            this.s += buf.s;
158      * 
159      */
160     {
161       sb.append(buf.sb);
162     }
163     return this;
164   }
165
166   public SB appendO(Object data) {
167     if (data != null) {
168       /**
169        * @j2sNative
170        * 
171        *            this.s += data.toString();
172        * 
173        */
174       {
175         sb.append(data);
176       }
177     }
178     return this;
179   }
180
181   public void appendCB(char[] cb, int off, int len) {
182     /**
183      * @j2sNative
184      * 
185      * this.s += cb.slice(off,off+len).join("");
186      * 
187      */
188     {
189        sb.append(cb, off, len);
190     }
191   }
192
193   @Override
194   public String toString() {
195     /**
196      * @j2sNative
197      * 
198      *            return this.s;
199      * 
200      */
201     {
202       return sb.toString();
203     }
204   }
205
206   public int length() {
207     /**
208      * @j2sNative
209      * 
210      *            return this.s.length;
211      * 
212      */
213     {
214       return sb.length();
215     }
216   }
217
218   public int indexOf(String s) {
219     /**
220      * @j2sNative
221      * 
222      *            return this.s.indexOf(s);
223      * 
224      */
225     {
226       return sb.indexOf(s);
227     }
228   }
229
230   public char charAt(int i) {
231     /**
232      * @j2sNative
233      * 
234      *            return this.s.charAt(i);
235      * 
236      */
237     {
238       return sb.charAt(i);
239     }
240   }
241
242   public int charCodeAt(int i) {
243     /**
244      * @j2sNative
245      * 
246      *            return this.s.charCodeAt(i);
247      * 
248      */
249     {
250       return sb.codePointAt(i);
251     }
252   }
253
254   public void setLength(int n) {
255     /**
256      * @j2sNative
257      * 
258      *            this.s = this.s.substring(0, n);
259      */
260     {
261       sb.setLength(n);
262     }
263   }
264
265   public int lastIndexOf(String s) {
266     /**
267      * @j2sNative
268      * 
269      *            return this.s.lastIndexOf(s);
270      */
271     {
272       return sb.lastIndexOf(s);
273     }
274   }
275
276   public int indexOf2(String s, int i) {
277     /**
278      * @j2sNative
279      * 
280      *            return this.s.indexOf(s, i);
281      */
282     {
283       return sb.indexOf(s, i);
284     }
285   }
286
287   public String substring(int i) {
288     /**
289      * @j2sNative
290      * 
291      *            return this.s.substring(i);
292      */
293     {
294       return sb.substring(i);
295     }
296   }
297
298   public String substring2(int i, int j) {
299     /**
300      * @j2sNative
301      * 
302      *            return this.s.substring(i, j);
303      */
304     {
305       return sb.substring(i, j);
306     }
307   }
308
309   /**
310    * simple byte conversion properly implementing UTF-8. * Used for base64
311    * conversion and allows for offset
312    * 
313    * @param off
314    * @param len
315    *        or -1 for full length (then off must = 0)
316    * @return byte[]
317    */
318   public byte[] toBytes(int off, int len) {
319     if (len == 0)
320       return new byte[0];
321     Charset cs;
322     /**
323      * 
324      * just a string in JavaScript
325      * 
326      * @j2sNative
327      * 
328      *            cs = "UTF-8";
329      * 
330      */
331     {
332       cs = Charset.forName("UTF-8");
333     }
334     return (len > 0 ? substring2(off, off + len) 
335         : off == 0 ? toString()
336         : substring2(off, length() - off)).getBytes(cs);
337   }
338
339         public void replace(int start, int end, String str) {
340                 /**
341                  * @j2sNative
342                  * 
343                  * this.s = this.s.substring(0, start) + str + this.s.substring(end);
344                  */
345                 {
346                         sb.replace(start, end, str);
347                 }
348         }
349
350         public void insert(int offset, String str) {
351                 replace(offset, offset, str);
352         }
353
354 }