protected static byte[] readDelimitedBuffer(RandomAccessFile fileHandle) throws IOException, CorruptEventException { int length = fileHandle.readInt(); if (length < 0) { throw new CorruptEventException("Length of event is: " + String.valueOf(length) + ". Event must have length >= 0. Possible corruption of data or partial fsync."); } byte[] buffer = new byte[length]; try { fileHandle.readFully(buffer); } catch (EOFException ex) { throw new CorruptEventException("Remaining data in file less than " + "expected size of event.", ex); } return buffer; }
/** * Skip forward the number of line delimiters. If you are in the middle of a line, * a value of 1 will skip to the start of the next record. * @param lines Number of lines to skip. * @throws IOException */ public final void skipLines(int lines) throws IOException { if (lines < 1) { return; } long expectedLineCount = this.lineCount + lines; try { do { nextChar(); } while (lineCount < expectedLineCount); if (lineCount < lines) { throw new IllegalArgumentException("Unable to skip " + lines + " lines from line " + (expectedLineCount - lines) + ". End of input reached"); } } catch (EOFException ex) { throw new IllegalArgumentException("Unable to skip " + lines + " lines from line " + (expectedLineCount - lines) + ". End of input reached"); } }
/** * Returns the ASCII characters up to but not including the next "\r\n", or * "\n". * * @throws java.io.EOFException if the stream is exhausted before the next newline * character. */ public static String readAsciiLine(InputStream in) throws IOException { // TODO: support UTF-8 here instead StringBuilder result = new StringBuilder(80); while (true) { int c = in.read(); if (c == -1) { throw new EOFException(); } else if (c == '\n') { break; } result.append((char) c); } int length = result.length(); if (length > 0 && result.charAt(length - 1) == '\r') { result.setLength(length - 1); } return result.toString(); }
@Override public GraphDocument parse() throws IOException { folderStack.push(rootDocument); hashStack.push(null); if (monitor != null) { monitor.setState("Starting parsing"); } try { while(true) { parseRoot(); } } catch (EOFException e) { } if (monitor != null) { monitor.setState("Finished parsing"); } return rootDocument; }
@Override public void readFully(long position, byte[] b, int off, int len) throws IOException { if (b == null) { throw new NullPointerException(); } else if (off < 0 || len < 0 || len > b.length - off) { throw new IndexOutOfBoundsException(); } else if (len == 0) { return; } if (position > length) { throw new IOException("Cannot read after EOF."); } if (position < 0) { throw new IOException("Cannot read to negative offset."); } checkStream(); if (position + len > length) { throw new EOFException("Reach the end of stream."); } System.arraycopy(data, (int)position, b, off, len); }
@Override public void write(byte[] b, int off, int len) throws IOException { ByteBuffer bb = ByteBuffer.wrap(b, off, len); while (bb.remaining() > 0) { channel.write(bb); if (bb.remaining() == 0) { return; } // wait for socket to become ready again int sel = selector.select(timeout); if (sel == 0) { throw new IOException("Timed out"); } else if (!channel.isConnected()) { throw new EOFException("Closed"); } } }
boolean readRow(RowInputInterface rowin, int pos) throws IOException { try { int length = dataStreamIn.readInt(); int count = 4; if (length == 0) { return false; } rowin.resetRow(pos, length); dataStreamIn.readFully(rowin.getBuffer(), count, length - count); return true; } catch (EOFException e) { return false; } }
/** * Returns the ASCII characters up to but not including the next "\r\n", or * "\n". * * @throws EOFException if the stream is exhausted before the next newline * character. */ public static String readAsciiLine(InputStream in) throws IOException { // TODO: support UTF-8 here instead StringBuilder result = new StringBuilder(80); while (true) { int c = in.read(); if (c == -1) { throw new EOFException(); } else if (c == '\n') { break; } result.append((char) c); } int length = result.length(); if (length > 0 && result.charAt(length - 1) == '\r') { result.setLength(length - 1); } return result.toString(); }
/** * Skip forward the number of line delimiters. If you are in the middle of a line, * a value of 1 will skip to the start of the next record. * @param lines Number of lines to skip. * @throws IOException */ public final void skipLines(int lines) throws IOException { if (lines < 1) { return; } long expectedLineCount = this.lineCount + lines; try { do { nextChar(); } while (lineCount < expectedLineCount /*&& bufferPtr < READ_CHARS_LIMIT*/); if (lineCount < lines) { throw new IllegalArgumentException("Unable to skip " + lines + " lines from line " + (expectedLineCount - lines) + ". End of input reached"); } } catch (EOFException ex) { throw new IllegalArgumentException("Unable to skip " + lines + " lines from line " + (expectedLineCount - lines) + ". End of input reached"); } }
public MotionData getNextData() { MotionData data = null; try { data = motionInputStream.readData(motionData); return data; } catch (EOFException e) { try { Thread.currentThread(); Thread.sleep(200); } catch (InterruptedException ignore) { } rewind(); } catch (IOException io) { // io.printStackTrace(); rewind(); return chip.getEmptyMotionData(); } catch (NullPointerException np) { np.printStackTrace(); rewind(); } return data; }
private byte[] getBytes(ZipEntry ze) throws IOException { try (InputStream is = super.getInputStream(ze)) { int len = (int)ze.getSize(); int bytesRead; byte[] b; // trust specified entry sizes when reasonably small if (len != -1 && len <= 65535) { b = new byte[len]; bytesRead = is.readNBytes(b, 0, len); } else { b = is.readAllBytes(); bytesRead = b.length; } if (len != -1 && len != bytesRead) { throw new EOFException("Expected:" + len + ", read:" + bytesRead); } return b; } }
/** * Decodes an array of instructions. The result has non-null * elements at each offset that represents the start of an * instruction. */ public static DecodedInstruction[] decodeAll(short[] encodedInstructions) { int size = encodedInstructions.length; DecodedInstruction[] decoded = new DecodedInstruction[size]; ShortArrayCodeInput in = new ShortArrayCodeInput(encodedInstructions); try { while (in.hasMore()) { decoded[in.cursor()] = DecodedInstruction.decode(in); } } catch (EOFException ex) { throw new DexException(ex); } return decoded; }
public int read(byte[] b, int off, int len) throws EOFException { if (link.isEmpty()) { return 0; } int olen = len; while (true) { ByteBuffer bb = link.getFirst(); if (len < bb.remaining()) { bb.get(b, off, len); incrReadByteCount(len); return olen; } int rem = bb.remaining(); bb.get(b, off, rem); incrReadByteCount(rem); len -= rem; off += rem; if (!removeFirstLink(bb)) { break; } } return olen - len; }
private static CompleteType getLiteralSchema(QueryContext context, byte[] bytes) { try( BufferAllocator allocator = context.getAllocator().newChildAllocator("convert-from-json-sampling", 0, 1024*1024); BufferManager bufferManager = new BufferManagerImpl(allocator); ArrowBuf data = allocator.buffer(bytes.length); VectorContainer container = new VectorContainer(allocator); VectorAccessibleComplexWriter vc = new VectorAccessibleComplexWriter(container) ){ data.writeBytes(bytes); JsonReader jsonReader = new JsonReader(bufferManager.getManagedBuffer(), false, false, false); jsonReader.setSource(bytes); ComplexWriter writer = new ComplexWriterImpl("dummy", vc); writer.setPosition(0); ReadState state = jsonReader.write(writer); if(state == ReadState.END_OF_STREAM){ throw new EOFException("Unexpected arrival at end of JSON literal stream"); } container.buildSchema(); return CompleteType.fromField(container.getSchema().getFields().get(0)); }catch(Exception ex){ throw UserException.validationError(ex).message("Failure while trying to parse JSON literal.").build(logger); } }
/** Check the rpc response header. */ void checkResponse(RpcResponseHeaderProto header) throws IOException { if (header == null) { throw new EOFException("Response is null."); } if (header.hasClientId()) { // check client IDs final byte[] id = header.getClientId().toByteArray(); if (!Arrays.equals(id, RpcConstants.DUMMY_CLIENT_ID)) { if (!Arrays.equals(id, clientId)) { throw new IOException("Client IDs not matched: local ID=" + StringUtils.byteToHexString(clientId) + ", ID in response=" + StringUtils.byteToHexString(header.getClientId().toByteArray())); } } } }
public final void readFully(byte[] b, int off, int len) throws IOException { if (len < 0) { throw new IndexOutOfBoundsException(); } int n = 0; while (n < len) { int count = read(b, off + n, len - n); if (count < 0) { throw new EOFException(); } n += count; } }
public static LuaValue freaduntil(File f,boolean lineonly) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); int c; try { if ( lineonly ) { loop: while ( (c = f.read()) > 0 ) { switch ( c ) { case '\r': break; case '\n': break loop; default: baos.write(c); break; } } } else { while ( (c = f.read()) > 0 ) baos.write(c); } } catch ( EOFException e ) { c = -1; } return ( c < 0 && baos.size() == 0 )? (LuaValue) NIL: (LuaValue) LuaString.valueUsing(baos.toByteArray()); }
int readLeUnsignedShort() throws IOException { int result; if(pos + 1 < buffer.length) { result = ((buffer[pos + 0] & 0xff) | (buffer[pos + 1] & 0xff) << 8); pos += 2; } else { int b0 = read(); int b1 = read(); if (b1 == -1) throw new EOFException(); result = (b0 & 0xff) | (b1 & 0xff) << 8; } return result; }
static String parseComment(BufferedReader in) throws IOException { StringBuffer sb = new StringBuffer(); boolean white = false; int count = 0; while( true ) { int i = in.read(); if( i==-1 )throw new EOFException(); char c = (char)i; if( Character.isWhitespace(c) ) { if( white )continue; white = true; sb.append(' '); continue; } if( c=='<' )count++; if( c=='>' ) { if( count==0) { // System.out.println("comment:\t"+sb.toString()); return sb.toString(); } count--; } sb.append(c); white = false; } }
private int fillReadBuffer(boolean block) throws IOException { int nRead; if (block) { Selector selector = null; try { selector = pool.get(); } catch ( IOException x ) { // Ignore } try { NioEndpoint.KeyAttachment att = (NioEndpoint.KeyAttachment) nioChannel.getAttachment(); if (att == null) { throw new IOException("Key must be cancelled."); } nRead = pool.read(nioChannel.getBufHandler().getReadBuffer(), nioChannel, selector, att.getTimeout()); } catch (EOFException eof) { nRead = -1; } finally { if (selector != null) { pool.put(selector); } } } else { nRead = nioChannel.read(nioChannel.getBufHandler().getReadBuffer()); } return nRead; }
public long readLong() throws IOException { long ch1 = read(); long ch2 = read(); long ch3 = read(); long ch4 = read(); long ch5 = read(); long ch6 = read(); long ch7 = read(); long ch8 = read(); if (ch1 < 0) throw new EOFException(); if (ch2 < 0) throw new EOFException(); if (ch3 < 0) throw new EOFException(); if (ch4 < 0) throw new EOFException(); if (ch5 < 0) throw new EOFException(); if (ch6 < 0) throw new EOFException(); if (ch7 < 0) throw new EOFException(); if (ch8 < 0) throw new EOFException(); return ch1 | (ch2 << 8) | (ch3 << 16) | (ch4 << 24) | (ch5 << 32) | (ch6 << 40) | (ch7 << 48) | (ch8 << 56); }
public byte readByte() throws IOException { int b = input.read(); if (b < 0) { throw new EOFException(); } return (byte) b; }
public int readInt() throws IOException { int ch1 = read(); int ch2 = read(); int ch3 = read(); int ch4 = read(); if (ch1 < 0) throw new EOFException(); if (ch2 < 0) throw new EOFException(); if (ch3 < 0) throw new EOFException(); if (ch4 < 0) throw new EOFException(); return ch1 + (ch2 << 8) | (ch3 << 16) | (ch4 << 24); }
@Override public int sampleData(ExtractorInput input, int length, boolean allowEndOfInput) throws IOException, InterruptedException { byte[] newData = new byte[length]; int bytesAppended = input.read(newData, 0, length); if (bytesAppended == C.RESULT_END_OF_INPUT) { if (allowEndOfInput) { return C.RESULT_END_OF_INPUT; } throw new EOFException(); } newData = Arrays.copyOf(newData, bytesAppended); sampleData = TestUtil.joinByteArrays(sampleData, newData); return bytesAppended; }
public final int readUnsignedShort() throws IOException { int ch1 = read(); int ch2 = read(); if ((ch1 | ch2) < 0) { throw new EOFException(); } return (ch1 << 8) + (ch2); }
@Override public NodeHeartbeatResponse nodeHeartbeat(NodeHeartbeatRequest request) throws YarnException, IOException { heartBeatID++; if(heartBeatID == 1) { // EOFException should be retried as well. throw new EOFException("NodeHeartbeat exception"); } else { throw new java.net.ConnectException( "NodeHeartbeat exception"); } }
public final void skip(int bytes) throws IOException { if (bytes<=0) { return; } long skipped=m_stream.skip(bytes); m_position+=skipped; if (skipped!=bytes) { throw new EOFException(); } }
@Override public int readInt(long pos) throws IOException { try { return curBuf.getInt((int) pos); } catch (IllegalArgumentException e) { if (pos < 0) { throw new IllegalArgumentException("Seeking to negative position: " + this, e); } else { throw new EOFException("seek past EOF: " + this); } } catch (NullPointerException npe) { throw new AlreadyClosedException("Already closed: " + this); } }
@Override public DaemonStopEvent read(Decoder decoder) throws EOFException, Exception { long timestamp = decoder.readLong(); long pid = decoder.readLong(); DaemonExpirationStatus status = decoder.readBoolean() ? DaemonExpirationStatus.values()[decoder.readByte()] : null; String reason = decoder.readNullableString(); return new DaemonStopEvent(new Date(timestamp), pid, status, reason); }
public final int readUnsignedShort() throws IOException { int b1 = read(); int b2 = read(); if ((b1 | b2) < 0) { throw new EOFException(); } return ((b1 << 8) + (b2)); }
public void read(byte[] b, int offset, int length) throws IOException { try { if (bufferDirty || seekPosition < bufferOffset || seekPosition >= bufferOffset + buffer.length) { readIntoBuffer(); } else { cacheHit++; } ba.reset(); if (seekPosition - bufferOffset != ba.skip(seekPosition - bufferOffset)) { throw new EOFException(); } int bytesRead = ba.read(b, offset, length); seekPosition += bytesRead; if (bytesRead < length) { if (seekPosition != realPosition) { file.seek(seekPosition); } file.readFully(b, offset + bytesRead, length - bytesRead); seekPosition += (length - bytesRead); realPosition = seekPosition; } } catch (IOException e) { resetPointer(); appLog.logContext(e, null); throw e; } }
@Override public byte readByte() throws IOException { try { return bb.get(); } catch (BufferUnderflowException e) { throw new EOFException(e.getMessage()); } }
/** * Reads an int value from stream * @return an int value * @throws IOException if no value was read */ public final int readInt() throws IOException { int ch1 = read(); int ch2 = read(); int ch3 = read(); int ch4 = read(); if ((ch1 | ch2 | ch3 | ch4) < 0) { throw new EOFException(); } return (ch1 << SHIFT24) + (ch2 << TWO_BYTE_SIZE) + (ch3 << BYTE_SIZE) + ch4; }
@Override public void seek(long pos) throws IOException { int newBufferIndex = (int) (pos / Constants.BUFFER_SIZE); if (newBufferIndex != currentBufferIndex) { currentBufferIndex = newBufferIndex; setCurrentBuffer(); } bufferPosition = (int) (pos % Constants.BUFFER_SIZE); if (getFilePointer() > length()) { throw new EOFException("seek beyond EOF: pos=" + getFilePointer() + " vs length=" + length() + ": " + this); } }
/** * Simple wrapper around {@link InputStream#read()} that throws EOFException * instead of returning -1. */ private static int read(InputStream is) throws IOException { int b = is.read(); if (b == -1) { throw new EOFException(); } return b; }
private void readEndOfRecord(DataInput di) throws IOException { int b = di.readByte(); if (b != DiskInitFile.END_OF_RECORD_ID) { if (b == 0) { // this is expected if this is the last record and we died while writing it. throw new EOFException("found partial last record"); } else { // Our implementation currently relies on all unwritten bytes having // a value of 0. So throw this exception if we find one we didn't expect. throw new IllegalStateException("expected end of record (byte==" + DiskInitFile.END_OF_RECORD_ID + ") or zero but found " + b); } } }
@Override public byte readByte() throws IOException { if (pos >= offset + length) { throw new EOFException("seek past EOF"); } return bytes[offset + pos++]; }
