下面列出了java.nio.ByteBuffer#position ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Test
public void compress_with_direct_ByteBuffer_without_flushing() throws Exception {
ByteBuffer inBuffer = ByteBuffer.allocateDirect(A_BYTES.length);
inBuffer.put(A_BYTES);
inBuffer.position(0);
// when
ByteBuffer outBuffer = compressor.compressNext(inBuffer, false);
// then
assertThat(outBuffer.capacity()).isEqualTo(0);
// when
outBuffer = compressor.compressNext(ByteBuffer.allocateDirect(0), true);
// then
assertThat(outBuffer.capacity()).isEqualTo(A_BYTES_COMPRESSED.length);
// then
assertThat(getByteArray(outBuffer)).startsWith(A_BYTES_COMPRESSED);
}
private void testGetMethods(ByteBuffer b) {
b.position(0);
b.get();
b.get(0);
b.get(new byte[1]);
b.get(new byte[1], 0, 1);
b.getChar();
b.getChar(0);
b.position(0);
b.getDouble();
b.getDouble(0);
b.position(0);
b.getFloat();
b.getFloat(0);
b.getInt();
b.getInt(0);
b.position(0);
b.getLong();
b.getLong(0);
b.position(0);
b.getShort();
b.getShort(0);
}
private void combination_12(List<byte[]> results, int mode, byte[] AAD,
byte[] plainText, AlgorithmParameters params) throws Exception {
// prepare ByteBuffer to test
ByteBuffer buf = ByteBuffer.allocate(AAD.length);
buf.put(AAD);
buf.position(0);
buf.limit(AAD.length);
Cipher ci = createCipher(mode, params);
ci.updateAAD(buf);
// prepare an empty ByteBuffer
ByteBuffer emptyBuf = ByteBuffer.allocate(0);
emptyBuf.put(new byte[0]);
ci.updateAAD(emptyBuf);
byte[] part12_1 = new byte[ci.getOutputSize(plainText.length)];
int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
int len12 = ci.update(plainText, 0, plainText.length - offset,
part12_1, 0);
int rest12 = ci.doFinal(plainText, plainText.length - offset, offset,
part12_1, len12);
byte[] outputText12 = new byte[len12 + rest12];
System.arraycopy(part12_1, 0, outputText12, 0, outputText12.length);
results.add(outputText12);
}
/**
* Does the decryption using inBuffer as input and outBuffer as output. Upon
* return, inBuffer is cleared; the decrypted data starts at
* outBuffer.position() and ends at outBuffer.limit().
*
* @param state the CipherState instance.
* @param inByteBuffer the input buffer.
* @param outByteBuffer the output buffer.
* @param padding the padding.
* @throws IOException if an I/O error occurs.
*/
private void decrypt(final CipherState state, final ByteBuffer inByteBuffer,
final ByteBuffer outByteBuffer, final byte padding) throws IOException {
Utils.checkState(inByteBuffer.position() >= padding);
if (inByteBuffer.position() == padding) {
// There is no real data in inBuffer.
return;
}
inByteBuffer.flip();
outByteBuffer.clear();
decryptBuffer(state, inByteBuffer, outByteBuffer);
inByteBuffer.clear();
outByteBuffer.flip();
if (padding > 0) {
/*
* The plain text and cipher text have a 1:1 mapping, they start at
* the same position.
*/
outByteBuffer.position(padding);
}
}
private byte[] computeMd5Hash(DirectByteBuffer buffer)
{
BrokenMd5Hasher md5 = new BrokenMd5Hasher();
md5.reset();
final int position = buffer.position(DirectByteBuffer.SS_DW);
md5.update(buffer.getBuffer(DirectByteBuffer.SS_DW));
buffer.position(DirectByteBuffer.SS_DW, position);
ByteBuffer md5Result = ByteBuffer.allocate(16);
md5Result.position(0);
md5.finalDigest( md5Result );
final byte[] result =new byte[16];
md5Result.position(0);
for (int i =0; i <result.length; i++ )
{
result[i] = md5Result.get();
}
return result;
}
/**
* Returns a byte buffer whose length is lesser than or equal to truncateLength and is greater than the given input
*/
public static Literal<ByteBuffer> truncateBinaryMax(Literal<ByteBuffer> input, int length) {
ByteBuffer inputBuffer = input.value();
if (length >= inputBuffer.remaining()) {
return input;
}
// Truncate the input to the specified truncate length.
ByteBuffer truncatedInput = truncateBinary(inputBuffer, length);
// Try incrementing the bytes from the end. If all bytes overflow after incrementing, then return null
for (int i = length - 1; i >= 0; --i) {
byte element = truncatedInput.get(i);
element = (byte) (element + 1);
if (element != 0) { // No overflow
truncatedInput.put(i, element);
// Return a byte buffer whose position is zero and limit is i + 1
truncatedInput.position(0);
truncatedInput.limit(i + 1);
return Literal.of(truncatedInput);
}
}
return null; // Cannot find a valid upper bound
}
private int receiveIntoNativeBuffer(FileDescriptor fd, ByteBuffer bb,
int rem, int pos)
throws IOException
{
int n = receive0(fd, ((DirectBuffer)bb).address() + pos, rem,
isConnected());
if (n > 0)
bb.position(pos + n);
return n;
}
private int send(int fd,
ByteBuffer src,
int assocId,
SocketAddress target,
MessageInfo messageInfo)
throws IOException {
int streamNumber = messageInfo.streamNumber();
boolean unordered = messageInfo.isUnordered();
int ppid = messageInfo.payloadProtocolID();
if (src instanceof DirectBuffer)
return sendFromNativeBuffer(fd, src, target, assocId,
streamNumber, unordered, ppid);
/* Substitute a native buffer */
int pos = src.position();
int lim = src.limit();
assert (pos <= lim && streamNumber >= 0);
int rem = (pos <= lim ? lim - pos : 0);
ByteBuffer bb = Util.getTemporaryDirectBuffer(rem);
try {
bb.put(src);
bb.flip();
/* Do not update src until we see how many bytes were written */
src.position(pos);
int n = sendFromNativeBuffer(fd, bb, target, assocId,
streamNumber, unordered, ppid);
if (n > 0) {
/* now update src */
src.position(pos + n);
}
return n;
} finally {
Util.releaseTemporaryDirectBuffer(bb);
}
}
@Override
protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) {
char[] sa = src.array();
int sp = src.arrayOffset() + src.position();
int sl = src.arrayOffset() + src.limit();
assert (sp <= sl);
sp = (sp <= sl ? sp : sl);
byte[] da = dst.array();
int dp = dst.arrayOffset() + dst.position();
int dl = dst.arrayOffset() + dst.limit();
assert (dp <= dl);
dp = (dp <= dl ? dp : dl);
try {
while (sp < sl) {
char c = sa[sp];
if (dl - dp < 1)
return CoderResult.OVERFLOW;
if (!canEncode(c))
return CoderResult.unmappableForLength(1);
sp++;
da[dp++] = table[c - 0x2700];
}
return CoderResult.UNDERFLOW;
} finally {
src.position(sp - src.arrayOffset());
dst.position(dp - dst.arrayOffset());
}
}
/**
* Get the minor version number from the given ByteBuffer.
*
* @return int - the minor version
*/
public static int getMinorVersion(ByteBuffer bb) {
// save buffer state
int position = bb.position();
bb.position(PERFDATA_PROLOG_MINOR_OFFSET);
int minor = (int)bb.get();
// restore buffer state.
bb.position(position);
return minor;
}
private void handleNHSG(Client client, ByteBuffer data) {
byte dataCopy[] = new byte[data.limit()];
data.rewind();
data.get(dataCopy);
data = ByteBuffer.wrap(dataCopy);
client.getClientData().getNativeHeapData().addHeapData(data);
if (true) {
return;
}
byte[] copy = new byte[data.limit()];
data.get(copy);
ByteBuffer buffer = ByteBuffer.wrap(copy);
buffer.order(ByteOrder.BIG_ENDIAN);
int id = buffer.getInt();
int unitsize = buffer.get();
long startAddress = buffer.getInt() & 0x00000000ffffffffL;
int offset = buffer.getInt();
int allocationUnitCount = buffer.getInt();
// read the usage
while (buffer.position() < buffer.limit()) {
int eState = buffer.get() & 0x000000ff;
int eLen = (buffer.get() & 0x000000ff) + 1;
}
}
private void combination_14(List<byte[]> results, int mode, byte[] AAD,
byte[] plainText, AlgorithmParameters params) throws Exception {
Cipher c = createCipher(mode, params);
// prepare ByteBuffer to test
ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
buf.put(AAD);
// process the first half of AAD data
buf.position(0);
buf.limit(AAD.length / 2);
c.updateAAD(buf);
// process the rest of AAD data
buf.limit(AAD.length);
c.updateAAD(buf);
// prepare buffers to encrypt/decrypt
ByteBuffer in = ByteBuffer.allocate(plainText.length);
in.put(plainText);
in.position(0);
in.limit(plainText.length);
ByteBuffer out = ByteBuffer.allocate(c.getOutputSize(in.limit()));
out.position(0);
out.limit(c.getOutputSize(in.limit()));
// process input text
c.update(in, out);
c.doFinal(in, out);
int resultSize = out.position();
byte[] result14 = new byte[resultSize];
out.position(0);
out.limit(resultSize);
out.get(result14, 0, resultSize);
results.add(result14);
}
private int calculateHmac(int baseNonce, int networkKey){
ByteBuffer key = ByteBuffer.allocate(8);
key.order(ByteOrder.LITTLE_ENDIAN);
key.putInt(baseNonce);
key.putInt(networkKey);
ByteBuffer buf = packet.duplicate();
buf.position(0);
return generateHmac(buf, PACKET_LEN-4, key).getInt();
}
public void writeSampleData(SampleType sampleType, ByteBuffer byteBuf, MediaCodec.BufferInfo bufferInfo) {
if (mStarted) {
mMuxer.writeSampleData(getTrackIndexForSampleType(sampleType), byteBuf, bufferInfo);
return;
}
byteBuf.limit(bufferInfo.offset + bufferInfo.size);
byteBuf.position(bufferInfo.offset);
if (mByteBuffer == null) {
mByteBuffer = ByteBuffer.allocate(MediaUtil.BUFFER_SIZE);
}
mByteBuffer.put(byteBuf);
mSampleInfoList.add(new SampleInfo(sampleType, bufferInfo.size, bufferInfo));
}
/** Jumps ahead by string */
public void delta(String string){
ByteBuffer buf = fsa.encode(string);
Maps m = fsa.map();
while (state >0 && buf.position()<buf.limit()){
delta(m, buf.get());
}
}
public static int skip(ByteBuffer buffer, int count) {
int toSkip = Math.min(buffer.remaining(), count);
buffer.position(buffer.position() + toSkip);
return toSkip;
}
@Override
public void queueInput(ByteBuffer inputBuffer) {
// Prepare the output buffer.
int position = inputBuffer.position();
int limit = inputBuffer.limit();
int size = limit - position;
int resampledSize;
switch (inputAudioFormat.encoding) {
case C.ENCODING_PCM_8BIT:
resampledSize = size * 2;
break;
case C.ENCODING_PCM_24BIT:
resampledSize = (size / 3) * 2;
break;
case C.ENCODING_PCM_32BIT:
resampledSize = size / 2;
break;
case C.ENCODING_PCM_16BIT:
case C.ENCODING_PCM_FLOAT:
case C.ENCODING_PCM_A_LAW:
case C.ENCODING_PCM_MU_LAW:
case C.ENCODING_INVALID:
case Format.NO_VALUE:
default:
throw new IllegalStateException();
}
// Resample the little endian input and update the input/output buffers.
ByteBuffer buffer = replaceOutputBuffer(resampledSize);
switch (inputAudioFormat.encoding) {
case C.ENCODING_PCM_8BIT:
// 8->16 bit resampling. Shift each byte from [0, 256) to [-128, 128) and scale up.
for (int i = position; i < limit; i++) {
buffer.put((byte) 0);
buffer.put((byte) ((inputBuffer.get(i) & 0xFF) - 128));
}
break;
case C.ENCODING_PCM_24BIT:
// 24->16 bit resampling. Drop the least significant byte.
for (int i = position; i < limit; i += 3) {
buffer.put(inputBuffer.get(i + 1));
buffer.put(inputBuffer.get(i + 2));
}
break;
case C.ENCODING_PCM_32BIT:
// 32->16 bit resampling. Drop the two least significant bytes.
for (int i = position; i < limit; i += 4) {
buffer.put(inputBuffer.get(i + 2));
buffer.put(inputBuffer.get(i + 3));
}
break;
case C.ENCODING_PCM_16BIT:
case C.ENCODING_PCM_FLOAT:
case C.ENCODING_PCM_A_LAW:
case C.ENCODING_PCM_MU_LAW:
case C.ENCODING_INVALID:
case Format.NO_VALUE:
default:
// Never happens.
throw new IllegalStateException();
}
inputBuffer.position(inputBuffer.limit());
buffer.flip();
}
/**
* Decodes one Base64 byte buffer into another. This method will return and save state
* if the target does not have the required capacity. Subsequent calls with a new target will
* resume reading where it last left off (the source buffer's position). Similarly not all of the
* source data need be available, this method can be repetitively called as data is made available.
*
* <p>The decoder will skip white space, but will error if it detects corruption.</p>
*
* @param source the byte buffer to read encoded data from
* @param target the byte buffer to write decoded data to
* @throws IOException if the encoded data is corrupted
*/
public void decode(ByteBuffer source, ByteBuffer target) throws IOException {
if (target == null)
throw new IllegalStateException();
int last = this.last;
int state = this.state;
int remaining = source.remaining();
int targetRemaining = target.remaining();
int b = 0;
while (remaining-- > 0 && targetRemaining > 0) {
b = nextByte(source, state, last, false);
if (b == MARK) {
last = MARK;
if (--remaining <= 0) {
break;
}
b = nextByte(source, state, last, false);
}
if (b == DONE) {
last = state = 0;
break;
}
if (b == SKIP) {
continue;
}
// ( 6 | 2) (4 | 4) (2 | 6)
if (state == 0) {
last = b << 2;
state++;
if (remaining-- <= 0) {
break;
}
b = nextByte(source, state, last, false);
if ((b & 0xF000) != 0) {
source.position(source.position() - 1);
continue;
}
}
if (state == 1) {
target.put((byte)(last | (b >>> 4)));
last = (b & 0x0F) << 4;
state++;
if (remaining-- <= 0 || --targetRemaining <= 0) {
break;
}
b = nextByte(source, state, last, false);
if ((b & 0xF000) != 0) {
source.position(source.position() - 1);
continue;
}
}
if (state == 2) {
target.put((byte) (last | (b >>> 2)));
last = (b & 0x3) << 6;
state++;
if (remaining-- <= 0 || --targetRemaining <= 0) {
break;
}
b = nextByte(source, state, last, false);
if ((b & 0xF000) != 0) {
source.position(source.position() - 1);
continue;
}
}
if (state == 3) {
target.put((byte)(last | b));
last = state = 0;
targetRemaining--;
}
}
if (remaining > 0) {
drain(source, b, state, last);
}
this.last = last;
this.state = state;
this.lastPos = source.position();
}
public void configure(MetalBasic3DView view) {
// find a usable Device
device = view.getDevice();
// setup view with drawable formats
view.setDepthPixelFormat(MTLPixelFormat.Depth32Float);
view.setStencilPixelFormat(MTLPixelFormat.Invalid);
view.setSampleCount(1);
// create a new command queue
commandQueue = device.newCommandQueue();
defaultLibrary = device.newDefaultLibrary();
if (defaultLibrary == null) {
// If the shader libary isn't loading, nothing good will happen
throw new Error(">> ERROR: Couldnt create a default shader library");
}
preparePipelineState(view);
MTLDepthStencilDescriptor depthStateDesc = new MTLDepthStencilDescriptor();
depthStateDesc.setDepthCompareFunction(MTLCompareFunction.Less);
depthStateDesc.setDepthWriteEnabled(true);
depthState = device.newDepthStencilState(depthStateDesc);
// allocate a number of buffers in memory that matches the sempahore count so that
// we always have one self contained memory buffer for each buffered frame.
// In this case triple buffering is the optimal way to go so we cycle through 3 memory buffers
for (int i = 0; i < kInFlightCommandBuffers; i++) {
dynamicConstantBuffer[i] = device.newBuffer(maxBufferBytesPerFrame, MTLResourceOptions.CPUCacheModeDefaultCache);
dynamicConstantBuffer[i].setLabel("ConstantBuffer" + i);
// write initial color values for both cubes (at each offset).
// Note, these will get animated during update
ByteBuffer constant_buffer = dynamicConstantBuffer[i].getContents();
constant_buffer.order(ByteOrder.nativeOrder());
for (int j = 0; j < kNumberOfBoxes; j++) {
if (j % 2 == 0) {
constant_buffer.position((sizeOfConstantT * j) + ambientColorOffset);
BufferUtils.copy(kBoxAmbientColors[0], 0, 4, constant_buffer);
constant_buffer.position((sizeOfConstantT * j) + diffuseColorOffset);
BufferUtils.copy(kBoxDiffuseColors[0], 0, 4, constant_buffer);
constant_buffer.putInt((sizeOfConstantT * j) + multiplierOffset, 1);
} else {
constant_buffer.position((sizeOfConstantT * j) + ambientColorOffset);
BufferUtils.copy(kBoxAmbientColors[1], 0, 4, constant_buffer);
constant_buffer.position((sizeOfConstantT * j) + diffuseColorOffset);
BufferUtils.copy(kBoxDiffuseColors[1], 0, 4, constant_buffer);
constant_buffer.putInt((sizeOfConstantT * j) + multiplierOffset, -1);
}
}
}
}
private CoderResult decodeArrayLoop(ByteBuffer src, CharBuffer dst) {
byte[] sa = src.array();
int sp = src.arrayOffset() + src.position();
int sl = src.arrayOffset() + src.limit();
assert (sp <= sl);
sp = (sp <= sl ? sp : sl);
char[] da = dst.array();
int dp = dst.arrayOffset() + dst.position();
int dl = dst.arrayOffset() + dst.limit();
assert (dp <= dl);
dp = (dp <= dl ? dp : dl);
try {
while (sp < sl) {
int b1, b2;
b1 = sa[sp];
int inputSize = 1;
int v = 0;
char outputChar = REPLACE_CHAR;
if (b1 < 0)
b1 += 256;
if (!leadByte[b1])
{
outputChar = singleByteToChar.charAt(b1);
} else {
if (sl - sp < 2)
return CoderResult.UNDERFLOW;
b2 = sa[sp + 1];
if (b2 < 0)
b2 += 256;
inputSize++;
// Lookup in the two level index
v = b1 * 256 + b2;
outputChar = index2.charAt(index1[((v & mask1) >> shift)]
+ (v & mask2));
}
if (outputChar == '\uFFFD')
return CoderResult.unmappableForLength(inputSize);
if (dl - dp < 1)
return CoderResult.OVERFLOW;
da[dp++] = outputChar;
sp += inputSize;
}
return CoderResult.UNDERFLOW;
} finally {
src.position(sp - src.arrayOffset());
dst.position(dp - dst.arrayOffset());
}
}