Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / OC.java
1 package javajs.util;
2
3 import java.io.BufferedWriter;
4 import java.io.ByteArrayOutputStream;
5 import java.io.FileOutputStream;
6 import java.io.IOException;
7 import java.io.OutputStream;
8
9 import javajs.api.BytePoster;
10 import javajs.api.GenericOutputChannel;
11 import javajs.api.js.J2SObjectInterface;
12
13 /**
14  * 
15  * A generic output method. JmolOutputChannel can be used to:
16  * 
17  * add characters to a StringBuffer 
18  *   using fileName==null, append() and toString()
19  *   
20  * add bytes utilizing ByteArrayOutputStream 
21  *   using writeBytes(), writeByteAsInt(), append()*, and bytesAsArray()
22  *       *append() can be used as long as os==ByteArrayOutputStream
23  *        or it is not used before one of the writeByte methods. 
24  * 
25  * output characters to a FileOutputStream 
26  *  using os==FileOutputStream, asWriter==true, append(), and closeChannel()
27  *  
28  * output bytes to a FileOutputStream 
29  *  using os==FileOutputStream, writeBytes(), writeByteAsInt(), append(), and closeChannel()
30  * 
31  * post characters or bytes to a remote server
32  *  using fileName=="http://..." or "https://...",
33  *    writeBytes(), writeByteAsInt(), append(), and closeChannel()
34  *    
35  * send characters or bytes to a JavaScript function
36  *  when JavaScript and (typeof fileName == "function")
37  *  
38  * if fileName equals ";base64,", then the data are base64-encoded
39  * prior to writing, and closeChannel() returns the data.
40  * 
41  *  @author hansonr  Bob Hanson hansonr@stolaf.edu  9/2013
42  *  
43  *  
44  */
45
46 public class OC extends OutputStream implements GenericOutputChannel {
47  
48   private BytePoster bytePoster; // only necessary for writing to http:// or https://
49   private String fileName;
50   private BufferedWriter bw;
51   private boolean isLocalFile;
52   private int byteCount;
53   private boolean isCanceled;
54   private boolean closed;
55   private OutputStream os;
56   private SB sb;
57   private String type;
58         private boolean isBase64;
59         private OutputStream os0;
60         private byte[] bytes; // preset bytes; output only
61   
62         public boolean bigEndian = true;
63
64         private boolean isTemp;
65         
66         /**
67          * Setting isTemp=true informs OC that this is a temporary file 
68          * and not to send it to the user as a "download". Instead, the calling
69          * class can use .toByteArray() to retrieve the byte[] result.
70          * 
71          * @param tf
72          */
73         public void setTemp(boolean tf) {
74                 isTemp = tf;
75         }
76
77
78   
79   @Override
80   public boolean isBigEndian() {
81     return bigEndian;
82   }
83
84   public void setBigEndian(boolean TF) {
85         bigEndian = TF;
86   }
87
88         /**
89          * Set up an output channel. String or byte data can be added without problem.
90          * 
91          * @param bytePoster a byte poster can take the output byte[] when closing and
92          *                   do something with them
93          * @param fileName   TODO: It is possible that JavaScript will call this with a
94          *                   function name for fileName
95          * @param asWriter   string-based
96          * @param os         the desired target OutputStream - not the calling stream!
97          * @return
98          */
99   public OC setParams(BytePoster bytePoster, String fileName,
100                                      boolean asWriter, OutputStream os) {
101     this.bytePoster = bytePoster;
102     isBase64 = ";base64,".equals(fileName);
103     if (isBase64) {
104         fileName = null;
105         os0 = os;
106         os = null;
107     }
108     this.fileName = fileName;
109     this.os = os;
110     isLocalFile = (fileName != null && !isRemote(fileName));
111     if (asWriter && !isBase64 && os != null) 
112         bw = Rdr.getBufferedWriter(os, null);
113     return this;
114   }
115
116   public OC setBytes(byte[] b) {
117         bytes = b;
118         return this;
119   }
120   
121   public String getFileName() {
122     return fileName;
123   }
124   
125   public String getName() {
126     return (fileName == null ? null : fileName.substring(fileName.lastIndexOf("/") + 1));
127   }
128
129   public int getByteCount() {
130     return byteCount;
131   }
132
133   /**
134    * 
135    * @param type  user-identified type (PNG, JPG, etc)
136    */
137   public void setType(String type) {
138     this.type = type;
139   }
140   
141   public String getType() {
142     return type;
143   }
144
145   /**
146    * will go to string buffer if bw == null and os == null
147    * 
148    * @param s
149    * @return this, for chaining like a standard StringBuffer
150    * 
151    */
152   public OC append(String s) {
153     try {
154       if (bw != null) {
155         bw.write(s);
156       } else if (os == null) {
157         if (sb == null)
158           sb = new SB();
159         sb.append(s);
160       } else {
161         byte[] b = s.getBytes();
162         os.write(b, 0, b.length);
163         byteCount += b.length;
164         return this;
165       }
166     } catch (IOException e) {
167       // ignore
168     }
169     byteCount += s.length(); // not necessarily exactly correct if unicode
170     return this;
171   }
172
173   @Override
174   public void reset() {
175     sb = null;
176     initOS();
177   }
178
179
180   private void initOS() {
181     if (sb != null) {
182       String s = sb.toString();
183       reset();
184       append(s);
185       return;
186     }
187     try {
188       /**
189        * @j2sNative
190        * 
191        *            this.os = null;
192        */
193       {
194         if (os instanceof FileOutputStream) {
195           os.close();
196           os = new FileOutputStream(fileName);
197         } else {
198           os = null;
199         }
200       }
201       if (os == null)
202         os = new ByteArrayOutputStream();
203       if (bw != null) {
204         bw.close();
205         bw = Rdr.getBufferedWriter(os, null);
206       }
207     } catch (Exception e) {
208       // not perfect here.
209       System.out.println(e.toString());
210     }
211     byteCount = 0;
212   }
213
214   /**
215    * @param b  
216    */
217   @Override
218   public void writeByteAsInt(int b) {
219     if (os == null)
220       initOS();
221     {
222       try {
223         os.write(b);
224       } catch (IOException e) {
225       }
226     }
227     byteCount++;
228   }
229   
230   @Override
231   public void write(byte[] buf, int i, int len) {
232     if (os == null)
233       initOS();
234     try {
235       os.write(buf, i, len);
236     } catch (IOException e) {
237     }
238     byteCount += len;
239   }
240   
241   @Override
242   public void writeShort(short i) {
243     if (isBigEndian()) {
244       writeByteAsInt(i >> 8);
245       writeByteAsInt(i);
246     } else {
247       writeByteAsInt(i);
248       writeByteAsInt(i >> 8);
249     }
250   }
251
252   @Override
253   public void writeLong(long b) {
254     if (isBigEndian()) {
255       writeInt((int) ((b >> 32) & 0xFFFFFFFFl));
256       writeInt((int) (b & 0xFFFFFFFFl));
257     } else {
258       writeByteAsInt((int) (b >> 56));
259       writeByteAsInt((int) (b >> 48));
260       writeByteAsInt((int) (b >> 40));
261       writeByteAsInt((int) (b >> 32));
262       writeByteAsInt((int) (b >> 24));
263       writeByteAsInt((int) (b >> 16));
264       writeByteAsInt((int) (b >> 8));
265       writeByteAsInt((int) b);
266     }
267   }
268
269   public void write(int b) {
270     // required by standard ZipOutputStream -- do not use, as it will break JavaScript methods
271     if (os == null)
272       initOS();
273     try {
274       os.write(b);
275     } catch (IOException e) {
276     }
277     byteCount++;
278   }
279
280   public void write(byte[] b) {
281     // not used in JavaScript due to overloading problem there
282     write(b, 0, b.length);
283   }
284
285   public void cancel() {
286     isCanceled = true;
287     closeChannel();
288   }
289
290   @Override
291   @SuppressWarnings({ "unused" })
292   public String closeChannel() {
293     if (closed)
294       return null;
295     // can't cancel file writers
296     try {
297       if (bw != null) {
298         bw.flush();
299         bw.close();
300       } else if (os != null) {
301         os.flush();
302         os.close();
303       }
304       if (os0 != null && isCanceled) {
305         os0.flush();
306         os0.close();
307       }
308     } catch (Exception e) {
309       // ignore closing issues
310     }
311     if (isCanceled) {
312       closed = true;
313       return null;
314     }
315     if (fileName == null) {
316       if (isBase64) {
317         String s = getBase64();
318         if (os0 != null) {
319           os = os0;
320           append(s);
321         }
322         sb = new SB();
323         sb.append(s);
324         isBase64 = false;
325         return closeChannel();
326       }
327       return (sb == null ? null : sb.toString());
328     }
329     closed = true;
330     J2SObjectInterface J2S = null;
331     Object _function = null;
332     /**
333      * @j2sNative
334      * 
335      *            J2S = self.J2S || self.Jmol; _function = (typeof this.fileName == "function" ?
336      *            this.fileName : null);
337      * 
338      */
339     {
340       if (!isLocalFile) {
341         String ret = postByteArray(); // unsigned applet could do this
342         if (ret.startsWith("java.net"))
343           byteCount = -1;
344         return ret;
345       }
346     }
347     if (J2S != null && !isTemp) {
348         
349       // action here generally will be for the browser to display a download message
350       // temp files will not be sent this way.
351       Object data = (sb == null ? toByteArray() : sb.toString());
352       if (_function == null)
353         J2S.doAjax(fileName, null, data, sb == null);
354       else
355         J2S.applyFunc(_function, data);
356     }
357     return null;
358   }
359
360         public boolean isBase64() {
361                 return isBase64;
362         }
363
364         public String getBase64() {
365     return Base64.getBase64(toByteArray()).toString();
366         }
367         
368   public byte[] toByteArray() {
369     return (bytes != null ? bytes : (bytes = os instanceof ByteArrayOutputStream ? ((ByteArrayOutputStream)os).toByteArray() : 
370         sb == null ? null : sb.toBytes(0, sb.length())));
371   }
372
373   @Override
374   @Deprecated
375   public void close() {
376     closeChannel();
377   }
378
379   @Override
380   public String toString() {
381     if (bw != null)
382       try {
383         bw.flush();
384       } catch (IOException e) {
385         // TODO
386       }
387     if (sb != null)
388       return closeChannel();
389     return byteCount + " bytes";
390   }
391
392   /**
393    * We have constructed some sort of byte[] that needs to be posted to a remote site.
394    * We don't do that posting here -- we let the bytePoster do it.
395    * 
396    * @return
397    */
398   private String postByteArray() {
399     return bytePoster == null ? null : bytePoster.postByteArray(fileName, toByteArray());
400   }
401
402   public final static String[] urlPrefixes = { "http:", "https:", "sftp:", "ftp:",
403   "file:" };
404   // note that SFTP is not supported
405   public final static int URL_LOCAL = 4;
406
407   public static boolean isRemote(String fileName) {
408     if (fileName == null)
409       return false;
410     int itype = urlTypeIndex(fileName);
411     return (itype >= 0 && itype != URL_LOCAL);
412   }
413
414   public static boolean isLocal(String fileName) {
415     if (fileName == null)
416       return false;
417     int itype = urlTypeIndex(fileName);
418     return (itype < 0 || itype == URL_LOCAL);
419   }
420
421   public static int urlTypeIndex(String name) {
422     if (name == null)
423       return -2; // local unsigned applet
424     for (int i = 0; i < urlPrefixes.length; ++i) {
425       if (name.startsWith(urlPrefixes[i])) {
426         return i;
427       }
428     }
429     return -1;
430   }
431
432   @Override
433   public void writeInt(int i) {
434     if (bigEndian) {
435       writeByteAsInt(i >> 24);
436       writeByteAsInt(i >> 16);
437       writeByteAsInt(i >> 8);
438       writeByteAsInt(i);
439     } else {
440       writeByteAsInt(i);
441       writeByteAsInt(i >> 8);
442       writeByteAsInt(i >> 16);
443       writeByteAsInt(i >> 24);
444     }
445   }
446
447   public void writeFloat(float x) {
448     writeInt(x == 0 ? 0 : Float.floatToIntBits(x));
449   }
450
451 }