public static void main(String args[]) throws Exception { ByteBuffer buffer = ByteBuffer.allocate(10); for (int i = 0; i < buffer.capacity(); ++i) { buffer.put((byte) i); } buffer.position(3); buffer.limit(7); ByteBuffer slice = buffer.slice(); for (int i = 0; i < slice.capacity(); ++i) { byte b = slice.get(i); b *= 11; slice.put(i, b); } buffer.position(0); buffer.limit(buffer.capacity()); while (buffer.hasRemaining()) { System.out.println(buffer.get()); } }
public String asHexToken(Key key) { try { Cipher encodingCipher = Cipher.getInstance("AES"); encodingCipher.init(Cipher.ENCRYPT_MODE, key); ByteBuffer buffer = ByteBuffer.allocate(16 + 1 + 8 + 8 + getBufferSize()); buffer.position(16); buffer.put(getId()); buffer.putLong(getExpires().getTimeInMillis()); buffer.putLong(getUoid()); getBytes(buffer); if (buffer.position() != buffer.capacity()) { throw new RuntimeException( "Buffer's position should be at the end " + buffer.position() + "/" + buffer.capacity()); } MessageDigest messageDigest = MessageDigest.getInstance("MD5"); buffer.position(16); messageDigest.update(buffer); buffer.position(0); buffer.put(messageDigest.digest()); byte[] encodedBytes = encodingCipher.doFinal(buffer.array()); String encodedHexString = new String(Hex.encodeHex(encodedBytes)); return encodedHexString; } catch (Exception e) { LOGGER.error("", e); } return null; }
/** Method <code>resizeApplicationBuffer</code> is used to perform */ private ByteBuffer resizeApplicationBuffer(ByteBuffer net, ByteBuffer app) { // if (appBuffSize > app.remaining()) { // if (net.remaining() > app.remaining()) { // if (appBuffSize > app.capacity() - app.remaining()) { // if (log.isLoggable(Level.FINE)) { // log.fine("Resizing tlsInput to " + (appBuffSize + app.capacity()) + " bytes."); // } // // ByteBuffer bb = ByteBuffer.allocate(app.capacity() + appBuffSize); if (log.isLoggable(Level.FINE)) { log.log( Level.FINE, "Resizing tlsInput to {0} bytes, {1}", new Object[] {(2048 + app.capacity()), debugId}); } ByteBuffer bb = ByteBuffer.allocate(app.capacity() + 2048); // bb.clear(); bb.order(app.order()); app.flip(); bb.put(app); return bb; // } else { // // return app; // } // end of else }
private CommandArgs<K, V> write(byte[] arg) { buffer.mark(); if (buffer.remaining() < arg.length) { int estimate = buffer.remaining() + arg.length + 10; realloc(max(buffer.capacity() * 2, estimate)); } while (true) { try { buffer.put((byte) '$'); write(arg.length); buffer.put(CRLF); buffer.put(arg); buffer.put(CRLF); break; } catch (BufferOverflowException e) { buffer.reset(); realloc(buffer.capacity() * 2); } } count++; return this; }
private CommandArgs<K, V> write(String arg) { int length = arg.length(); buffer.mark(); if (buffer.remaining() < length) { int estimate = buffer.remaining() + length + 10; realloc(max(buffer.capacity() * 2, estimate)); } while (true) { try { buffer.put((byte) '$'); write(length); buffer.put(CRLF); for (int i = 0; i < length; i++) { buffer.put((byte) arg.charAt(i)); } buffer.put(CRLF); break; } catch (BufferOverflowException e) { buffer.reset(); realloc(buffer.capacity() * 2); } } count++; return this; }
TileIndex(final File tileIndexFile) { try { this.tileIndexFile = tileIndexFile; final InputStream is = IOUtil.maybeBufferInputStream(new FileInputStream(tileIndexFile)); final ByteBuffer buf = ByteBuffer.allocate(8); buf.order(ByteOrder.LITTLE_ENDIAN); int absoluteRecordIndex = 0; int numTiles = 0; while (readTileIndexRecord(buf.array(), buf.capacity(), is)) { buf.rewind(); buf.limit(buf.capacity()); final int tile = buf.getInt(); // Note: not handling unsigned ints > 2^31, but could if one of these exceptions is thrown. if (tile < 0) throw new PicardException("Tile number too large in " + tileIndexFile.getAbsolutePath()); final int numClusters = buf.getInt(); if (numClusters < 0) throw new PicardException("Cluster size too large in " + tileIndexFile.getAbsolutePath()); tiles.add(new TileIndexRecord(tile, numClusters, absoluteRecordIndex, numTiles++)); absoluteRecordIndex += numClusters; } CloserUtil.close(is); } catch (final IOException e) { throw new PicardException("Problem reading " + tileIndexFile.getAbsolutePath(), e); } }
@Override public void read(int len) { if (readByteBuffer.position() != readByteBuffer.capacity()) { logger.error( "Read buffer position {} != capacity {}", readByteBuffer.position(), readByteBuffer.capacity()); eventLoop.disconnect(this); return; } readByteBuffer.flip(); long timestamp = readByteBuffer.getLong(); if (timestamp < -2) { logger.error("Received bad timestamp {}", timestamp); eventLoop.disconnect(this); return; } else if (timestamp != this.timestamp) { logger.error("Received bad timestamp {}. Sent timestamp {}", timestamp, this.timestamp); eventLoop.disconnect(this); return; } else if (timestamp > 0) { benchmarkResults.addResult(System.nanoTime() - timestamp); } readByteBuffer.clear(); send(); }
private void free(ByteBuffer oldBuf) { if ((oldBuf == null) || ((maxCachedBufferSize != 0) && (oldBuf.capacity() > maxCachedBufferSize)) || oldBuf.isReadOnly() || isDerived() || (Thread.currentThread() != ownerThread)) { return; } // Add to the cache. Queue<CachedBuffer> pool; if (oldBuf.isDirect()) { pool = directBuffers.get().get(oldBuf.capacity()); } else { pool = heapBuffers.get().get(oldBuf.capacity()); } if (pool == null) { return; } // Restrict the size of the pool to prevent OOM. if ((maxPoolSize == 0) || (pool.size() < maxPoolSize)) { pool.offer(new CachedBuffer(oldBuf)); } }
private int bufferCopiedCallback(long nCopiedSize, long nAvailableSize) { if (!super.mValid) { Log.e(TAG, "Invalid state"); return -1; } if (mPreview == null || !mPreview.isReady()) { // Not on the top return 0; } if (mVideoFrame == null || mVideoFrame.capacity() != nAvailableSize) { synchronized (mPreview) { long newWidth = mConsumer.getDisplayWidth(); long newHeight = mConsumer.getDisplayHeight(); mVideoFrame = ByteBuffer.allocateDirect((int) nAvailableSize); mConsumer.setConsumeBuffer(mVideoFrame, mVideoFrame.capacity()); mWidth = (int) newWidth; mHeight = (int) newHeight; mPreview.setBuffer(mVideoFrame, mWidth, mHeight); } return 0; } mPreview.requestRender(); return 0; }
/** Read at least the specified amount of bytes, and place them in the input buffer. */ protected boolean readt(int n, boolean useAvailableData) throws IOException { if (useAvailableData && inputBuffer.remaining() == 0) { return false; } if (inputBuffer.capacity() - inputBuffer.limit() <= n - inputBuffer.remaining()) { inputBuffer.compact(); inputBuffer.limit(inputBuffer.position()); inputBuffer.position(0); } int nRead; while (inputBuffer.remaining() < n) { nRead = Socket.recvbb( getSocketWrapper().getSocket().longValue(), inputBuffer.limit(), inputBuffer.capacity() - inputBuffer.limit()); if (nRead > 0) { inputBuffer.limit(inputBuffer.limit() + nRead); } else { if ((-nRead) == Status.getEtimedout() || (-nRead) == Status.getTimeup()) { return false; } else { throw new IOException(getSm().getString("ajpprocessor.failedread")); } } } return true; }
private UpfrontAllocatingPageSource( BufferSource source, long max, int maxChunk, int minChunk, boolean fixed) { Long totalPhysical = PhysicalMemory.totalPhysicalMemory(); Long freePhysical = PhysicalMemory.freePhysicalMemory(); if (totalPhysical != null && max > totalPhysical) { throw new IllegalArgumentException( "Attempting to allocate " + DebuggingUtils.toBase2SuffixedString(max) + "B of memory " + "when the host only contains " + DebuggingUtils.toBase2SuffixedString(totalPhysical) + "B of physical memory"); } if (freePhysical != null && max > freePhysical) { LOGGER.warn( "Attempting to allocate {}B of offheap when there is only {}B of free physical memory - some paging will therefore occur.", DebuggingUtils.toBase2SuffixedString(max), DebuggingUtils.toBase2SuffixedString(freePhysical)); } LOGGER.info("Allocating {}B in chunks", DebuggingUtils.toBase2SuffixedString(max)); for (ByteBuffer buffer : allocateBackingBuffers(source, max, maxChunk, minChunk, fixed)) { sliceAllocators.add(new PowerOfTwoAllocator(buffer.capacity())); victimAllocators.add(new PowerOfTwoAllocator(buffer.capacity())); victims.add(new TreeSet<Page>(REGION_COMPARATOR)); buffers.add(buffer); } }
@Override protected Action process() throws Exception { // Only return if EOF has previously been read and thus // a write done with EOF=true if (_eof) { if (LOG.isDebugEnabled()) LOG.debug("EOF of {}", this); // Handle EOF _in.close(); closed(); _channel.getByteBufferPool().release(_buffer); return Action.SUCCEEDED; } // Read until buffer full or EOF int len = 0; while (len < _buffer.capacity() && !_eof) { int r = _in.read(_buffer.array(), _buffer.arrayOffset() + len, _buffer.capacity() - len); if (r < 0) _eof = true; else len += r; } // write what we have _buffer.position(0); _buffer.limit(len); write(_buffer, _eof, this); return Action.SCHEDULED; }
@Override public void append(Framedata nextframe) throws InvalidFrameException { ByteBuffer b = nextframe.getPayloadData(); if (unmaskedpayload == null) { unmaskedpayload = ByteBuffer.allocate(b.remaining()); b.mark(); unmaskedpayload.put(b); b.reset(); } else { b.mark(); unmaskedpayload.position(unmaskedpayload.limit()); unmaskedpayload.limit(unmaskedpayload.capacity()); if (b.remaining() > unmaskedpayload.remaining()) { ByteBuffer tmp = ByteBuffer.allocate(b.remaining() + unmaskedpayload.capacity()); unmaskedpayload.flip(); tmp.put(unmaskedpayload); tmp.put(b); unmaskedpayload = tmp; } else { unmaskedpayload.put(b); } unmaskedpayload.rewind(); b.reset(); } fin = nextframe.isFin(); }
private void writeToTexture(RectanglePacker.Rectangle r, ByteBuffer data) { assert r.width * r.height * format.bytes == data.capacity() : r + " * " + format.bytes + " != " + data.capacity(); GL11.glBindTexture(GL11.GL_TEXTURE_2D, id); GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, format.bytes); GL11.glTexSubImage2D( GL11.GL_TEXTURE_2D, 0, r.x, r.y, r.width, r.height, format.glFormat, GL11.GL_UNSIGNED_BYTE, data); GLUtil.checkGLError(); if (mipmap) { mipmapDirty = true; } }
protected void shrinkCapacity() { boolean shrink = false; int aver = (int) Math.ceil(average); int skrinkSize = aver; if (_buffer.capacity() > AUTO_SHRINK_SIZE) { shrink = true; if (Runtime.getRuntime().freeMemory() < MAX_BUFFER_CAPACITY) { skrinkSize = INITIAL_BUFFER_CAPACITY; } else { skrinkSize = (int) aver * 2 > AUTO_SHRINK_SIZE ? AUTO_SHRINK_SIZE : (int) aver * 2; } } else if (_buffer.capacity() <= AUTO_SHRINK_SIZE) { if (_buffer.capacity() > aver * 4) { shrink = true; skrinkSize = (int) aver * 2; } } if (shrink && skrinkSize < MAX_BUFFER_CAPACITY && skrinkSize > _have) { // System.out.println("hashcode="+this.hashCode()+",capacity="+_buffer.capacity()+",shrink="+shrinkSize+",average="+aver); ByteBuffer newbuf = ByteBuffer.allocate(skrinkSize); newbuf.put((ByteBuffer) _buffer.flip()); _buffer = newbuf; } }
/** Borrow a buffer from the pool. If none in the pool, create a new one. */ public ByteBuffer borrowBuffer() { ByteBuffer buffer = pool.poll(); if (buffer == null) { buffer = ByteBuffer.allocateDirect(bufferSize + guard.length); initializeGuard(buffer); if (logger.isDetailEnabled()) logger.detail( "FixedByteBufferPoolImpl for " + name + " got new buffer: position " + buffer.position() + " capacity " + buffer.capacity() + " limit " + buffer.limit()); } else { if (logger.isDetailEnabled()) logger.detail( "FixedByteBufferPoolImpl for " + name + " got used buffer: position " + buffer.position() + " capacity " + buffer.capacity() + " limit " + buffer.limit()); } buffer.clear(); return buffer; }
/** * Writes the ETC1Data with a PKM header to the given file. * * @param file the file. */ public void write(FileHandle file) { DataOutputStream write = null; byte[] buffer = new byte[10 * 1024]; int writtenBytes = 0; compressedData.position(0); compressedData.limit(compressedData.capacity()); try { write = new DataOutputStream(new GZIPOutputStream(file.write(false))); write.writeInt(compressedData.capacity()); while (writtenBytes != compressedData.capacity()) { int bytesToWrite = Math.min(compressedData.remaining(), buffer.length); compressedData.get(buffer, 0, bytesToWrite); write.write(buffer, 0, bytesToWrite); writtenBytes += bytesToWrite; } } catch (Exception e) { throw new GdxRuntimeException("Couldn't write PKM file to '" + file + "'", e); } finally { if (write != null) try { write.close(); } catch (Exception e) { } } compressedData.position(dataOffset); compressedData.limit(compressedData.capacity()); }
/** Helper method for implementing {@link MessageLite#hashCode()} for bytes field. */ public static int hashCodeByteBuffer(ByteBuffer bytes) { if (bytes.hasArray()) { // Fast path. int h = LiteralByteString.hashCode( bytes.capacity(), bytes.array(), bytes.arrayOffset(), bytes.capacity()); return h == 0 ? 1 : h; } else { // Read the data into a temporary byte array before calculating the // hash value. final int bufferSize = bytes.capacity() > DEFAULT_BUFFER_SIZE ? DEFAULT_BUFFER_SIZE : bytes.capacity(); final byte[] buffer = new byte[bufferSize]; final ByteBuffer duplicated = bytes.duplicate(); duplicated.clear(); int h = bytes.capacity(); while (duplicated.remaining() > 0) { final int length = duplicated.remaining() <= bufferSize ? duplicated.remaining() : bufferSize; duplicated.get(buffer, 0, length); h = LiteralByteString.hashCode(h, buffer, 0, length); } return h == 0 ? 1 : h; } }
/** * read the size of the op (i.e., number of bytes, including the op size) written at the given * position */ private final int readSize(ByteBuffer reusableBuffer, long position) { // read op size from disk assert reusableBuffer.capacity() >= 4 : "reusable buffer must have capacity >=4 when reading opSize. got [" + reusableBuffer.capacity() + "]"; try { reusableBuffer.clear(); reusableBuffer.limit(4); readBytes(reusableBuffer, position); reusableBuffer.flip(); // Add an extra 4 to account for the operation size integer itself final int size = reusableBuffer.getInt() + 4; final long maxSize = sizeInBytes() - position; if (size < 0 || size > maxSize) { throw new TranslogCorruptedException( "operation size is corrupted must be [0.." + maxSize + "] but was: " + size); } return size; } catch (IOException e) { throw new ElasticsearchException( "unexpected exception reading from translog snapshot of " + this.channelReference.getPath(), e); } }
public void send(byte[] d) throws IOException { ByteBuffer send = ByteBuffer.allocate(messageSize + 4); send.clear(); if (d.length + send.position() > send.capacity()) { out("!!!!!: Cant not send message, message length greater than max buffer size"); throw new RuntimeException( "!!!!!: Cant not send message, message length greater than max buffer size. capacity:" + send.capacity() + " , position:" + send.position() + "," + " data size:" + d.length); } if (this.pad) { send.putInt(d.length); } send.put(d); send.flip(); while (send.hasRemaining()) // write to channel { int bw = ssc.write(send); // out("bytes written: "+bw + " remaining: "+send.hasRemaining() +" r:"+send.position()+" v // "+send.limit()); } }
// Writes a C string and expands the frame if necessary // FIXME: Property strings containing nul ('\0') characters will corrupt the frame when they are // written. // Figure out how to throw an exception here if any nul chars are encountered private static ByteBuffer writeCString(ByteBuffer frame, String string) { Byte b = propertyAbbreviations.get(string); if (b != null) { if (frame.remaining() < 2) frame = ByteBuffer.allocate(frame.capacity() << 1).put((ByteBuffer) frame.rewind()); frame.put(b); frame.put((byte) 0); } else { CharsetEncoder cStringEncoder = cStringCharset.newEncoder(); CharBuffer chars = CharBuffer.wrap(string); for (int size = frame.capacity(); ; cStringEncoder.flush(frame)) { cStringEncoder.reset(); if (cStringEncoder.encode(chars, frame, true) == CoderResult.OVERFLOW) { // debug output // System.out.println("overflow, reallocating to size " + (size << 1) + " (printing \"" + // string + "\")"); frame = ByteBuffer.allocate(size = (size << 1)).put((ByteBuffer) frame.rewind()); } else break; } cStringEncoder.flush(frame); frame.put((byte) 0); } return frame; }
/** Copy the required number of bytes into the save buffer. */ private void copyToSaveBuffer(int bytesNeeded) { /* How much can we get from this current read buffer? */ int bytesFromThisBuffer; if (bytesNeeded <= window.remaining()) { bytesFromThisBuffer = bytesNeeded; } else { bytesFromThisBuffer = window.remaining(); } /* Gather it all into this save buffer. */ ByteBuffer temp; /* Make sure the save buffer is big enough. */ if (saveBuffer.capacity() - threadSafeBufferPosition(saveBuffer) < bytesFromThisBuffer) { /* Grow the save buffer. */ temp = ByteBuffer.allocate(saveBuffer.capacity() + bytesFromThisBuffer); threadSafeBufferFlip(saveBuffer); temp.put(saveBuffer); saveBuffer = temp; } /* * Bulk copy only the required section from the read buffer into the * save buffer. We need from readBuffer.position() to * readBuffer.position() + bytesFromThisBuffer */ temp = window.getBuffer().slice(); temp.limit(bytesFromThisBuffer); saveBuffer.put(temp); window.incrementBufferPosition(bytesFromThisBuffer); }
/** * Change the read buffer size if we start hitting large log entries so we don't get into an * expensive cycle of multiple reads and piecing together of log entries. */ protected void adjustReadBufferSize(int amountToRead) { int readBufferSize = readBuffer.capacity(); /* * We need to read something larger than the current buffer * size. */ if (amountToRead > readBufferSize) { /* We're not at the max yet. */ if (readBufferSize < maxReadBufferSize) { /* * Make the buffer the minimum of amountToRead or a * maxReadBufferSize. */ if (amountToRead < maxReadBufferSize) { readBufferSize = amountToRead; /* Make it a multiple of 1K. */ int remainder = readBufferSize % 1024; readBufferSize += 1024 - remainder; readBufferSize = Math.min(readBufferSize, maxReadBufferSize); } else { readBufferSize = maxReadBufferSize; } readBuffer = ByteBuffer.allocate(readBufferSize); } if (amountToRead > readBuffer.capacity()) { nRepeatIteratorReads++; } } }
/** * Write a chunk of bytes to the underyling ByteBuffer via this OutputStream. * * @param bytes Write bytes from this byte array. * @param off Start reading at this offset within byte array. * @param len Write this many bytes, and enlarge underyling ByteBuffer when necessary, preserving * the contents. */ @Override public synchronized void write(byte[] bytes, int off, int len) throws IOException { if (mBuffer.position() + len > mBuffer.capacity()) { expand(mBuffer.capacity() + len); } mBuffer.put(bytes, off, len); }
/** * Write one byte to the underlying ByteBuffer via this OutputStream. * * @param b Byte to be written. */ @Override public synchronized void write(int b) throws IOException { if (mBuffer.position() + 1 > mBuffer.capacity()) { expand(mBuffer.capacity() + 1); } mBuffer.put((byte) b); }
@Override public boolean processed() { if (position() != mByteBuffer.capacity() - mSharedByteBuffer.capacity()) { return false; } return true; }
/** Helper method for implementing {@link MessageLite#equals()} for bytes field. */ public static boolean equalsByteBuffer(ByteBuffer a, ByteBuffer b) { if (a.capacity() != b.capacity()) { return false; } // ByteBuffer.equals() will only compare the remaining bytes, but we want to // compare all the content. return a.duplicate().clear().equals(b.duplicate().clear()); }
/** * Before parsing the bytes, initialize and prepare the algorithm. * * @param byteBuffer the <code>ByteBuffer</code> used by this algorithm * @return <code>ByteBuffer</code> used by this algorithm */ public ByteBuffer preParse(ByteBuffer byteBuffer) { if (byteBuffer.position() == byteBuffer.capacity()) { // Add space at the end for \n\r int bufferSize = contentLength > 0 ? contentLength + headerLength + 5 : byteBuffer.capacity() * 2; byteBuffer = swapBuffer(byteBuffer, bufferSize); } return byteBuffer; }
/** * Method tryReadPacket2. * * @param key SelectionKey * @param con MMOConnection<T> * @param buf ByteBuffer * @return boolean */ protected boolean tryReadPacket2(SelectionKey key, MMOConnection<T> con, ByteBuffer buf) { if (con.isClosed()) { return false; } int pos = buf.position(); if (buf.remaining() > _sc.HEADER_SIZE) { int size = buf.getShort() & 0xffff; if ((size <= _sc.HEADER_SIZE) || (size > _sc.PACKET_SIZE)) { _log.error( "Incorrect packet size : " + size + "! Client : " + con.getClient() + ". Closing connection."); closeConnectionImpl(con); return false; } size -= _sc.HEADER_SIZE; if (size <= buf.remaining()) { stats.increaseIncomingPacketsCount(); parseClientPacket(getPacketHandler(), buf, size, con); buf.position(pos + size + _sc.HEADER_SIZE); if (!buf.hasRemaining()) { freeBuffer(buf, con); return false; } return true; } buf.position(pos); } if (pos == buf.capacity()) { _log.warn( "Read buffer exhausted for client : " + con.getClient() + ", try to adjust buffer size, current : " + buf.capacity() + ", primary : " + (buf == READ_BUFFER) + "."); } if (buf == READ_BUFFER) { allocateReadBuffer(con); } else { buf.compact(); } return false; }
/** * Serialize the Transaction to a ByteBuffer. * * <ol> * <li><strong>lockSize</strong> - position 0 * <li><strong>locks</strong> - position 4 * <li><strong>writes</strong> - position 4 + lockSize * </ol> * * @return the ByteBuffer representation */ private ByteBuffer serialize() { ByteBuffer _locks = ByteableCollections.toByteBuffer(locks.values()); ByteBuffer _writes = ByteableCollections.toByteBuffer(((Queue) buffer).getWrites()); ByteBuffer bytes = ByteBuffer.allocate(4 + _locks.capacity() + _writes.capacity()); bytes.putInt(_locks.capacity()); bytes.put(_locks); bytes.put(_writes); bytes.rewind(); return bytes; }