private Reader markableReader(Reader r, long l) throws SQLException {
if (r.markSupported() && l < 0) {
boolean marked = true;
try {
r.mark(1000000);
} catch (IOException e) {
marked = false;
}
if (marked) return r;
}
StringBuffer sb = new StringBuffer();
int dim = l >= 0 ? (int) l : 4096;
char[] cb = new char[dim];
int rd;
try {
while ((rd = r.read(cb)) >= 0) {
sb.append(Arrays.copyOf(cb, rd));
if (l >= 0) break;
}
StringReader sr = new StringReader(sb.toString());
sr.mark(1000000);
return sr;
} catch (IOException e) {
throw new SQLException(e);
}
}
/**
* Marks the current position in this input stream. A subsequent call to the <code>reset</code>
* method repositions this stream at the last marked position so that subsequent reads re-read the
* same chars.
*
* <p>The <code>readlimit</code> argument tells this input stream to allow that many chars to be
* read before the mark position gets invalidated.
*
* <p>The general contract of mark is that, if the method <code>markSupported</code> returns
* <code>true</code>, the stream somehow remembers all the chars read after the call to mark and
* stands ready to supply those same chars again if and whenever the method <code>reset</code> is
* called. However, the stream is not required to remember any data at all if more than <code>
* readlimit</code> chars are read from the stream before <code>reset</code> is called.
*
* @param readlimit The maximum limit of chars that can be read before the mark position becomes
* invalid.
*/
public void mark(int readlimit) {
try {
in.mark(readlimit * 2);
} catch (Exception e) {
System.err.println(e);
}
}
public byte[] decode(String code) {
ByteArrayOutputStream baos = new ByteArrayOutputStream((code.length() * 3 / 4));
StringReader sr;
if (code.endsWith(Character.toString(padding))) {
sr = new StringReader(code.substring(0, code.indexOf(padding)));
} else {
sr = new StringReader(code);
}
char[] c = new char[4];
int[] b = new int[4];
int len;
try {
int count = 0;
while ((len = sr.read(c, 0, 4)) == 4) {
b[0] = decode[c[0]];
b[1] = decode[c[1]];
b[2] = decode[c[2]];
b[3] = decode[c[3]];
baos.write(((b[0] & 0x3f) << 2) | ((b[1] & 0x30) >> 4));
baos.write(((b[1] & 0x0f) << 4) | ((b[2] & 0x3c) >> 2));
baos.write(((b[2] & 0x03) << 6) | (b[3] & 0x3f));
count++;
if (count == 19) {
sr.mark(1);
count = 0;
if (sr.read() != 10) {
sr.reset();
}
}
}
b[0] = decode[c[0]];
b[1] = decode[c[1]];
b[2] = decode[c[2]];
b[3] = decode[c[3]];
if (len == 2) {
baos.write(((b[0] & 0x3f) << 2) | ((b[1] & 0x30) >> 4));
} else if (len == 3) {
baos.write(((b[0] & 0x3f) << 2) | ((b[1] & 0x30) >> 4));
baos.write(((b[1] & 0x0f) << 4) | ((b[2] & 0x3c) >> 2));
}
return baos.toByteArray();
} catch (java.io.IOException e) {
return null;
} catch (RuntimeException e) {
return null;
}
}
public static void main(String argv[]) throws Exception {
StringReader in = new StringReader("aaaaaaaaaaaaaaa");
try {
in.mark(-1);
} catch (IllegalArgumentException e) {
return;
}
throw new Exception(" Negative marklimit value should throw an exception");
}