bin/javajs/util/Rdr.js

   1 Clazz.declarePackage ("javajs.util");
   2 Clazz.load (["javajs.api.GenericLineReader"], "javajs.util.Rdr", ["java.io.BufferedInputStream", "$.BufferedReader", "$.ByteArrayInputStream", "$.InputStreamReader", "$.StringReader", "javajs.util.AU", "$.Base64", "$.Encoding", "$.SB"], function () {
   3 c$ = Clazz.decorateAsClass (function () {
   4 this.reader = null;
   5 Clazz.instantialize (this, arguments);
   6 }, javajs.util, "Rdr", null, javajs.api.GenericLineReader);
   7 Clazz.makeConstructor (c$,
   8 function (reader) {
   9 this.reader = reader;
  10 }, "java.io.BufferedReader");
  11 Clazz.overrideMethod (c$, "readNextLine",
  12 function () {
  13 return this.reader.readLine ();
  14 });
  15 c$.readCifData = Clazz.defineMethod (c$, "readCifData",
  16 function (parser, br) {
  17 return parser.set (null, br).getAllCifData ();
  18 }, "javajs.api.GenericCifDataParser,java.io.BufferedReader");
  19 c$.fixUTF = Clazz.defineMethod (c$, "fixUTF",
  20 function (bytes) {
  21 var encoding = javajs.util.Rdr.getUTFEncoding (bytes);
  22 if (encoding !== javajs.util.Encoding.NONE) try {
  23 var s =  String.instantialize (bytes, encoding.name ().$replace ('_', '-'));
  24 switch (encoding) {
  25 case javajs.util.Encoding.UTF8:
  26 case javajs.util.Encoding.UTF_16BE:
  27 case javajs.util.Encoding.UTF_16LE:
  28 s = s.substring (1);
  29 break;
  30 default:
  31 break;
  32 }
  33 return s;
  34 } catch (e) {
  35 if (Clazz.exceptionOf (e, java.io.UnsupportedEncodingException)) {
  36 System.out.println (e);
  37 } else {
  38 throw e;
  39 }
  40 }
  41 return  String.instantialize (bytes);
  42 }, "~A");
  43 c$.getUTFEncoding = Clazz.defineMethod (c$, "getUTFEncoding",
  44 ($fz = function (bytes) {
  45 if (bytes.length >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) return javajs.util.Encoding.UTF8;
  46 if (bytes.length >= 4 && bytes[0] == 0 && bytes[1] == 0 && bytes[2] == 0xFE && bytes[3] == 0xFF) return javajs.util.Encoding.UTF_32BE;
  47 if (bytes.length >= 4 && bytes[0] == 0xFF && bytes[1] == 0xFE && bytes[2] == 0 && bytes[3] == 0) return javajs.util.Encoding.UTF_32LE;
  48 if (bytes.length >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE) return javajs.util.Encoding.UTF_16LE;
  49 if (bytes.length >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF) return javajs.util.Encoding.UTF_16BE;
  50 return javajs.util.Encoding.NONE;
  51 }, $fz.isPrivate = true, $fz), "~A");
  52 c$.getUTFEncodingForStream = Clazz.defineMethod (c$, "getUTFEncodingForStream",
  53 ($fz = function (is) {
  54 {
  55 is.resetStream();
  56 }var abMagic =  Clazz.newByteArray (4, 0);
  57 abMagic[3] = 1;
  58 try {
  59 is.mark (5);
  60 } catch (e) {
  61 if (Clazz.exceptionOf (e, Exception)) {
  62 return javajs.util.Encoding.NONE;
  63 } else {
  64 throw e;
  65 }
  66 }
  67 is.read (abMagic, 0, 4);
  68 is.reset ();
  69 return javajs.util.Rdr.getUTFEncoding (abMagic);
  70 }, $fz.isPrivate = true, $fz), "java.io.BufferedInputStream");
  71 c$.isBase64 = Clazz.defineMethod (c$, "isBase64",
  72 function (sb) {
  73 return (sb.indexOf (";base64,") == 0);
  74 }, "javajs.util.SB");
  75 c$.isCompoundDocumentS = Clazz.defineMethod (c$, "isCompoundDocumentS",
  76 function (is) {
  77 return javajs.util.Rdr.isCompoundDocumentB (javajs.util.Rdr.getMagic (is, 8));
  78 }, "java.io.InputStream");
  79 c$.isCompoundDocumentB = Clazz.defineMethod (c$, "isCompoundDocumentB",
  80 function (bytes) {
  81 return (bytes.length >= 8 && bytes[0] == 0xD0 && bytes[1] == 0xCF && bytes[2] == 0x11 && bytes[3] == 0xE0 && bytes[4] == 0xA1 && bytes[5] == 0xB1 && bytes[6] == 0x1A && bytes[7] == 0xE1);
  82 }, "~A");
  83 c$.isGzipS = Clazz.defineMethod (c$, "isGzipS",
  84 function (is) {
  85 return javajs.util.Rdr.isGzipB (javajs.util.Rdr.getMagic (is, 2));
  86 }, "java.io.InputStream");
  87 c$.isGzipB = Clazz.defineMethod (c$, "isGzipB",
  88 function (bytes) {
  89 return (bytes != null && bytes.length >= 2 && bytes[0] == 0x1F && bytes[1] == 0x8B);
  90 }, "~A");
  91 c$.isPickleS = Clazz.defineMethod (c$, "isPickleS",
  92 function (is) {
  93 return javajs.util.Rdr.isPickleB (javajs.util.Rdr.getMagic (is, 2));
  94 }, "java.io.InputStream");
  95 c$.isPickleB = Clazz.defineMethod (c$, "isPickleB",
  96 function (bytes) {
  97 return (bytes != null && bytes.length >= 2 && bytes[0] == 0x7D && bytes[1] == 0x71);
  98 }, "~A");
  99 c$.isPngZipStream = Clazz.defineMethod (c$, "isPngZipStream",
 100 function (is) {
 101 return javajs.util.Rdr.isPngZipB (javajs.util.Rdr.getMagic (is, 55));
 102 }, "java.io.InputStream");
 103 c$.isPngZipB = Clazz.defineMethod (c$, "isPngZipB",
 104 function (bytes) {
 105 return (bytes[50] == 0 && bytes[51] == 0x50 && bytes[52] == 0x4E && bytes[53] == 0x47 && bytes[54] == 0x4A);
 106 }, "~A");
 107 c$.isZipS = Clazz.defineMethod (c$, "isZipS",
 108 function (is) {
 109 return javajs.util.Rdr.isZipB (javajs.util.Rdr.getMagic (is, 4));
 110 }, "java.io.InputStream");
 111 c$.isZipB = Clazz.defineMethod (c$, "isZipB",
 112 function (bytes) {
 113 return (bytes.length >= 4 && bytes[0] == 0x50 && bytes[1] == 0x4B && bytes[2] == 0x03 && bytes[3] == 0x04);
 114 }, "~A");
 115 c$.getMagic = Clazz.defineMethod (c$, "getMagic",
 116 ($fz = function (is, n) {
 117 var abMagic =  Clazz.newByteArray (n, 0);
 118 {
 119 is.resetStream();
 120 }try {
 121 is.mark (n + 1);
 122 is.read (abMagic, 0, n);
 123 } catch (e) {
 124 if (Clazz.exceptionOf (e, java.io.IOException)) {
 125 } else {
 126 throw e;
 127 }
 128 }
 129 try {
 130 is.reset ();
 131 } catch (e) {
 132 if (Clazz.exceptionOf (e, java.io.IOException)) {
 133 } else {
 134 throw e;
 135 }
 136 }
 137 return abMagic;
 138 }, $fz.isPrivate = true, $fz), "java.io.InputStream,~N");
 139 c$.guessMimeTypeForBytes = Clazz.defineMethod (c$, "guessMimeTypeForBytes",
 140 function (bytes) {
 141 switch (bytes.length < 2 ? -1 : bytes[1]) {
 142 case 0:
 143 return "image/jpg";
 144 case 0x49:
 145 return "image/gif";
 146 case 0x4D:
 147 return "image/BMP";
 148 case 0x50:
 149 return "image/png";
 150 default:
 151 return "image/unknown";
 152 }
 153 }, "~A");
 154 c$.getBIS = Clazz.defineMethod (c$, "getBIS",
 155 function (bytes) {
 156 return  new java.io.BufferedInputStream ( new java.io.ByteArrayInputStream (bytes));
 157 }, "~A");
 158 c$.getBR = Clazz.defineMethod (c$, "getBR",
 159 function (string) {
 160 return  new java.io.BufferedReader ( new java.io.StringReader (string));
 161 }, "~S");
 162 c$.getUnzippedInputStream = Clazz.defineMethod (c$, "getUnzippedInputStream",
 163 function (jzt, bis) {
 164 while (javajs.util.Rdr.isGzipS (bis)) bis =  new java.io.BufferedInputStream (jzt.newGZIPInputStream (bis));
 165
 166 return bis;
 167 }, "javajs.api.GenericZipTools,java.io.BufferedInputStream");
 168 c$.getBytesFromSB = Clazz.defineMethod (c$, "getBytesFromSB",
 169 function (sb) {
 170 return (javajs.util.Rdr.isBase64 (sb) ? javajs.util.Base64.decodeBase64 (sb.substring (8)) : sb.toBytes (0, -1));
 171 }, "javajs.util.SB");
 172 c$.getStreamAsBytes = Clazz.defineMethod (c$, "getStreamAsBytes",
 173 function (bis, out) {
 174 var buf =  Clazz.newByteArray (1024, 0);
 175 var bytes = (out == null ?  Clazz.newByteArray (4096, 0) : null);
 176 var len = 0;
 177 var totalLen = 0;
 178 while ((len = bis.read (buf, 0, 1024)) > 0) {
 179 totalLen += len;
 180 if (out == null) {
 181 if (totalLen >= bytes.length) bytes = javajs.util.AU.ensureLengthByte (bytes, totalLen * 2);
 182 System.arraycopy (buf, 0, bytes, totalLen - len, len);
 183 } else {
 184 out.write (buf, 0, len);
 185 }}
 186 bis.close ();
 187 if (out == null) {
 188 return javajs.util.AU.arrayCopyByte (bytes, totalLen);
 189 }return totalLen + " bytes";
 190 }, "java.io.BufferedInputStream,javajs.util.OC");
 191 c$.getBufferedReader = Clazz.defineMethod (c$, "getBufferedReader",
 192 function (bis, charSet) {
 193 if (javajs.util.Rdr.getUTFEncodingForStream (bis) === javajs.util.Encoding.NONE) return  new java.io.BufferedReader ( new java.io.InputStreamReader (bis, (charSet == null ? "UTF-8" : charSet)));
 194 var bytes = javajs.util.Rdr.getLimitedStreamBytes (bis, -1);
 195 bis.close ();
 196 return javajs.util.Rdr.getBR (charSet == null ? javajs.util.Rdr.fixUTF (bytes) :  String.instantialize (bytes, charSet));
 197 }, "java.io.BufferedInputStream,~S");
 198 c$.getLimitedStreamBytes = Clazz.defineMethod (c$, "getLimitedStreamBytes",
 199 function (is, n) {
 200 var buflen = (n > 0 && n < 1024 ? n : 1024);
 201 var buf =  Clazz.newByteArray (buflen, 0);
 202 var bytes =  Clazz.newByteArray (n < 0 ? 4096 : n, 0);
 203 var len = 0;
 204 var totalLen = 0;
 205 if (n < 0) n = 2147483647;
 206 while (totalLen < n && (len = is.read (buf, 0, buflen)) > 0) {
 207 totalLen += len;
 208 if (totalLen > bytes.length) bytes = javajs.util.AU.ensureLengthByte (bytes, totalLen * 2);
 209 System.arraycopy (buf, 0, bytes, totalLen - len, len);
 210 if (n != 2147483647 && totalLen + buflen > bytes.length) buflen = bytes.length - totalLen;
 211 }
 212 if (totalLen == bytes.length) return bytes;
 213 buf =  Clazz.newByteArray (totalLen, 0);
 214 System.arraycopy (bytes, 0, buf, 0, totalLen);
 215 return buf;
 216 }, "java.io.InputStream,~N");
 217 c$.StreamToUTF8String = Clazz.defineMethod (c$, "StreamToUTF8String",
 218 function (bis) {
 219 var data =  new Array (1);
 220 try {
 221 javajs.util.Rdr.readAllAsString (javajs.util.Rdr.getBufferedReader (bis, "UTF-8"), -1, true, data, 0);
 222 } catch (e) {
 223 if (Clazz.exceptionOf (e, java.io.IOException)) {
 224 } else {
 225 throw e;
 226 }
 227 }
 228 return data[0];
 229 }, "java.io.BufferedInputStream");
 230 c$.readAllAsString = Clazz.defineMethod (c$, "readAllAsString",
 231 function (br, nBytesMax, allowBinary, data, i) {
 232 try {
 233 var sb = javajs.util.SB.newN (8192);
 234 var line;
 235 if (nBytesMax < 0) {
 236 line = br.readLine ();
 237 if (allowBinary || line != null && line.indexOf ('\0') < 0 && (line.length != 4 || line.charCodeAt (0) != 65533 || line.indexOf ("PNG") != 1)) {
 238 sb.append (line).appendC ('\n');
 239 while ((line = br.readLine ()) != null) sb.append (line).appendC ('\n');
 240
 241 }} else {
 242 var n = 0;
 243 var len;
 244 while (n < nBytesMax && (line = br.readLine ()) != null) {
 245 if (nBytesMax - n < (len = line.length) + 1) line = line.substring (0, nBytesMax - n - 1);
 246 sb.append (line).appendC ('\n');
 247 n += len + 1;
 248 }
 249 }br.close ();
 250 data[i] = sb.toString ();
 251 return true;
 252 } catch (ioe) {
 253 if (Clazz.exceptionOf (ioe, Exception)) {
 254 data[i] = ioe.toString ();
 255 return false;
 256 } else {
 257 throw ioe;
 258 }
 259 }
 260 }, "java.io.BufferedReader,~N,~B,~A,~N");
 261 c$.getPngZipPointAndCount = Clazz.defineMethod (c$, "getPngZipPointAndCount",
 262 function (bis, pt_count) {
 263 bis.mark (75);
 264 try {
 265 var data = javajs.util.Rdr.getLimitedStreamBytes (bis, 74);
 266 bis.reset ();
 267 var pt = 0;
 268 for (var i = 64, f = 1; --i > 54; f *= 10) pt += (data[i] - 48) * f;
 269
 270 var n = 0;
 271 for (var i = 74, f = 1; --i > 64; f *= 10) n += (data[i] - 48) * f;
 272
 273 pt_count[0] = pt;
 274 pt_count[1] = n;
 275 } catch (e) {
 276 pt_count[1] = 0;
 277 }
 278 }, "java.io.BufferedInputStream,~A");
 279 c$.getPngZipStream = Clazz.defineMethod (c$, "getPngZipStream",
 280 function (bis, asNewStream) {
 281 if (!javajs.util.Rdr.isPngZipStream (bis)) return bis;
 282 var data =  Clazz.newByteArray (0, 0);
 283 bis.mark (75);
 284 try {
 285 var pt_count =  Clazz.newIntArray (2, 0);
 286 javajs.util.Rdr.getPngZipPointAndCount (bis, pt_count);
 287 if (pt_count[1] != 0) {
 288 var pt = pt_count[0];
 289 while (pt > 0) pt -= bis.skip (pt);
 290
 291 if (!asNewStream) return bis;
 292 data = javajs.util.Rdr.getLimitedStreamBytes (bis, pt_count[1]);
 293 }} catch (e) {
 294 } finally {
 295 try {
 296 if (asNewStream) bis.close ();
 297 } catch (e) {
 298 if (Clazz.exceptionOf (e, Exception)) {
 299 } else {
 300 throw e;
 301 }
 302 }
 303 }
 304 return javajs.util.Rdr.getBIS (data);
 305 }, "java.io.BufferedInputStream,~B");
 306 c$.getZipRoot = Clazz.defineMethod (c$, "getZipRoot",
 307 function (fileName) {
 308 var pt = fileName.indexOf ("|");
 309 return (pt < 0 ? fileName : fileName.substring (0, pt));
 310 }, "~S");
 311 });