private String getDiskStoreIdFromInitFile(File dir, String fileName) throws FileNotFoundException, IOException { FileInputStream fis = new FileInputStream(new File(dir, fileName)); try { byte[] bytes = new byte[1 + 8 + 8]; fis.read(bytes); ByteBuffer buffer = ByteBuffer.wrap(bytes); // Skip the record type. buffer.get(); long least = buffer.getLong(); long most = buffer.getLong(); UUID id = new UUID(most, least); return id.toString(); } finally { fis.close(); } }
public static void main(String[] args) { Path file = Paths.get(System.getProperty("user.home") + "/test/myfile.txt"); try (SeekableByteChannel sbc = Files.newByteChannel(file)) { // |\longremark{newByteChannel默认返回只读的Channel}| ByteBuffer buf = ByteBuffer.allocate(10); // |\longremark{allocate创建一个指定字节的ByteBuffer,本例中,sbc这个Channel每次读取10个字节}| String encoding = System.getProperty("file.encoding"); // |\longremark{获得当前系统文件编码方式,以便读取文件字节后解码}| while (sbc.read(buf) > 0) { // |\longremark{从通道读数据到缓冲区}| buf.flip(); // |\longremark{切换缓冲区为读模式}| System.out.print(Charset.forName(encoding).decode(buf)); buf.clear(); // |\longremark{清空缓冲区,准备写入下一轮数据}| } } catch (IOException x) { System.out.println("caught exception: " + x); } }
private static Object parseCharArray(int length, ByteBuffer buf, ConstantPool constPool) { char[] result = new char[length]; boolean typeMismatch = false; byte tag = 0; for (int i = 0; i < length; i++) { tag = buf.get(); if (tag == 'C') { int index = buf.getShort() & 0xFFFF; result[i] = (char) constPool.getIntAt(index); } else { skipMemberValue(tag, buf); typeMismatch = true; } } return typeMismatch ? exceptionProxy(tag) : result; }
@Override protected void init(ByteBuffer buffer) { super.init(buffer); for (Chunk chunk : getChunks().values()) { if (chunk instanceof TypeChunk) { TypeChunk typeChunk = (TypeChunk) chunk; types.put(typeChunk.getId(), typeChunk); } else if (chunk instanceof TypeSpecChunk) { TypeSpecChunk typeSpecChunk = (TypeSpecChunk) chunk; typeSpecs.put(typeSpecChunk.getId(), typeSpecChunk); } else if (chunk instanceof StringPoolChunk) { continue; } else if (chunk instanceof LibraryChunk) { LibraryChunk libraryChunk = (LibraryChunk) chunk; libraries.add(libraryChunk); } else { throw new IllegalStateException(String.format("PackageChunk contains an unexpected chunk: %s", chunk.getClass())); } } }
/** * Save the encoded (output) buffer into the complete encoded recording. * TODO: copy directly (without the intermediate byte array) */ @TargetApi(Build.VERSION_CODES.JELLY_BEAN) private void dequeueOutputBuffer(MediaCodec codec, ByteBuffer[] outputBuffers, int index, MediaCodec.BufferInfo info) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) { ByteBuffer buffer = outputBuffers[index]; Log.i("size/remaining: " + info.size + "/" + buffer.remaining()); if (info.size <= buffer.remaining()) { final byte[] bufferCopied = new byte[info.size]; buffer.get(bufferCopied); // TODO: catch BufferUnderflow // TODO: do we need to clear? // on N5: always size == remaining(), clearing is not needed // on SGS2: remaining decreases until it becomes less than size, which results in BufferUnderflow // (but SGS2 records only zeros anyway) //buffer.clear(); codec.releaseOutputBuffer(index, false); addEncoded(bufferCopied); if (Log.DEBUG) { AudioUtils.showSomeBytes("out", bufferCopied); } } else { Log.e("size > remaining"); codec.releaseOutputBuffer(index, false); } } }
@Override public void run() { ByteBuffer buffer = ByteBuffer.allocate(Options.getInstance().bufferSize); while (running) { try { selector.select(); Set selectedKeys = selector.selectedKeys(); for (Object selectedKey : selectedKeys) { SelectionKey key = (SelectionKey) selectedKey; SocketChannel channel = (SocketChannel) key.channel(); channel.read(buffer); //TODO } } catch (IOException e) { Lg.e(Error.READER, e); } } }
public static void writeImageDescriptor(ByteBuffer out, int imageLeft, int imageTop, int imageWidth, int imageHeight, boolean hasLct, int numColors) { verifyRemaining(out, IMAGE_DESCRIPTOR_LENGTH); verifyShortValues(imageLeft, imageTop, imageWidth, imageHeight); final byte packed; if (hasLct) { int size = log2(numColors) - 1; packed = (byte) (0x80 | size); } else { packed = 0x00; } // Image separator out.put((byte) 0x2C); out.putShort((short) imageLeft).putShort((short) imageTop).putShort((short) imageWidth) .putShort((short) imageHeight).put(packed); }
public int compare(ByteBuffer buffer1, byte[] buffer2, int offset2, int length2) { Object obj1; long offset1; if (buffer1.hasArray()) { obj1 = buffer1.array(); offset1 = BYTE_ARRAY_BASE_OFFSET + buffer1.arrayOffset(); } else { obj1 = null; offset1 = THE_UNSAFE.getLong(buffer1, DIRECT_BUFFER_ADDRESS_OFFSET); } int length1; { int position = buffer1.position(); int limit = buffer1.limit(); length1 = limit - position; offset1 += position; } return compareTo(obj1, offset1, length1, buffer2, BYTE_ARRAY_BASE_OFFSET + offset2, length2); }
/** * Calculate checkSum over the Page * * @param page */ private void calculateChecksumOverPage(ByteBuffer page) { //CRC should be zero before calculating it page.putInt(OggPageHeader.FIELD_PAGE_CHECKSUM_POS, 0); //Compute CRC over the page //TODO shouldnt really use array(); byte[] crc = OggCRCFactory.computeCRC(page.array()); for (int i = 0; i < crc.length; i++) { page.put(OggPageHeader.FIELD_PAGE_CHECKSUM_POS + i, crc[i]); } //Rewind to start of Page page.rewind(); }
/** * testGetParameterSet */ public void testGetParameterSet() throws Exception { StoredProcedureInvocation invocation = new StoredProcedureInvocation(CLIENT_HANDLE, TARGET_PROCEDURE, PARAMS); byte[] invocation_bytes = FastSerializer.serialize(invocation); assertNotNull(invocation_bytes); ByteBuffer buffer = ByteBuffer.wrap(invocation_bytes); ByteBuffer paramsBuffer = StoredProcedureInvocation.getParameterSet(buffer); assertNotNull(paramsBuffer); ParameterSet cloneParams = new ParameterSet(); FastDeserializer fds = new FastDeserializer(paramsBuffer); cloneParams.readExternal(fds); assertEquals(PARAMS.length, cloneParams.size()); for (int i = 0; i < PARAMS.length; i++) { assertEquals(PARAMS[i], cloneParams.toArray()[i]); } }
/** Returns a sliced view from a set of already-existing buffers: * the last buffer's limit() will be correct, but * you must deal with offset separately (the first buffer will not be adjusted) */ private ByteBuffer[] buildSlice(ByteBuffer[] buffers, long offset, long length) { final long sliceEnd = offset + length; final int startIndex = (int) (offset >>> chunkSizePower); final int endIndex = (int) (sliceEnd >>> chunkSizePower); // we always allocate one more slice, the last one may be a 0 byte one final ByteBuffer slices[] = new ByteBuffer[endIndex - startIndex + 1]; for (int i = 0; i < slices.length; i++) { slices[i] = buffers[startIndex + i].duplicate(); } // set the last buffer's limit for the sliced view. slices[slices.length - 1].limit((int) (sliceEnd & chunkSizeMask)); return slices; }
@Override public ResourcePool transform(ResourcePool in, ResourcePoolBuilder out) { in.transformAndCopy((resource) -> { ResourcePoolEntry res = resource; if (resource.type().equals(ResourcePoolEntry.Type.CLASS_OR_RESOURCE) && predicate.test(resource.path())) { byte[] compressed; compressed = compress(resource.contentBytes()); res = ResourcePoolManager.newCompressedResource(resource, ByteBuffer.wrap(compressed), getName(), null, ((ResourcePoolImpl)in).getStringTable(), in.byteOrder()); } return res; }, out); return out.build(); }
@Test public void testArrayBackedBufferSlice() throws IOException { byte[] compressed = compressedBytes(); int sliceOffset = 12; ByteBuffer buffer = ByteBuffer.allocate(compressed.length + sliceOffset + 123); buffer.position(sliceOffset); buffer.put(compressed).flip(); buffer.position(sliceOffset); ByteBuffer slice = buffer.slice(); testDecompression(slice); int offset = 42; buffer = ByteBuffer.allocate(compressed.length + sliceOffset + offset); buffer.position(sliceOffset + offset); buffer.put(compressed).flip(); buffer.position(sliceOffset); slice = buffer.slice(); slice.position(offset); testDecompression(slice); }
/** * 生成flv medadata 数据 * @param width 视频宽度 * @param height 视频高度 * @param fps 视频帧率 * @param audioRate 音频采样率 * @param audioSize 音频大小 * @param isStereo 音频是否为立体声 * @return byte数组 */ public static byte[] writeFlvMetaData(int width, int height, int fps, int audioRate, int audioSize, boolean isStereo) { AmfString metaDataHeader = new AmfString("onMetaData", false); AmfMap amfMap = new AmfMap(); amfMap.setProperty("width", width); amfMap.setProperty("height", height); amfMap.setProperty("framerate", fps); amfMap.setProperty("videocodecid", FlvVideoCodecID.AVC); amfMap.setProperty("audiosamplerate", audioRate); amfMap.setProperty("audiosamplesize", audioSize); if(isStereo) { amfMap.setProperty("stereo", true); } else { amfMap.setProperty("stereo", false); } amfMap.setProperty("audiocodecid", FlvAudio.AAC); int size = amfMap.getSize() + metaDataHeader.getSize(); ByteBuffer amfBuffer = ByteBuffer.allocate(size); amfBuffer.put(metaDataHeader.getBytes()); amfBuffer.put(amfMap.getBytes()); return amfBuffer.array(); }
private static void addHeader(ByteBuffer result, String key, List<String> values) { StringBuilder sb = new StringBuilder(); Iterator<String> iter = values.iterator(); if (!iter.hasNext()) { return; } sb.append(iter.next()); while (iter.hasNext()) { sb.append(','); sb.append(iter.next()); } result.put(key.getBytes(StandardCharsets.ISO_8859_1)); result.put(": ".getBytes(StandardCharsets.ISO_8859_1)); result.put(sb.toString().getBytes(StandardCharsets.ISO_8859_1)); result.put(crlf); }
/** * Encodes the CertGenerationRequest extended operation. * * @return A ByteBuffer that contains the encoded PDU * @throws org.apache.directory.api.asn1.EncoderException If anything goes wrong. */ /* no qualifier */ByteBuffer encodeInternal() throws EncoderException { // Allocate the bytes buffer. ByteBuffer bb = ByteBuffer.allocate( computeLengthInternal() ); bb.put( UniversalTag.SEQUENCE.getValue() ); bb.put( TLV.getBytes( requestLength ) ); BerValue.encode( bb, certGenerationRequest.getTargetDN() ); BerValue.encode( bb, certGenerationRequest.getIssuerDN() ); BerValue.encode( bb, certGenerationRequest.getSubjectDN() ); BerValue.encode( bb, certGenerationRequest.getKeyAlgorithm() ); return bb; }
/** * Compare two ByteBuffer at specified offsets for length. * Compares the non equal bytes as unsigned. * * @param bytes1 First byte buffer to compare. * @param offset1 Position to start the comparison at in the first array. * @param bytes2 Second byte buffer to compare. * @param offset2 Position to start the comparison at in the second array. * @param length How many bytes to compare? * @return -1 if byte1 is less than byte2, 1 if byte2 is less than byte1 or 0 if equal. */ public static int compareSubArrays(ByteBuffer bytes1, int offset1, ByteBuffer bytes2, int offset2, int length) { if (bytes1 == null) { return bytes2 == null ? 0 : -1; } if (bytes2 == null) { return 1; } assert bytes1.limit() >= offset1 + length : "The first byte array isn't long enough for the specified offset and length."; assert bytes2.limit() >= offset2 + length : "The second byte array isn't long enough for the specified offset and length."; for (int i = 0; i < length; i++) { byte byte1 = bytes1.get(offset1 + i); byte byte2 = bytes2.get(offset2 + i); // compare non-equal bytes as unsigned if (byte1 != byte2) { return (byte1 & 0xFF) < (byte2 & 0xFF) ? -1 : 1; } } return 0; }
@Override public ByteBuffer getByteBuffer(long offset, int size) throws IOException { if (size < 0) { throw new IndexOutOfBoundsException("size: " + size); } ByteBuffer result = ByteBuffer.allocate(size); copyTo(offset, size, result); result.flip(); return result; }
@Override public byte[] serialize() { int valueLength = OUI_LENGTH + SUBTYPE_LENGTH + infoString.length; value = new byte[valueLength]; ByteBuffer bb = ByteBuffer.wrap(value); bb.put(oui); bb.put(subType); bb.put(infoString); return super.serialize(); }
ReadTask(ByteBuffer dst, int pos, int rem, long position, PendingFuture<Integer,A> result) { this.dst = dst; this.pos = pos; this.rem = rem; this.position = position; this.result = result; }
@Override public void initializeApplication(ApplicationInitializationContext context) { ByteBuffer data = context.getApplicationDataForService(); assertEquals(idef, data.getChar()); assertEquals(expected_appId, data.getInt()); assertEquals(expected_appId, context.getApplicationId().getId()); }
@Test(expected = IOException.class) public void doWriteToSocketDoesNotCatchExceptionFromSocket() throws IOException { // given when(socketMock.write(ArgumentMatchers.any(ByteBuffer.class))).thenThrow(IOException.class); SessionImpl target = new SessionImpl(selectorMock); target.write("Hello World!".getBytes()); // when/then target.doWriteToSocket(socketMock); }
@Override public void create( final int[] dicIndexArray , final byte[] buffer , final int start , final int length ) throws IOException{ ByteBuffer wrapBuffer = ByteBuffer.wrap( buffer , start , length ); for( int index : dicIndexArray ){ wrapBuffer.putShort( (short)index ); } }
private ChannelListener<StreamConnection> createOpenListener(final ClientCallback<ClientConnection> listener, final URI uri, final XnioSsl ssl, final Pool<ByteBuffer> bufferPool, final OptionMap options) { return new ChannelListener<StreamConnection>() { @Override public void handleEvent(StreamConnection connection) { handleConnected(connection, listener, uri, ssl, bufferPool, options); } }; }
private static ByteBuffer decode(ByteBuffer source) throws IOException { int len = source.remaining(); int remainder = len % 4; int size = ((len / 4) + (remainder == 0 ? 0 : 4 - remainder)) * 3; ByteBuffer buffer = ByteBuffer.allocate(size); createDecoder().decode(source, buffer); buffer.flip(); return buffer; }
@PostMapping @SuppressWarnings("all") public Mono<ResponseEntity<Object>> save(@RequestHeader("X-Block-Id") String blockId, @RequestBody Flux<ByteBuffer> blockFlux) { log.info("Block {}", blockId); return logsStorage.streamBlock(blockId, blockFlux) .map(res -> { if (res.getHttpCode() >= 200 && res.getHttpCode() < 300) { return noContent(); } else { return status(res.getHttpCode()); } }) .map(r -> r.build()) .onErrorResume(t -> Mono.just(status(INTERNAL_SERVER_ERROR).build())); }
/** * Gets a unsigned smart from the buffer. * * @param buffer The buffer. * @return The value. */ public static int getUnsignedSmart(ByteBuffer buf) { int peek = buf.get(buf.position()) & 0xFF; if (peek < 128) return buf.get() & 0xFF; else return (buf.getShort() & 0xFFFF) - 32768; }
public static DnsHeader FromBytes(ByteBuffer buffer) { DnsHeader header=new DnsHeader(buffer.array(),buffer.arrayOffset()+buffer.position()); header.ID=buffer.getShort(); header.Flags=DnsFlags.Parse(buffer.getShort()); header.QuestionCount=buffer.getShort(); header.ResourceCount=buffer.getShort(); header.AResourceCount=buffer.getShort(); header.EResourceCount=buffer.getShort(); return header; }
/** * Create a digest for a snapshot containing the time of the snapshot and the list of tables included. * The first item in the comma separated list is the time in milliseconds as a string. * @param snapshotTime * @param path * @param nonce * @param tables * @throws IOException */ public static void recordSnapshotTableList( long snapshotTime, String path, String nonce, List<Table> tables) throws IOException { final File f = new File(path, constructDigestFilenameForNonce(nonce)); if (f.exists()) { if (!f.delete()) { throw new IOException("Unable to write table list file " + f); } } FileOutputStream fos = new FileOutputStream(f); StringWriter sw = new StringWriter(); sw.append(Long.toString(snapshotTime)); if (!tables.isEmpty()) { sw.append(','); } for (int ii = 0; ii < tables.size(); ii++) { sw.append(tables.get(ii).getTypeName()); if (!(ii == (tables.size() - 1))) { sw.append(','); } else { sw.append('\n'); } } final byte tableListBytes[] = sw.getBuffer().toString().getBytes("UTF-8"); final CRC32 crc = new CRC32(); crc.update(tableListBytes); ByteBuffer fileBuffer = ByteBuffer.allocate(tableListBytes.length + 4); fileBuffer.putInt((int)crc.getValue()); fileBuffer.put(tableListBytes); fileBuffer.flip(); fos.getChannel().write(fileBuffer); fos.getFD().sync(); }
protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) { char[] sa = src.array(); int sp = src.arrayOffset() + src.position(); int sl = src.arrayOffset() + src.limit(); byte[] da = dst.array(); int dp = dst.arrayOffset() + dst.position(); int dl = dst.arrayOffset() + dst.limit(); try { while (sp < sl) { char c = sa[sp]; if (c <= '\u007f') return CoderResult.unmappableForLength(1); int ncode = encodeDouble(c); if (ncode != 0 && c != '\u0000' ) { da[dp++] = (byte) ((ncode >> 8) & 0x7f); da[dp++] = (byte) (ncode & 0x7f); sp++; continue; } return CoderResult.unmappableForLength(1); } return CoderResult.UNDERFLOW; } finally { src.position(sp - src.arrayOffset()); dst.position(dp - dst.arrayOffset()); } }
private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) { char[] sa = src.array(); int sp = src.arrayOffset() + src.position(); int sl = src.arrayOffset() + src.limit(); byte[] da = dst.array(); int dp = dst.arrayOffset() + dst.position(); int dl = dst.arrayOffset() + dst.limit(); CoderResult cr = CoderResult.UNDERFLOW; if ((dl - dp) < (sl - sp)) { sl = sp + (dl - dp); cr = CoderResult.OVERFLOW; } while (sp < sl) { char c = sa[sp]; int b = encode(c); if (b == UNMAPPABLE_ENCODING) { if (Character.isSurrogate(c)) { if (sgp == null) sgp = new Surrogate.Parser(); if (sgp.parse(c, sa, sp, sl) < 0) return withResult(sgp.error(), src, sp, dst, dp); return withResult(sgp.unmappableResult(), src, sp, dst, dp); } return withResult(CoderResult.unmappableForLength(1), src, sp, dst, dp); } da[dp++] = (byte)b; sp++; } return withResult(cr, src, sp, dst, dp); }
public ByteBufferBackedChannelBuffer(ByteBuffer buffer) { if (buffer == null) { throw new NullPointerException("buffer"); } this.buffer = buffer.slice(); capacity = buffer.remaining(); writerIndex(capacity); }
private void encodeByte(@NonNull OutputStream out, @NonNull ByteBuffer buffer) throws IOException { byte[] bytes = buffer.array(); if (bytes.length == 0) { throw new IOException("Input bytes is empty"); } String encodeBytes = String.format(Locale.getDefault(), "%d:", bytes.length); out.write(encodeBytes.getBytes("UTF-8")); out.write(bytes); }
@Override void putMyBytes(ByteBuffer buffer) { buffer.putLong(this.amountNQT); buffer.putInt(this.deadline); buffer.put(Escrow.decisionToByte(this.deadlineAction)); buffer.put(this.requiredSigners); byte totalSigners = (byte) this.signers.size(); buffer.put(totalSigners); for(Long id : this.signers) { buffer.putLong(id); } }
@Override public int read(ByteBuffer buf) throws IOException { checkStream(); if (pos < length) { int n = (int) Math.min(buf.remaining(), length - pos); if (n > 0) { buf.put(data, pos, n); } pos += n; return n; } return -1; }
public long read(ByteBuffer[] dsts, int offset, int length) throws IOException { if ((offset < 0) || (length < 0) || (offset > dsts.length - length)) throw new IndexOutOfBoundsException(); synchronized (readLock) { synchronized (stateLock) { ensureOpen(); if (!isConnected()) throw new NotYetConnectedException(); } long n = 0; try { begin(); if (!isOpen()) return 0; readerThread = NativeThread.current(); do { n = IOUtil.read(fd, dsts, offset, length, nd); } while ((n == IOStatus.INTERRUPTED) && isOpen()); return IOStatus.normalize(n); } finally { readerThread = 0; end((n > 0) || (n == IOStatus.UNAVAILABLE)); assert IOStatus.check(n); } } }
private LongToken getToken(ByteBuffer key, long[] hash) { if (key.remaining() == 0) return MINIMUM; return new LongToken(normalize(hash[0])); }
/** * Appends the value to a cell and checks that the cell value is updated properly. * * @throws Exception */ public static void doTestAppend() throws Exception { ThriftServerRunner.HBaseHandler handler = new ThriftServerRunner.HBaseHandler(UTIL.getConfiguration(), UserProvider.instantiate(UTIL.getConfiguration())); handler.createTable(tableAname, getColumnDescriptors()); try { List<Mutation> mutations = new ArrayList<Mutation>(1); mutations.add(new Mutation(false, columnAname, valueAname, true)); handler.mutateRow(tableAname, rowAname, mutations, null); List<ByteBuffer> columnList = new ArrayList<ByteBuffer>(); columnList.add(columnAname); List<ByteBuffer> valueList = new ArrayList<ByteBuffer>(); valueList.add(valueBname); TAppend append = new TAppend(tableAname, rowAname, columnList, valueList); handler.append(append); TRowResult rowResult = handler.getRow(tableAname, rowAname, null).get(0); assertEquals(rowAname, rowResult.row); assertArrayEquals(Bytes.add(valueAname.array(), valueBname.array()), rowResult.columns.get(columnAname).value.array()); } finally { handler.disableTable(tableAname); handler.deleteTable(tableAname); } }
/** * Decode/unescape a portion of a URL, to use with the query part ensure {@code plusAsBlank} is true. * * @param content the portion to decode * @param charset the charset to use * @param plusAsBlank if {@code true}, then convert '+' to space (e.g. for www-url-form-encoded content), otherwise leave as is. * @return encoded string */ private static String urldecode( final String content, final Charset charset, final boolean plusAsBlank) { if (content == null) { return null; } ByteBuffer bb = ByteBuffer.allocate(content.length()); CharBuffer cb = CharBuffer.wrap(content); while (cb.hasRemaining()) { char c = cb.get(); if (c == '%' && cb.remaining() >= 2) { char uc = cb.get(); char lc = cb.get(); int u = Character.digit(uc, 16); int l = Character.digit(lc, 16); if (u != -1 && l != -1) { bb.put((byte) ((u << 4) + l)); } else { bb.put((byte) '%'); bb.put((byte) uc); bb.put((byte) lc); } } else if (plusAsBlank && c == '+') { bb.put((byte) ' '); } else { bb.put((byte) c); } } bb.flip(); return charset.decode(bb).toString(); }
@Override public void parse(ReadableByteChannel dataSource, ByteBuffer header, long contentSize, BoxParser boxParser) throws IOException { initContainer(dataSource, contentSize, boxParser); for (AbstractBox box : this.getBoxes(AbstractBox.class)) { box.parseDetails(); } }