public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); } public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); } public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }
public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); } public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }
public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); } public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }
public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); } public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }
public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); } public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }
public void msync(long address, long byteCount, int flags) throws ErrnoException { os.msync(address, byteCount, flags); } public void munlock(long address, long byteCount) throws ErrnoException { os.munlock(address, byteCount); }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }