package com.fasterxml.jackson.dataformat.avro.deser;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Writer;

import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.core.io.IOContext;

Implementation class that exposes additional internal API to be used as callbacks by AvroReadContext implementations.
/** * Implementation class that exposes additional internal API * to be used as callbacks by {@link AvroReadContext} implementations. */
public class JacksonAvroParserImpl extends AvroParserImpl {
Additionally we can combine UTF-8 decoding info into similar data table. Values indicate "byte length - 1"; meaning -1 is used for invalid bytes, 0 for single-byte codes, 1 for 2-byte codes and 2 for 3-byte codes.
/** * Additionally we can combine UTF-8 decoding info into similar * data table. * Values indicate "byte length - 1"; meaning -1 is used for * invalid bytes, 0 for single-byte codes, 1 for 2-byte codes * and 2 for 3-byte codes. */
public final static int[] sUtf8UnitLengths; static { int[] table = new int[256]; for (int c = 128; c < 256; ++c) { int code; // We'll add number of bytes needed for decoding if ((c & 0xE0) == 0xC0) { // 2 bytes (0x0080 - 0x07FF) code = 1; } else if ((c & 0xF0) == 0xE0) { // 3 bytes (0x0800 - 0xFFFF) code = 2; } else if ((c & 0xF8) == 0xF0) { // 4 bytes; double-char with surrogates and all... code = 3; } else { // And -1 seems like a good "universal" error marker... code = -1; } table[c] = code; } sUtf8UnitLengths = table; } /* /********************************************************** /* Input source config /********************************************************** */ protected InputStream _inputStream;
Current buffer from which data is read; generally data is read into buffer from input source, but in some cases pre-loaded buffer is handed to the parser.
/** * Current buffer from which data is read; generally data is read into * buffer from input source, but in some cases pre-loaded buffer * is handed to the parser. */
protected byte[] _inputBuffer;
Flag that indicates whether the input buffer is recycable (and needs to be returned to recycler once we are done) or not.

If it is not, it also means that parser can NOT modify underlying buffer.

/** * Flag that indicates whether the input buffer is recycable (and * needs to be returned to recycler once we are done) or not. *<p> * If it is not, it also means that parser can NOT modify underlying * buffer. */
protected boolean _bufferRecyclable; /* /********************************************************** /* Life-cycle /********************************************************** */ public JacksonAvroParserImpl(IOContext ctxt, int parserFeatures, int avroFeatures, ObjectCodec codec, InputStream in) { super(ctxt, parserFeatures, avroFeatures, codec); _inputStream = in; _inputBuffer = ctxt.allocReadIOBuffer(); _inputPtr = 0; _inputEnd = 0; _bufferRecyclable = true; } public JacksonAvroParserImpl(IOContext ctxt, int parserFeatures, int avroFeatures, ObjectCodec codec, byte[] data, int offset, int len) { super(ctxt, parserFeatures, avroFeatures, codec); _inputStream = null; _inputBuffer = data; _inputPtr = offset; _inputEnd = offset + len; } @Override protected void _releaseBuffers() throws IOException { super._releaseBuffers(); if (_bufferRecyclable) { byte[] buf = _inputBuffer; if (buf != null) { _inputBuffer = null; _ioContext.releaseReadIOBuffer(buf); } } } /* /********************************************************** /* Abstract method impls, i/o access /********************************************************** */ @Override public Object getInputSource() { return _inputStream; } @SuppressWarnings("deprecation") @Override protected void _closeInput() throws IOException { if (_inputStream != null) { if (_ioContext.isResourceManaged() || isEnabled(JsonParser.Feature.AUTO_CLOSE_SOURCE)) { _inputStream.close(); } _inputStream = null; } } @Override public int releaseBuffered(OutputStream out) throws IOException { int count = _inputEnd - _inputPtr; if (count < 1) { return 0; } // let's just advance ptr to end int origPtr = _inputPtr; out.write(_inputBuffer, origPtr, count); return count; } /* /********************************************************** /* Abstract method impls, traversal /********************************************************** */ // !!! TODO: optimize @Override public String nextTextValue() throws IOException { if (nextToken() == JsonToken.VALUE_STRING) { return _textBuffer.contentsAsString(); } return null; } /* /********************************************************** /* Abstract method impls, text /********************************************************** */ @Override public boolean hasTextCharacters() { if (_currToken == JsonToken.VALUE_STRING) { return true; } // usually true // name might be copied but... return false; } @Override public String getText() throws IOException { JsonToken t = _currToken; if (t == JsonToken.VALUE_STRING) { return _textBuffer.contentsAsString(); } if (t == JsonToken.FIELD_NAME) { return _avroContext.getCurrentName(); } if (t != null) { if (t.isNumeric()) { return getNumberValue().toString(); } return _currToken.asString(); } return null; } @Override // since 2.8 public int getText(Writer writer) throws IOException { JsonToken t = _currToken; if (t == JsonToken.VALUE_STRING) { return _textBuffer.contentsToWriter(writer); } if (t == JsonToken.FIELD_NAME) { String n = _avroContext.getCurrentName(); writer.write(n); return n.length(); } if (t != null) { if (t.isNumeric()) { return _textBuffer.contentsToWriter(writer); } char[] ch = t.asCharArray(); writer.write(ch); return ch.length; } return 0; } /* /********************************************************** /* Methods for AvroReadContext implementations: decoding int /********************************************************** */ @Override public JsonToken decodeIntToken() throws IOException { _numberInt = decodeInt(); _numTypesValid = NR_INT; return JsonToken.VALUE_NUMBER_INT; } @Override public final int decodeInt() throws IOException { int ptr = _inputPtr; if ((_inputEnd - ptr) < 5) { return _decodeIntSlow(); } final byte[] buf = _inputBuffer; int b = buf[ptr++]; int i = b & 0x7F; if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 7); if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 14); if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 21); if (b < 0) { b = buf[ptr++]; if (b < 0) { _inputPtr = ptr; _reportInvalidNegative(b); } i += (b << 28); } } } } _inputPtr = ptr; // and final part: Zigzag decode return (i >>> 1) ^ (-(i & 1)); } public int _decodeIntSlow() throws IOException { int b = _nextByteGuaranteed(); int i = b & 0x7F; if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 7); if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 14); if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 21); if (b < 0) { b = _nextByteGuaranteed(); if (b < 0) { _reportInvalidNegative(b); } i += (b << 28); } } } } // and final part: Zigzag decode return (i >>> 1) ^ (-(i & 1)); } @Override public void skipInt() throws IOException { int ptr = _inputPtr; if ((_inputEnd - ptr) < 5) { _skipIntSlow(); return; } final byte[] buf = _inputBuffer; if (buf[ptr++] < 0) { if (buf[ptr++] < 0) { if (buf[ptr++] < 0) { if (buf[ptr++] < 0) { int b = buf[ptr++]; if (b < 0) { _inputPtr = ptr; _reportInvalidNegative(b); } } } } } _inputPtr = ptr; } public void _skipIntSlow() throws IOException { if (_nextByteGuaranteed() < 0) { if (_nextByteGuaranteed() < 0) { if (_nextByteGuaranteed() < 0) { if (_nextByteGuaranteed() < 0) { int b = _nextByteGuaranteed(); if (b < 0) { _reportInvalidNegative(b); } } } } } } /* /********************************************************** /* Methods for AvroReadContext implementations: decoding long /********************************************************** */ @Override public JsonToken decodeLongToken() throws IOException { _numberLong = decodeLong(); _numTypesValid = NR_LONG; return JsonToken.VALUE_NUMBER_INT; } @Override public long decodeLong() throws IOException { int ptr = _inputPtr; if ((_inputEnd - ptr) < 10) { return _decodeLongSlow(); } final byte[] buf = _inputBuffer; // inline handling of first 4 bytes (for 28-bits of content) int b = buf[ptr++]; int i = b & 0x7F; if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 7); if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 14); if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 21); if (b < 0) { return _decodeLong2(ptr, i); } } } } _inputPtr = ptr; // should be ok to zigzag as int, then sign-extend i = (i >>> 1) ^ (-(i & 1)); return (long) i; } private long _decodeLong2(int ptr, long lo) throws IOException { final byte[] buf = _inputBuffer; // then next 28 bits (altogether 8 bytes) int b = buf[ptr++]; int i = b & 0x7F; if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 7); if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 14); if (b < 0) { b = buf[ptr++]; i += ((b & 0x7F) << 21); if (b < 0) { // Ok 56-bits gone... still going strong! b = buf[ptr++]; int inner = b & 0x7F; if (b < 0) { b = buf[ptr++]; if (b < 0) { _inputPtr = ptr; _reportInvalidNegative(b); } inner |= ((b & 0x1) << 7); } lo |= (((long) inner) << 56); } } } } _inputPtr = ptr; lo |= (((long) i) << 28); return (lo >>> 1) ^ (-(lo & 1)); } public long _decodeLongSlow() throws IOException { int b = _nextByteGuaranteed(); int i = b & 0x7F; if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 7); if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 14); if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 21); if (b < 0) { return _decodeLongSlow2(i); } } } } i = (i >>> 1) ^ (-(i & 1)); return (long) i; } private long _decodeLongSlow2(long lo) throws IOException { // then next 28 bits (altogether 8 bytes) int b = _nextByteGuaranteed(); int i = b & 0x7F; if (b < 0) { i &= 0x7F; b = _nextByteGuaranteed(); i += ((b & 0x7F) << 7); if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 14); if (b < 0) { b = _nextByteGuaranteed(); i += ((b & 0x7F) << 21); if (b < 0) { // Ok 56-bits gone... still going strong! lo |= (((long) i) << 28); b = _nextByteGuaranteed(); i = b & 0x7F; if (b < 0) { b = _nextByteGuaranteed(); if (i < 0) { _reportInvalidNegative(b); } i |= (b << 7); } lo |= (((long) i) << 56); return (lo >>> 1) ^ (-(lo & 1)); } } } } lo |= (((long) i) << 28); return (lo >>> 1) ^ (-(lo & 1)); } @Override public void skipLong() throws IOException { int ptr = _inputPtr; if ((_inputEnd - ptr) < 10) { _skipLongSlow(); return; } final byte[] buf = _inputBuffer; if (buf[ptr++] < 0) { int maxLeft = 9; int b; do { b = _nextByteGuaranteed(); } while ((--maxLeft > 0) && (b < 0)); if (b < 0) { _reportInvalidNegative(b); } } _inputPtr = ptr; } public void _skipLongSlow() throws IOException { if (_nextByteGuaranteed() < 0) { int maxLeft = 9; int b; do { b = _nextByteGuaranteed(); } while ((--maxLeft > 0) && (b < 0)); if (b < 0) { _reportInvalidNegative(b); } } } /* /********************************************************** /* Methods for AvroReadContext implementations: decoding float/double /********************************************************** */ @Override public JsonToken decodeFloat() throws IOException { int ptr = _inputPtr; if ((_inputEnd - ptr) < 4) { _loadToHaveAtLeast(4); ptr = _inputPtr; } final byte[] buf = _inputBuffer; _inputPtr = ptr+4; int i = (buf[ptr] & 0xff) | ((buf[ptr+1] & 0xff) << 8) | ((buf[ptr+2] & 0xff) << 16) | (buf[ptr+3] << 24); _numberFloat = Float.intBitsToFloat(i); _numTypesValid = NR_FLOAT; return JsonToken.VALUE_NUMBER_FLOAT; } @Override public void skipFloat() throws IOException { _skip(4); } @Override public JsonToken decodeDouble() throws IOException { int ptr = _inputPtr; if ((_inputEnd - ptr) < 8) { _loadToHaveAtLeast(8); ptr = _inputPtr; } final byte[] buf = _inputBuffer; int i = (buf[ptr] & 0xff) | ((buf[ptr+1] & 0xff) << 8) | ((buf[ptr+2] & 0xff) << 16) | (buf[ptr+3] << 24); ptr += 4; int i2 = (buf[ptr] & 0xff) | ((buf[ptr+1] & 0xff) << 8) | ((buf[ptr+2] & 0xff) << 16) | (buf[ptr+3] << 24); _inputPtr = ptr+4; _numberDouble = Double.longBitsToDouble((((long) i) & 0xffffffffL) | (((long) i2) << 32)); _numTypesValid = NR_DOUBLE; return JsonToken.VALUE_NUMBER_FLOAT; } @Override public void skipDouble() throws IOException { _skip(8); } /* /********************************************************** /* Methods for AvroReadContext implementations: decoding Strings /********************************************************** */ @Override public JsonToken decodeStringToken() throws IOException { decodeString(); return JsonToken.VALUE_STRING; } @Override public void decodeString() throws IOException { int len = decodeInt(); if (len <= 0) { if (len < 0) { _reportError("Invalid length indicator for String: "+len); } _textBuffer.resetWithEmpty(); return; } if (len > (_inputEnd - _inputPtr)) { // or if not, could we read? if (len >= _inputBuffer.length) { // If not enough space, need handling similar to chunked _finishLongText(len); return; } _loadToHaveAtLeast(len); } // offline for better optimization _finishShortText(len); } @Override public void skipString() throws IOException { int len = decodeInt(); if (len <= 0) { if (len < 0) { _reportError("Invalid length indicator for String: "+len); } return; } _skip(len); } private final String _finishShortText(int len) throws IOException { char[] outBuf = _textBuffer.emptyAndGetCurrentSegment(); if (outBuf.length < len) { // one minor complication outBuf = _textBuffer.expandCurrentSegment(len); } int outPtr = 0; int inPtr = _inputPtr; _inputPtr += len; final byte[] inputBuf = _inputBuffer; // Let's actually do a tight loop for ASCII first: final int end = inPtr + len; int i; while ((i = inputBuf[inPtr]) >= 0) { outBuf[outPtr++] = (char) i; if (++inPtr == end) { return _textBuffer.setCurrentAndReturn(outPtr); } } final int[] codes = sUtf8UnitLengths; do { i = inputBuf[inPtr++] & 0xFF; switch (codes[i]) { case 0: break; case 1: i = ((i & 0x1F) << 6) | (inputBuf[inPtr++] & 0x3F); break; case 2: i = ((i & 0x0F) << 12) | ((inputBuf[inPtr++] & 0x3F) << 6) | (inputBuf[inPtr++] & 0x3F); break; case 3: i = ((i & 0x07) << 18) | ((inputBuf[inPtr++] & 0x3F) << 12) | ((inputBuf[inPtr++] & 0x3F) << 6) | (inputBuf[inPtr++] & 0x3F); // note: this is the codepoint value; need to split, too i -= 0x10000; outBuf[outPtr++] = (char) (0xD800 | (i >> 10)); i = 0xDC00 | (i & 0x3FF); break; default: // invalid _reportError("Invalid byte "+Integer.toHexString(i)+" in Unicode text block"); } outBuf[outPtr++] = (char) i; } while (inPtr < end); return _textBuffer.setCurrentAndReturn(outPtr); } private final void _finishLongText(int len) throws IOException { char[] outBuf = _textBuffer.emptyAndGetCurrentSegment(); int outPtr = 0; final int[] codes = sUtf8UnitLengths; int outEnd = outBuf.length; while (--len >= 0) { int c = _nextByteGuaranteed() & 0xFF; int code = codes[c]; if (code == 0 && outPtr < outEnd) { outBuf[outPtr++] = (char) c; continue; } if ((len -= code) < 0) { // may need to improve error here but... throw _constructError("Malformed UTF-8 character at end of long (non-chunked) text segment"); } switch (code) { case 0: break; case 1: // 2-byte UTF { int d = _nextByteGuaranteed(); if ((d & 0xC0) != 0x080) { _reportInvalidOther(d & 0xFF, _inputPtr); } c = ((c & 0x1F) << 6) | (d & 0x3F); } break; case 2: // 3-byte UTF c = _decodeUTF8_3(c); break; case 3: // 4-byte UTF c = _decodeUTF8_4(c); // Let's add first part right away: outBuf[outPtr++] = (char) (0xD800 | (c >> 10)); if (outPtr >= outBuf.length) { outBuf = _textBuffer.finishCurrentSegment(); outPtr = 0; outEnd = outBuf.length; } c = 0xDC00 | (c & 0x3FF); // And let the other char output down below break; default: // Is this good enough error message? _reportInvalidChar(c); } // Need more room? if (outPtr >= outEnd) { outBuf = _textBuffer.finishCurrentSegment(); outPtr = 0; outEnd = outBuf.length; } // Ok, let's add char to output: outBuf[outPtr++] = (char) c; } _textBuffer.setCurrentLength(outPtr); } private final int _decodeUTF8_3(int c1) throws IOException { c1 &= 0x0F; int d = _nextByteGuaranteed(); if ((d & 0xC0) != 0x080) { _reportInvalidOther(d & 0xFF, _inputPtr); } int c = (c1 << 6) | (d & 0x3F); d = _nextByteGuaranteed(); if ((d & 0xC0) != 0x080) { _reportInvalidOther(d & 0xFF, _inputPtr); } c = (c << 6) | (d & 0x3F); return c; } private final int _decodeUTF8_4(int c) throws IOException { int d = _nextByteGuaranteed(); if ((d & 0xC0) != 0x080) { _reportInvalidOther(d & 0xFF, _inputPtr); } c = ((c & 0x07) << 6) | (d & 0x3F); d = _nextByteGuaranteed(); if ((d & 0xC0) != 0x080) { _reportInvalidOther(d & 0xFF, _inputPtr); } c = (c << 6) | (d & 0x3F); d = _nextByteGuaranteed(); if ((d & 0xC0) != 0x080) { _reportInvalidOther(d & 0xFF, _inputPtr); } return ((c << 6) | (d & 0x3F)) - 0x10000; } protected void _reportInvalidChar(int c) throws JsonParseException { // Either invalid WS or illegal UTF-8 start char if (c < ' ') { _throwInvalidSpace(c); } _reportInvalidInitial(c); } private void _reportInvalidInitial(int mask) throws JsonParseException { _reportError("Invalid UTF-8 start byte 0x"+Integer.toHexString(mask)); } private void _reportInvalidOther(int mask) throws JsonParseException { _reportError("Invalid UTF-8 middle byte 0x"+Integer.toHexString(mask)); } private void _reportInvalidOther(int mask, int ptr) throws JsonParseException { _inputPtr = ptr; _reportInvalidOther(mask); } /* /********************************************************** /* Methods for AvroReadContext implementations: decoding Bytes /********************************************************** */ @Override public JsonToken decodeBytes() throws IOException { int len = decodeInt(); if (len <= 0) { if (len < 0) { _reportError("Invalid length indicator for Bytes: "+len); } _binaryValue = NO_BYTES; } else { byte[] b = new byte[len]; // this is simple raw read, safe to use: _read(b, 0, len); _binaryValue = b; } return JsonToken.VALUE_EMBEDDED_OBJECT; } @Override public void skipBytes() throws IOException { int len = decodeInt(); if (len <= 0) { if (len < 0) { _reportError("Invalid length indicator for Bytes: "+len); } _binaryValue = NO_BYTES; } else { _skip(len); } } @Override public JsonToken decodeFixed(int size) throws IOException { byte[] data = new byte[size]; _read(data, 0, size); _binaryValue = data; return JsonToken.VALUE_EMBEDDED_OBJECT; } @Override public void skipFixed(int size) throws IOException { _skip(size); } private final void _read(byte[] target, int offset, int len) throws IOException { int ptr = _inputPtr; int available = _inputEnd - ptr; if (len <= available) { // already got it all? System.arraycopy(_inputBuffer, ptr, target, offset, len); _inputPtr = ptr + len; return; } // only had some, copy whatever there is System.arraycopy(_inputBuffer, ptr, target, offset, available); _inputPtr = ptr + available; offset += available; int left = len - available; // and rest we can read straight from input do { int count = _inputStream.read(target, offset, left); if (count <= 0) { _reportError("Needed to read "+len+" bytes, reached end-of-input after reading "+(len - left)); } offset += count; left -= count; } while (left > 0); } private final void _skip(int len) throws IOException { int ptr = _inputPtr; int available = _inputEnd - ptr; int left = len - available; if (left <= 0) { _inputPtr = ptr + len; return; } _inputPtr = _inputEnd; // mark all used, whatever it was if (_inputStream != null) { do { int skipped = (int) _inputStream.skip(left); if (skipped < 0) { break; } left -= skipped; } while (left > 0); } if (left > 0) { _reportError("Only able to skip "+(len-left)+" bytes before end-of-input (needed "+len+")"); } } private final void _skipL(long len) throws IOException { int ptr = _inputPtr; int available = _inputEnd - ptr; long left = len - available; if (left <= 0L) { _inputPtr = ptr + (int) len; return; } _inputPtr = _inputEnd; // mark all used, whatever it was if (_inputStream != null) { do { int skipped = (int) _inputStream.skip(left); if (skipped < 0) { break; } left -= skipped; } while (left > 0L); } if (left > 0L) { _reportError("Only able to skip "+(len-left)+" bytes before end-of-input (needed "+len+")"); } } /* /********************************************************** /* Methods for AvroReadContext implementations: decoding Arrays /********************************************************** */ @Override public long decodeArrayStart() throws IOException { return _decodeChunkLength(); } @Override public long decodeArrayNext() throws IOException { return _decodeChunkLength(); } @Override public long skipArray() throws IOException { return _skipChunkElements(); } // used for Arrays and Maps, first and other chunks private final long _decodeChunkLength() throws IOException { long result = decodeLong(); if (result < 0) { skipLong(); // Consume byte-count if present result = -result; } return result; } private long _skipChunkElements() throws IOException { int result = decodeInt(); while (result < 0) { long bytecount = decodeLong(); _skipL(bytecount); result = decodeInt(); } return result; } /* /********************************************************** /* Methods for AvroReadContext implementations: decoding Maps /********************************************************** */ @Override public String decodeMapKey() throws IOException { decodeString(); return _textBuffer.contentsAsString(); } @Override public long decodeMapStart() throws IOException { return _decodeChunkLength(); } @Override public long decodeMapNext() throws IOException { return _decodeChunkLength(); } @Override public long skipMap() throws IOException { return _skipChunkElements(); } /* /********************************************************** /* Methods for AvroReadContext implementations: misc /********************************************************** */ @Override public JsonToken decodeBoolean() throws IOException { int b = _nextByteGuaranteed(); // As per Avro default impl: only `1` recognized as true (unlike // "C-style" 0 == false, others true) return (b == 1) ? JsonToken.VALUE_TRUE : JsonToken.VALUE_FALSE; } @Override public void skipBoolean() throws IOException { _skipByteGuaranteed(); } @Override public int decodeIndex() throws IOException { return (_branchIndex = decodeInt()); } @Override public int decodeEnum() throws IOException { return (_enumIndex = decodeInt()); } @Override public boolean checkInputEnd() throws IOException { if (_closed) { return true; } if (_inputPtr < _inputEnd) { return false; } return !_loadMore(); } /* /********************************************************** /* Low-level methods: setting values from defaults /********************************************************** */ @Override protected JsonToken setString(String str) { _textBuffer.resetWithString(str); return JsonToken.VALUE_STRING; } /* /********************************************************** /* Low-level reading, other /********************************************************** */ private final byte _nextByteGuaranteed() throws IOException { int ptr = _inputPtr; if (ptr < _inputEnd) { byte b = _inputBuffer[ptr]; _inputPtr = ptr+1; return b; } return _nextByteGuaranteed2(); } private final byte _nextByteGuaranteed2() throws IOException { if (!_loadMore()) { _reportInvalidEOF(); } return _inputBuffer[_inputPtr++]; } protected final void _loadMoreGuaranteed() throws IOException { if (!_loadMore()) { _reportInvalidEOF(); } } private final void _skipByteGuaranteed() throws IOException { int ptr = _inputPtr; if (ptr < _inputEnd) { _inputPtr = ptr+1; return; } _loadMoreGuaranteed(); _inputPtr += 1; } protected final boolean _loadMore() throws IOException { //_currInputRowStart -= _inputEnd; if (_inputStream != null) { int count = _inputStream.read(_inputBuffer, 0, _inputBuffer.length); _currInputProcessed += _inputEnd; _inputPtr = 0; if (count > 0) { _inputEnd = count; return true; } // important: move pointer to same as end, to keep location accurate _inputEnd = 0; // End of input _closeInput(); // Should never return 0, so let's fail if (count == 0) { throw new IOException("InputStream.read() returned 0 characters when trying to read "+_inputBuffer.length+" bytes"); } } return false; }
Helper method that will try to load at least specified number bytes in input buffer, possible moving existing data around if necessary
/** * Helper method that will try to load at least specified number bytes in * input buffer, possible moving existing data around if necessary */
protected final void _loadToHaveAtLeast(int minAvailable) throws IOException { // Need to move remaining data in front? int amount = _inputEnd - _inputPtr; _currInputProcessed += _inputPtr; if (_inputPtr > 0) { if (amount > 0) { //_currInputRowStart -= _inputPtr; System.arraycopy(_inputBuffer, _inputPtr, _inputBuffer, 0, amount); _inputEnd = amount; } else { _inputEnd = 0; } } _inputPtr = 0; // No input stream, no leading (either we are closed, or have non-stream input source) if (_inputStream == null) { _reportError("Needed to read %d bytes, reached end-of-input", minAvailable); } while (_inputEnd < minAvailable) { int count = _inputStream.read(_inputBuffer, _inputEnd, _inputBuffer.length - _inputEnd); if (count < 1) { // End of input _closeInput(); // Should never return 0, so let's fail if (count == 0) { throw new IOException("InputStream.read() returned 0 characters when trying to read "+amount+" bytes"); } _reportError("Needed to read %d bytes, missed %d before end-of-input", minAvailable, minAvailable); } _inputEnd += count; } } private void _reportInvalidNegative(int v) throws IOException { _reportError("Invalid negative byte %x at end of VInt", v); } }