Cross Reference: /libcore/luni/src/main/java/java/nio/MemoryBlock.java

Lines Matching defs:offset
95     public static MemoryBlock mmap(FileDescriptor fd, long offset, long size, MapMode mapMode) throws IOException {
101         if (offset < 0 || size < 0 || offset > Integer.MAX_VALUE || size > Integer.MAX_VALUE) {
102             throw new IllegalArgumentException("offset=" + offset + " size=" + size);
117             int address = (int) Libcore.os.mmap(0L, size, prot, flags, fd, offset);
148     public final void pokeByte(int offset, byte value) {
149         Memory.pokeByte(address + offset, value);
152     public final void pokeByteArray(int offset, byte[] src, int srcOffset, int byteCount) {
153         Memory.pokeByteArray(address + offset, src, srcOffset, byteCount);
156     public final void pokeCharArray(int offset, char[] src, int srcOffset, int charCount, boolean swap) {
157         Memory.pokeCharArray(address + offset, src, srcOffset, charCount, swap);
160     public final void pokeDoubleArray(int offset, double[] src, int srcOffset, int doubleCount, boolean swap) {
161         Memory.pokeDoubleArray(address + offset, src, srcOffset, doubleCount, swap);
164     public final void pokeFloatArray(int offset, float[] src, int srcOffset, int floatCount, boolean swap) {
165         Memory.pokeFloatArray(address + offset, src, srcOffset, floatCount, swap);
168     public final void pokeIntArray(int offset, int[] src, int srcOffset, int intCount, boolean swap) {
169         Memory.pokeIntArray(address + offset, src, srcOffset, intCount, swap);
172     public final void pokeLongArray(int offset, long[] src, int srcOffset, int longCount, boolean swap) {
173         Memory.pokeLongArray(address + offset, src, srcOffset, longCount, swap);
176     public final void pokeShortArray(int offset, short[] src, int srcOffset, int shortCount, boolean swap) {
177         Memory.pokeShortArray(address + offset, src, srcOffset, shortCount, swap);
180     public final byte peekByte(int offset) {
181         return Memory.peekByte(address + offset);
184     public final void peekByteArray(int offset, byte[] dst, int dstOffset, int byteCount) {
185         Memory.peekByteArray(address + offset, dst, dstOffset, byteCount);
188     public final void peekCharArray(int offset, char[] dst, int dstOffset, int charCount, boolean swap) {
189         Memory.peekCharArray(address + offset, dst, dstOffset, charCount, swap);
192     public final void peekDoubleArray(int offset, double[] dst, int dstOffset, int doubleCount, boolean swap) {
193         Memory.peekDoubleArray(address + offset, dst, dstOffset, doubleCount, swap);
196     public final void peekFloatArray(int offset, float[] dst, int dstOffset, int floatCount, boolean swap) {
197         Memory.peekFloatArray(address + offset, dst, dstOffset, floatCount, swap);
200     public final void peekIntArray(int offset, int[] dst, int dstOffset, int intCount, boolean swap) {
201         Memory.peekIntArray(address + offset, dst, dstOffset, intCount, swap);
204     public final void peekLongArray(int offset, long[] dst, int dstOffset, int longCount, boolean swap) {
205         Memory.peekLongArray(address + offset, dst, dstOffset, longCount, swap);
208     public final void peekShortArray(int offset, short[] dst, int dstOffset, int shortCount, boolean swap) {
209         Memory.peekShortArray(address + offset, dst, dstOffset, shortCount, swap);
212     public final void pokeShort(int offset, short value, ByteOrder order) {
213         Memory.pokeShort(address + offset, value, order.needsSwap);
216     public final short peekShort(int offset, ByteOrder order) {
217         return Memory.peekShort(address + offset, order.needsSwap);
220     public final void pokeInt(int offset, int value, ByteOrder order) {
221         Memory.pokeInt(address + offset, value, order.needsSwap);
224     public final int peekInt(int offset, ByteOrder order) {
225         return Memory.peekInt(address + offset, order.needsSwap);
228     public final void pokeLong(int offset, long value, ByteOrder order) {
229         Memory.pokeLong(address + offset, value, order.needsSwap);
232     public final long peekLong(int offset, ByteOrder order) {
233         return Memory.peekLong(address + offset, order.needsSwap);