@Override public long read(int index) { return buffer.get(buffer.position() + index); }
/** Returns a string representing the state of this long buffer. * * @return a string representing the state of this long buffer. * @since Android 1.0 */ public String toString () { StringBuilder sb = new StringBuilder(); sb.append(getClass().getName()); sb.append(", status: capacity="); //$NON-NLS-1$ sb.append(capacity()); sb.append(" position="); //$NON-NLS-1$ sb.append(position()); sb.append(" limit="); //$NON-NLS-1$ sb.append(limit()); return sb.toString(); } }
/** Returns a string representing the state of this long buffer. * * @return a string representing the state of this long buffer. * @since Android 1.0 */ public String toString () { StringBuilder sb = new StringBuilder(); sb.append(getClass().getName()); sb.append(", status: capacity="); //$NON-NLS-1$ sb.append(capacity()); sb.append(" position="); //$NON-NLS-1$ sb.append(position()); sb.append(" limit="); //$NON-NLS-1$ sb.append(limit()); return sb.toString(); } }
/** * Returns a {@code BitSet} corresponding to {@code longBuffer}, interpreted as a little-endian * sequence of bits. This method does not alter the {@code LongBuffer}. * @since 1.7 */ public static BitSet valueOf(LongBuffer longBuffer) { // The bulk get would mutate LongBuffer (even if we reset position later), and it's not // clear that's allowed. My assumption is that it's the long[] variant that's the common // case anyway, so copy the buffer into a long[]. long[] longs = new long[longBuffer.remaining()]; for (int i = 0; i < longs.length; ++i) { longs[i] = longBuffer.get(longBuffer.position() + i); } return BitSet.valueOf(longs); }
+ String.valueOf(longBuffer.position()));
@Override @SuppressWarnings("WeakerAccess") public long[] getCompressedCounts() { LongBuffer buf = LongBuffer.allocate(counts.length); Simple64.compress(buf, counts, 0, counts.length); long[] r = new long[buf.position()]; buf.flip(); buf.get(r); return r; }
@Override public int first() { assertNonEmpty(cardinality == 0); long firstNonZeroWord; int i = 0; if(BufferUtil.isBackedBySimpleArray(bitmap)) { long[] array = bitmap.array(); while(array[i] == 0) { ++i; } firstNonZeroWord = array[i]; } else { i = bitmap.position(); while(bitmap.get(i) == 0) { ++i; } firstNonZeroWord = bitmap.get(i); } return i * 64 + numberOfTrailingZeros(firstNonZeroWord); }
@Override public LongBuffer asNioLong() { if (offset() >= Integer.MAX_VALUE) throw new IllegalStateException("Index out of bounds " + offset()); if (offset() == 0) { return wrappedBuffer().asLongBuffer(); } else return (LongBuffer) wrappedBuffer().asLongBuffer().position((int) offset()); }
@Override @SuppressWarnings("WeakerAccess") public void writeObject(java.io.ObjectOutputStream out) throws IOException { out.writeDouble(min); out.writeDouble(max); out.writeByte(bitsOfPrecision); out.writeByte(shift); ByteBuffer buf = ByteBuffer.allocate(8 * counts.length); LongBuffer longBuffer = buf.asLongBuffer(); Simple64.compress(longBuffer, counts, 0, counts.length); buf.position(8 * longBuffer.position()); byte[] r = new byte[buf.position()]; out.writeShort(buf.position()); buf.flip(); buf.get(r); out.write(r); }
/** * Take a certain number of longs from the buffer and return them in an array. * * @param buffer the buffer to read * @param cnt the number of longs to take * @return the longs */ public static long[] take(LongBuffer buffer, int cnt) { if (cnt < 0) { throw msg.parameterOutOfRange("cnt"); } if (buffer.hasArray()) { final int pos = buffer.position(); final int lim = buffer.limit(); if (lim - pos < cnt) { throw new BufferUnderflowException(); } final long[] array = buffer.array(); final int offset = buffer.arrayOffset(); buffer.position(pos + cnt); final int start = offset + pos; return Arrays.copyOfRange(array, start, start + cnt); } final long[] longs = new long[cnt]; buffer.get(longs); return longs; }
@Override public void setArg(int index, long l) { LongBuffer buf = Utils.tempBuffers[0].b16l; buf.position(0); buf.limit(1); buf.put(0, l); int ret = CL10.clSetKernelArg(kernel, index, buf); Utils.checkError(ret, "clSetKernelArg"); }
@Override public void setArg(int index, long l) { LongBuffer buf = Utils.tempBuffers[0].b16l; buf.position(0); buf.limit(1); buf.put(0, l); int ret = cl.clSetKernelArg(kernel, index, 8, buf); Utils.checkError(ret, "clSetKernelArg"); }
public long[] getA8( ) { _arys++; // Get the lengths of lead & trailing zero sections, and the non-zero // middle section. int x = getInt(); if( x == -1 ) return null; int y = getInt(); // Non-zero in the middle int z = y==0 ? 0 : getInt();// Trailing zeros long[] buf = MemoryManager.malloc8(x+y+z); switch( get1() ) { // 1,2,4 or 8 for how the middle section is passed case 1: for( int i=x; i<x+y; i++ ) buf[i] = get1(); return buf; case 2: for( int i=x; i<x+y; i++ ) buf[i] = (short)get2(); return buf; case 4: for( int i=x; i<x+y; i++ ) buf[i] = get4(); return buf; case 8: break; default: throw H2O.fail(); } int sofar = x; while( sofar < x+y ) { LongBuffer as = _bb.asLongBuffer(); int more = Math.min(as.remaining(), x+y - sofar); as.get(buf, sofar, more); sofar += more; _bb.position(_bb.position() + as.position()*8); if( sofar < x+y ) getSp(Math.min(_bb.capacity()-7, (x+y-sofar)*8)); } return buf; } public double[] getA8d( ) {
/** * Creates the actual Buffer objects. */ public void createBuffers() { for (BufferInfo info : mBuffers) { if (info.buffer != null) { if (info.buffer instanceof FloatBuffer) { ((FloatBuffer) info.buffer).compact().position(0); } else if (info.buffer instanceof IntBuffer) { ((IntBuffer) info.buffer).compact().position(0); } else if (info.buffer instanceof ShortBuffer) { ((ShortBuffer) info.buffer).compact().position(0); } else if (info.buffer instanceof ByteBuffer) { ((ByteBuffer) info.buffer).compact().position(0); } else if (info.buffer instanceof DoubleBuffer) { ((DoubleBuffer) info.buffer).compact().position(0); } else if (info.buffer instanceof LongBuffer) { ((LongBuffer) info.buffer).compact().position(0); } else if (info.buffer instanceof CharBuffer) { ((CharBuffer) info.buffer).compact().position(0); } } createBuffer(info); } GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0); GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0); mHaveCreatedBuffers = true; }
/** * Fill a buffer with a repeated value. * * @param buffer the buffer to fill * @param value the value to fill * @param count the number of longs to fill * @return the buffer instance */ public static LongBuffer fill(LongBuffer buffer, long value, int count) { if (count > buffer.remaining()) { throw msg.bufferUnderflow(); } if (buffer.hasArray()) { final int offs = buffer.arrayOffset(); Arrays.fill(buffer.array(), offs + buffer.position(), offs + buffer.limit(), value); skip(buffer, count); } else { for (int i = count; i > 0; i--) { buffer.put(value); } } return buffer; }
sb.put(ary, sofar, len); sofar += len; _bb.position(_bb.position() + sb.position()*8); if( sofar < y ) sendPartial();
/** * For direct buffers, calls {@link Pointer#Pointer(Buffer)}, while for buffers * backed with an array, allocates enough memory for the array and copies it. * * @param buffer the Buffer to reference or copy * @see #put(long[]) */ public LongPointer(LongBuffer buffer) { super(buffer); if (buffer != null && !buffer.isDirect() && buffer.hasArray()) { long[] array = buffer.array(); allocateArray(array.length - buffer.arrayOffset()); put(array, buffer.arrayOffset(), array.length - buffer.arrayOffset()); position(buffer.position()); limit(buffer.limit()); } } /**
/** * Get bit at specified position in serialized bitmap. * * @param bitmap Serialized bitmap. * @param i Index into serialized bitmap. * @return Value of bit. */ public static long getBit(LongBuffer bitmap, int i) { return ((bitmap.get(bitmap.position() + (i / 64)) >>> (63L - i)) & 1L); }