harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndbe...@apache.org
Subject svn commit: r824209 [2/2] - /harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/
Date Mon, 12 Oct 2009 00:55:28 GMT
Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java?rev=824209&r1=824208&r2=824209&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSFileSystem.java Mon Oct 12 00:55:27 2009
@@ -35,124 +35,124 @@
     }
 
     private OSFileSystem() {
-		super();
-	}
+        super();
+    }
+
+    private final void validateLockArgs(int type, long start, long length) {
+        if ((type != IFileSystem.SHARED_LOCK_TYPE)
+                && (type != IFileSystem.EXCLUSIVE_LOCK_TYPE)) {
+            throw new IllegalArgumentException("Illegal lock type requested."); //$NON-NLS-1$
+        }
+
+        // Start position
+        if (start < 0) {
+            throw new IllegalArgumentException(
+                    "Lock start position must be non-negative"); //$NON-NLS-1$
+        }
+
+        // Length of lock stretch
+        if (length < 0) {
+            throw new IllegalArgumentException(
+                    "Lock length must be non-negative"); //$NON-NLS-1$
+        }
+    }
+
+    private native int lockImpl(long fileDescriptor, long start, long length,
+            int type, boolean wait);
+
+    /**
+     * Returns the granularity for virtual memory allocation.
+     * Note that this value for Windows differs from the one for the
+     * page size (64K and 4K respectively).
+     */
+    public native int getAllocGranularity() throws IOException;
+
+    public boolean lock(long fileDescriptor, long start, long length, int type,
+            boolean waitFlag) throws IOException {
+        // Validate arguments
+        validateLockArgs(type, start, length);
+        int result = lockImpl(fileDescriptor, start, length, type, waitFlag);
+        return result != -1;
+    }
+
+    private native int unlockImpl(long fileDescriptor, long start, long length);
+
+    public void unlock(long fileDescriptor, long start, long length)
+            throws IOException {
+        // Validate arguments
+        validateLockArgs(IFileSystem.SHARED_LOCK_TYPE, start, length);
+        int result = unlockImpl(fileDescriptor, start, length);
+        if (result == -1) {
+            throw new IOException();
+        }
+    }
+
+    private native int fflushImpl(long fd, boolean metadata);
+
+    public void fflush(long fileDescriptor, boolean metadata)
+            throws IOException {
+        int result = fflushImpl(fileDescriptor, metadata);
+        if (result == -1) {
+            throw new IOException();
+        }
+    }
 
-	private final void validateLockArgs(int type, long start, long length) {
-		if ((type != IFileSystem.SHARED_LOCK_TYPE)
-				&& (type != IFileSystem.EXCLUSIVE_LOCK_TYPE)) {
-			throw new IllegalArgumentException("Illegal lock type requested."); //$NON-NLS-1$
-		}
-
-		// Start position
-		if (start < 0) {
-			throw new IllegalArgumentException(
-					"Lock start position must be non-negative"); //$NON-NLS-1$
-		}
-
-		// Length of lock stretch
-		if (length < 0) {
-			throw new IllegalArgumentException(
-					"Lock length must be non-negative"); //$NON-NLS-1$
-		}
-	}
-
-	private native int lockImpl(long fileDescriptor, long start, long length,
-			int type, boolean wait);
-
-	/**
-	 * Returns the granularity for virtual memory allocation.
-	 * Note that this value for Windows differs from the one for the
-	 * page size (64K and 4K respectively).
-	 */
-	public native int getAllocGranularity() throws IOException;
-
-	public boolean lock(long fileDescriptor, long start, long length, int type,
-			boolean waitFlag) throws IOException {
-		// Validate arguments
-		validateLockArgs(type, start, length);
-		int result = lockImpl(fileDescriptor, start, length, type, waitFlag);
-		return result != -1;
-	}
-
-	private native int unlockImpl(long fileDescriptor, long start, long length);
-
-	public void unlock(long fileDescriptor, long start, long length)
-			throws IOException {
-		// Validate arguments
-		validateLockArgs(IFileSystem.SHARED_LOCK_TYPE, start, length);
-		int result = unlockImpl(fileDescriptor, start, length);
-		if (result == -1) {
-			throw new IOException();
-		}
-	}
-
-	private native int fflushImpl(long fd, boolean metadata);
-
-	public void fflush(long fileDescriptor, boolean metadata)
-			throws IOException {
-		int result = fflushImpl(fileDescriptor, metadata);
-		if (result == -1) {
-			throw new IOException();
-		}
-	}
-
-	/*
-	 * File position seeking.
-	 */
-
-	private native long seekImpl(long fd, long offset, int whence);
-
-	public long seek(long fileDescriptor, long offset, int whence)
-			throws IOException {
-		long pos = seekImpl(fileDescriptor, offset, whence);
-		if (pos == -1) {
-			throw new IOException();
-		}
-		return pos;
-	}
-
-	/*
-	 * Direct read/write APIs work on addresses.
-	 */
-	private native long readDirectImpl(long fileDescriptor, long address,
-			int offset, int length);
-
-	public long readDirect(long fileDescriptor, long address, int offset,
-			int length) throws IOException {
-		long bytesRead = readDirectImpl(fileDescriptor, address, offset, length);
-		if (bytesRead < -1) {
-			throw new IOException();
-		}
-		return bytesRead;
-	}
-
-	private native long writeDirectImpl(long fileDescriptor, long address,
-			int offset, int length);
-
-	public long writeDirect(long fileDescriptor, long address, int offset,
-			int length) throws IOException {
-		long bytesWritten = writeDirectImpl(fileDescriptor, address, offset,
-				length);
-		if (bytesWritten < 0) {
-			throw new IOException();
-		}
-		return bytesWritten;
-	}
-
-	/*
-	 * Indirect read/writes work on byte[]'s
-	 */
-	private native long readImpl(long fileDescriptor, byte[] bytes, int offset,
-			int length);
-
-	public long read(long fileDescriptor, byte[] bytes, int offset, int length)
-			throws IOException {
-		if (bytes == null) {
-			throw new NullPointerException();
-		}
-		long bytesRead = readImpl(fileDescriptor, bytes, offset, length);
-		if (bytesRead < -1) {
+    /*
+     * File position seeking.
+     */
+
+    private native long seekImpl(long fd, long offset, int whence);
+
+    public long seek(long fileDescriptor, long offset, int whence)
+            throws IOException {
+        long pos = seekImpl(fileDescriptor, offset, whence);
+        if (pos == -1) {
+            throw new IOException();
+        }
+        return pos;
+    }
+
+    /*
+     * Direct read/write APIs work on addresses.
+     */
+    private native long readDirectImpl(long fileDescriptor, long address,
+            int offset, int length);
+
+    public long readDirect(long fileDescriptor, long address, int offset,
+            int length) throws IOException {
+        long bytesRead = readDirectImpl(fileDescriptor, address, offset, length);
+        if (bytesRead < -1) {
+            throw new IOException();
+        }
+        return bytesRead;
+    }
+
+    private native long writeDirectImpl(long fileDescriptor, long address,
+            int offset, int length);
+
+    public long writeDirect(long fileDescriptor, long address, int offset,
+            int length) throws IOException {
+        long bytesWritten = writeDirectImpl(fileDescriptor, address, offset,
+                length);
+        if (bytesWritten < 0) {
+            throw new IOException();
+        }
+        return bytesWritten;
+    }
+
+    /*
+     * Indirect read/writes work on byte[]'s
+     */
+    private native long readImpl(long fileDescriptor, byte[] bytes, int offset,
+            int length);
+
+    public long read(long fileDescriptor, byte[] bytes, int offset, int length)
+            throws IOException {
+        if (bytes == null) {
+            throw new NullPointerException();
+        }
+        long bytesRead = readImpl(fileDescriptor, bytes, offset, length);
+        if (bytesRead < -1) {
                         /*
                          * TODO: bytesRead is never less than -1 so this code
                          * does nothing?
@@ -161,81 +161,81 @@
                          * any other cases.  But the other cases have been
                          * ignored until now so fixing this could break things
                          */
-			throw new IOException();
-		}
-		return bytesRead;
-	}
-
-	private native long writeImpl(long fileDescriptor, byte[] bytes,
-			int offset, int length);
-
-	public long write(long fileDescriptor, byte[] bytes, int offset, int length)
-			throws IOException {
-		long bytesWritten = writeImpl(fileDescriptor, bytes, offset, length);
-		if (bytesWritten < 0) {
-			throw new IOException();
-		}
-		return bytesWritten;
-	}
-
-	/*
-	 * Scatter/gather calls.
-	 */
-	public long readv(long fileDescriptor, long[] addresses, int[] offsets,
-			int[] lengths, int size) throws IOException {
-		long bytesRead = readvImpl(fileDescriptor, addresses, offsets, lengths,
-				size);
-		if (bytesRead < -1) {
-			throw new IOException();
-		}
-		return bytesRead;
-	}
-
-	private native long readvImpl(long fileDescriptor, long[] addresses,
-			int[] offsets, int[] lengths, int size);
-
-	public long writev(long fileDescriptor, long[] addresses, int[] offsets,
-			int[] lengths, int size) throws IOException {
-		long bytesWritten = writevImpl(fileDescriptor, addresses, offsets,
-				lengths, size);
-		if (bytesWritten < 0) {
-			throw new IOException();
-		}
-		return bytesWritten;
-	}
-
-	private native long writevImpl(long fileDescriptor, long[] addresses,
-			int[] offsets, int[] lengths, int size);
-
-	private native int closeImpl(long fileDescriptor);
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see org.apache.harmony.luni.platform.IFileSystem#close(long)
-	 */
-	public void close(long fileDescriptor) throws IOException {
-		int rc = closeImpl(fileDescriptor);
-		if (rc == -1) {
-			throw new IOException();
-		}
-	}
-
-	public void truncate(long fileDescriptor, long size) throws IOException {
-		int rc = truncateImpl(fileDescriptor, size);
-		if (rc < 0) {
-			throw new IOException();
-		}
-	}
-
-	private native int truncateImpl(long fileDescriptor, long size);
-
-	public long open(byte[] fileName, int mode) throws FileNotFoundException {
-		if (fileName == null) {
-			throw new NullPointerException();
-		}
-		long handler = openImpl(fileName, mode);
-		if (handler < 0) {
+            throw new IOException();
+        }
+        return bytesRead;
+    }
+
+    private native long writeImpl(long fileDescriptor, byte[] bytes,
+            int offset, int length);
+
+    public long write(long fileDescriptor, byte[] bytes, int offset, int length)
+            throws IOException {
+        long bytesWritten = writeImpl(fileDescriptor, bytes, offset, length);
+        if (bytesWritten < 0) {
+            throw new IOException();
+        }
+        return bytesWritten;
+    }
+
+    /*
+     * Scatter/gather calls.
+     */
+    public long readv(long fileDescriptor, long[] addresses, int[] offsets,
+            int[] lengths, int size) throws IOException {
+        long bytesRead = readvImpl(fileDescriptor, addresses, offsets, lengths,
+                size);
+        if (bytesRead < -1) {
+            throw new IOException();
+        }
+        return bytesRead;
+    }
+
+    private native long readvImpl(long fileDescriptor, long[] addresses,
+            int[] offsets, int[] lengths, int size);
+
+    public long writev(long fileDescriptor, long[] addresses, int[] offsets,
+            int[] lengths, int size) throws IOException {
+        long bytesWritten = writevImpl(fileDescriptor, addresses, offsets,
+                lengths, size);
+        if (bytesWritten < 0) {
+            throw new IOException();
+        }
+        return bytesWritten;
+    }
+
+    private native long writevImpl(long fileDescriptor, long[] addresses,
+            int[] offsets, int[] lengths, int size);
+
+    private native int closeImpl(long fileDescriptor);
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.apache.harmony.luni.platform.IFileSystem#close(long)
+     */
+    public void close(long fileDescriptor) throws IOException {
+        int rc = closeImpl(fileDescriptor);
+        if (rc == -1) {
+            throw new IOException();
+        }
+    }
+
+    public void truncate(long fileDescriptor, long size) throws IOException {
+        int rc = truncateImpl(fileDescriptor, size);
+        if (rc < 0) {
+            throw new IOException();
+        }
+    }
+
+    private native int truncateImpl(long fileDescriptor, long size);
+
+    public long open(byte[] fileName, int mode) throws FileNotFoundException {
+        if (fileName == null) {
+            throw new NullPointerException();
+        }
+        long handler = openImpl(fileName, mode);
+        if (handler < 0) {
                     try {
                         throw new FileNotFoundException(new String(fileName, "UTF-8"));
                     } catch (java.io.UnsupportedEncodingException e) {
@@ -244,40 +244,40 @@
                         e.initCause(fnfe);
                         throw new AssertionError(e);
                     }
-		}
-		return handler;
-	}
-
-	private native long openImpl(byte[] fileName, int mode);
-
-	public long transfer(long fileHandler, FileDescriptor socketDescriptor,
-			long offset, long count) throws IOException {
-		long result = transferImpl(fileHandler, socketDescriptor, offset, count);
-		if (result < 0)
-			throw new IOException();
-		return result;
-	}
-
-	private native long transferImpl(long fileHandler,
-			FileDescriptor socketDescriptor, long offset, long count);
-
-	public long ttyAvailable() throws IOException {
-		long nChar = ttyAvailableImpl();
-		if (nChar < 0) {
-			throw new IOException();
-		}
-		return nChar;
-	}
-
-	private native long ttyAvailableImpl();
-
-	public long ttyRead(byte[] bytes, int offset, int length) throws IOException {
-		long nChar = ttyReadImpl(bytes, offset, length);
-		if (nChar < 0) {
-			throw new IOException();
-		}
-		return nChar;
-	}
+        }
+        return handler;
+    }
+
+    private native long openImpl(byte[] fileName, int mode);
+
+    public long transfer(long fileHandler, FileDescriptor socketDescriptor,
+            long offset, long count) throws IOException {
+        long result = transferImpl(fileHandler, socketDescriptor, offset, count);
+        if (result < 0)
+            throw new IOException();
+        return result;
+    }
+
+    private native long transferImpl(long fileHandler,
+            FileDescriptor socketDescriptor, long offset, long count);
+
+    public long ttyAvailable() throws IOException {
+        long nChar = ttyAvailableImpl();
+        if (nChar < 0) {
+            throw new IOException();
+        }
+        return nChar;
+    }
+
+    private native long ttyAvailableImpl();
+
+    public long ttyRead(byte[] bytes, int offset, int length) throws IOException {
+        long nChar = ttyReadImpl(bytes, offset, length);
+        if (nChar < 0) {
+            throw new IOException();
+        }
+        return nChar;
+    }
 
-	private native long ttyReadImpl(byte[] bytes, int offset, int length);
+    private native long ttyReadImpl(byte[] bytes, int offset, int length);
 }

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java?rev=824209&r1=824208&r2=824209&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/OSMemory.java Mon Oct 12 00:55:27 2009
@@ -41,33 +41,33 @@
  */
 final class OSMemory implements IMemorySystem {
 
-	/**
-	 * Defines the size, in bytes, of a native pointer type for the underlying
-	 * platform. This will be 4 (for 32-bit machines) or 8 (for 64-bit
-	 * machines).
-	 */
-	public static final int POINTER_SIZE;
-
-	/**
-	 * Defines the natural byte order for this machine.
-	 */
-	public static final Endianness NATIVE_ORDER;
-
-	private static final OSMemory singleton = new OSMemory();
-
-	static {
-		POINTER_SIZE = getPointerSizeImpl();
-
-		if (isLittleEndianImpl()) {
-			NATIVE_ORDER = Endianness.LITTLE_ENDIAN;
-		} else {
-			NATIVE_ORDER = Endianness.BIG_ENDIAN;
-		}
-	}
-
-	public static OSMemory getOSMemory() {
-		return singleton;
-	}
+    /**
+     * Defines the size, in bytes, of a native pointer type for the underlying
+     * platform. This will be 4 (for 32-bit machines) or 8 (for 64-bit
+     * machines).
+     */
+    public static final int POINTER_SIZE;
+
+    /**
+     * Defines the natural byte order for this machine.
+     */
+    public static final Endianness NATIVE_ORDER;
+
+    private static final OSMemory singleton = new OSMemory();
+
+    static {
+        POINTER_SIZE = getPointerSizeImpl();
+
+        if (isLittleEndianImpl()) {
+            NATIVE_ORDER = Endianness.LITTLE_ENDIAN;
+        } else {
+            NATIVE_ORDER = Endianness.BIG_ENDIAN;
+        }
+    }
+
+    public static OSMemory getOSMemory() {
+        return singleton;
+    }
 
     /*
      * Native method to determine whether the underlying platform is little
@@ -78,14 +78,14 @@
      */
     private static native boolean isLittleEndianImpl();
 
-	/**
-	 * This class is not designed to be publicly instantiated.
-	 * 
-	 * @see #getOSMemory()
-	 */
-	private OSMemory() {
-		super();
-	}
+    /**
+     * This class is not designed to be publicly instantiated.
+     * 
+     * @see #getOSMemory()
+     */
+    private OSMemory() {
+        super();
+    }
 
     /**
      * Answers whether the byte order of this machine is little endian or not.
@@ -93,510 +93,510 @@
      * @return <code>false</code> for Big Endian, and
      *         <code>true</code> for Little Endian.
      */
-	public boolean isLittleEndian() {
-		return NATIVE_ORDER == Endianness.LITTLE_ENDIAN;
-	}
-
-	/**
-	 * Answers the natural byte order for this machine.
-	 * 
-	 * @return the native byte order for the current platform.
-	 */
-	public Endianness getNativeOrder() {
-		return NATIVE_ORDER;
-	}
-
-	/**
-	 * Answers the size of a native pointer type for the underlying platform.
-	 * 
-	 * @return the size of a pointer, in bytes.
-	 */
-	private static native int getPointerSizeImpl();
-
-	public int getPointerSize() {
-		return POINTER_SIZE;
-	}
-
-	/**
-	 * Allocates and returns a pointer to space for a memory block of
-	 * <code>length</code> bytes. The space is uninitialized and may be larger
-	 * than the number of bytes requested; however, the guaranteed usable memory
-	 * block is exactly <code>length</code> bytes long.
-	 * 
-	 * @param length
-	 *            number of bytes requested.
-	 * @return the address of the start of the memory block.
-	 * @throws OutOfMemoryError
-	 *             if the request cannot be satisfied.
-	 */
-	public native long malloc(long length) throws OutOfMemoryError;
-
-	/**
-	 * Deallocates space for a memory block that was previously allocated by a
-	 * call to {@link #malloc(long) malloc(long)}. The number of bytes freed is
-	 * identical to the number of bytes acquired when the memory block was
-	 * allocated. If <code>address</code> is zero the method does nothing.
-	 * <p>
-	 * Freeing a pointer to a memory block that was not allocated by
-	 * <code>malloc()</code> has unspecified effect.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the address of the memory block to deallocate.
-	 */
-	public native void free(long address);
-
-	/**
-	 * Places <code>value</code> into first <code>length</code> bytes of the
-	 * memory block starting at <code>address</code>.
-	 * <p>
-	 * The behavior is unspecified if
-	 * <code>(address ... address + length)</code> is not wholly within the
-	 * range that was previously allocated using <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the address of the first memory location.
-	 * @param value
-	 *            the byte value to set at each location.
-	 * @param length
-	 *            the number of byte-length locations to set.
-	 */
-	public native void memset(long address, byte value, long length);
-
-	/**
-	 * Copies <code>length</code> bytes from <code>srcAddress</code> to
-	 * <code>destAddress</code>. Where any part of the source memory block
-	 * and the destination memory block overlap <code>memmove()</code> ensures
-	 * that the original source bytes in the overlapping region are copied
-	 * before being overwritten.
-	 * <p>
-	 * The behavior is unspecified if
-	 * <code>(srcAddress ... srcAddress + length)</code> and
-	 * <code>(destAddress ... destAddress + length)</code> are not both wholly
-	 * within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param destAddress
-	 *            the address of the destination memory block.
-	 * @param srcAddress
-	 *            the address of the source memory block.
-	 * @param length
-	 *            the number of bytes to move.
-	 */
-	public native void memmove(long destAddress, long srcAddress, long length);
-
-	/**
-	 * Copies <code>length</code> bytes from the memory block at
-	 * <code>address</code> into the byte array <code>bytes</code> starting
-	 * at element <code>offset</code> within the byte array.
-	 * <p>
-	 * The behavior of this method is undefined if the range
-	 * <code>(address ... address + length)</code> is not within a memory
-	 * block that was allocated using {@link #malloc(long) malloc(long)}.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the address of the OS memory block from which to copy bytes.
-	 * @param bytes
-	 *            the byte array into which to copy the bytes.
-	 * @param offset
-	 *            the index of the first element in <code>bytes</code> that
-	 *            will be overwritten.
-	 * @param length
-	 *            the total number of bytes to copy into the byte array.
-	 * @throws NullPointerException
-	 *             if <code>bytes</code> is <code>null</code>.
-	 * @throws IndexOutOfBoundsException
-	 *             if <code>offset + length > bytes.length</code>.
-	 */
-	public native void getByteArray(long address, byte[] bytes, int offset,
-			int length) throws NullPointerException, IndexOutOfBoundsException;
-
-	/**
-	 * Copies <code>length</code> bytes from the byte array <code>bytes</code>
-	 * into the memory block at <code>address</code>, starting at element
-	 * <code>offset</code> within the byte array.
-	 * <p>
-	 * The behavior of this method is undefined if the range
-	 * <code>(address ... address + length)</code> is not within a memory
-	 * block that was allocated using {@link #malloc(long) malloc(long)}.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the address of the OS memory block into which to copy the
-	 *            bytes.
-	 * @param bytes
-	 *            the byte array from which to copy the bytes.
-	 * @param offset
-	 *            the index of the first element in <code>bytes</code> that
-	 *            will be read.
-	 * @param length
-	 *            the total number of bytes to copy from <code>bytes</code>
-	 *            into the memory block.
-	 * @throws NullPointerException
-	 *             if <code>bytes</code> is <code>null</code>.
-	 * @throws IndexOutOfBoundsException
-	 *             if <code>offset + length > bytes.length</code>.
-	 */
-	public native void setByteArray(long address, byte[] bytes, int offset,
-			int length) throws NullPointerException, IndexOutOfBoundsException;
-
-	// Primitive get & set methods
-
-	/**
-	 * Gets the value of the single byte at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>address</code> is not in the range
-	 * that was previously allocated using <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the byte.
-	 * @return the byte value.
-	 */
-	public native byte getByte(long address);
-
-	/**
-	 * Sets the given single byte value at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>address</code> is not in the range
-	 * that was previously allocated using <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the address at which to set the byte value.
-	 * @param value
-	 *            the value to set.
-	 */
-	public native void setByte(long address, byte value);
-
-	/**
-	 * Gets the value of the signed two-byte integer stored in platform byte
-	 * order at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 2)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the two-byte value.
-	 * @return the value of the two-byte integer as a Java <code>short</code>.
-	 */
-	public native short getShort(long address);
-
-	public short getShort(long address, Endianness endianness) {
-		return (endianness == NATIVE_ORDER) ? getShort(address)
-				: swap(getShort(address));
-	}
-
-	/**
-	 * Sets the value of the signed two-byte integer at the given address in
-	 * platform byte order.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 2)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the two-byte value.
-	 * @param value
-	 *            the value of the two-byte integer as a Java <code>short</code>.
-	 */
-	public native void setShort(long address, short value);
-
-	public void setShort(long address, short value, Endianness endianness) {
-		if (endianness == NATIVE_ORDER) {
-			setShort(address, value);
-		} else {
-			setShort(address, swap(value));
-		}
-	}
-
-	/**
-	 * Gets the value of the signed four-byte integer stored in platform
-	 * byte-order at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 4)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the four-byte value.
-	 * @return the value of the four-byte integer as a Java <code>int</code>.
-	 */
-	public native int getInt(long address);
-
-	public int getInt(long address, Endianness endianness) {
-		return (endianness == NATIVE_ORDER) ? getInt(address)
-				: swap(getInt(address));
-	}
-
-	/**
-	 * Sets the value of the signed four-byte integer at the given address in
-	 * platform byte order.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 4)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the four-byte value.
-	 * @param value
-	 *            the value of the four-byte integer as a Java <code>int</code>.
-	 */
-	public native void setInt(long address, int value);
-
-	public void setInt(long address, int value, Endianness endianness) {
-		if (endianness == NATIVE_ORDER) {
-			setInt(address, value);
-		} else {
-			setInt(address, swap(value));
-		}
-	}
-
-	/**
-	 * Gets the value of the signed eight-byte integer stored in platform byte
-	 * order at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 8)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the eight-byte value.
-	 * @return the value of the eight-byte integer as a Java <code>long</code>.
-	 */
-	public native long getLong(long address);
-
-	public long getLong(long address, Endianness endianness) {
-		return (endianness == NATIVE_ORDER) ? getLong(address)
-				: swap(getLong(address));
-	}
-
-	/**
-	 * Sets the value of the signed eight-byte integer at the given address in
-	 * the platform byte order.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 8)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the eight-byte value.
-	 * @param value
-	 *            the value of the eight-byte integer as a Java
-	 *            <code>long</code>.
-	 */
-	public native void setLong(long address, long value);
-
-	public void setLong(long address, long value, Endianness endianness) {
-		if (endianness == NATIVE_ORDER) {
-			setLong(address, value);
-		} else {
-			setLong(address, swap(value));
-		}
-	}
-
-	/**
-	 * Gets the value of the IEEE754-format four-byte float stored in platform
-	 * byte order at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 4)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the eight-byte value.
-	 * @return the value of the four-byte float as a Java <code>float</code>.
-	 */
-	public native float getFloat(long address);
-
-	public float getFloat(long address, Endianness endianness) {
-		if (endianness == NATIVE_ORDER) {
-			return getFloat(address);
-		}
-		int floatBits = swap(getInt(address));
-		return Float.intBitsToFloat(floatBits);
-	}
-
-	/**
-	 * Sets the value of the IEEE754-format four-byte float stored in platform
-	 * byte order at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 4)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the eight-byte value.
-	 * @param value
-	 *            the value of the four-byte float as a Java <code>float</code>.
-	 */
-	public native void setFloat(long address, float value);
-
-	public void setFloat(long address, float value, Endianness endianness) {
-		if (endianness == NATIVE_ORDER) {
-			setFloat(address, value);
-		} else {
-			int floatBits = Float.floatToIntBits(value);
-			setInt(address, swap(floatBits));
-		}
-	}
-
-	/**
-	 * Gets the value of the IEEE754-format eight-byte float stored in platform
-	 * byte order at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 8)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the eight-byte value.
-	 * @return the value of the eight-byte float as a Java <code>double</code>.
-	 */
-	public native double getDouble(long address);
-
-	public double getDouble(long address, Endianness endianness) {
-		if (endianness == NATIVE_ORDER) {
-			return getDouble(address);
-		}
-		long doubleBits = swap(getLong(address));
-		return Double.longBitsToDouble(doubleBits);
-	}
-
-	/**
-	 * Sets the value of the IEEE754-format eight-byte float store in platform
-	 * byte order at the given address.
-	 * <p>
-	 * The behavior is unspecified if <code>(address ... address + 8)</code>
-	 * is not wholly within the range that was previously allocated using
-	 * <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the eight-byte value.
-	 * @param value
-	 *            the value of the eight-byte float as a Java
-	 *            <code>double</code>.
-	 */
-	public native void setDouble(long address, double value);
-
-	public void setDouble(long address, double value, Endianness endianness) {
-		if (endianness == NATIVE_ORDER) {
-			setDouble(address, value);
-		} else {
-			long doubleBits = Double.doubleToLongBits(value);
-			setLong(address, swap(doubleBits));
-		}
-	}
-
-	/**
-	 * Gets the value of the platform pointer at the given address.
-	 * <p>
-	 * The length of the platform pointer is defined by
-	 * <code>POINTER_SIZE</code>.
-	 * </p>
-	 * The behavior is unspecified if
-	 * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
-	 * the range that was previously allocated using <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the platform pointer.
-	 * @return the value of the platform pointer as a Java <code>long</code>.
-	 */
-	public native long getAddress(long address);
-
-	/**
-	 * Sets the value of the platform pointer at the given address.
-	 * <p>
-	 * The length of the platform pointer is defined by
-	 * <code>POINTER_SIZE</code>. This method only sets
-	 * <code>POINTER_SIZE</code> bytes at the given address.
-	 * </p>
-	 * The behavior is unspecified if
-	 * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
-	 * the range that was previously allocated using <code>malloc()</code>.
-	 * </p>
-	 * 
-	 * @param address
-	 *            the platform address of the start of the platform pointer.
-	 * @param value
-	 *            the value of the platform pointer as a Java <code>long</code>.
-	 */
-	public native void setAddress(long address, long value);
-
-	/*
-	 * Memory mapped file
-	 */
-	private native long mmapImpl(long fileDescriptor, long alignment,
-			long size, int mapMode);
+    public boolean isLittleEndian() {
+        return NATIVE_ORDER == Endianness.LITTLE_ENDIAN;
+    }
+
+    /**
+     * Answers the natural byte order for this machine.
+     * 
+     * @return the native byte order for the current platform.
+     */
+    public Endianness getNativeOrder() {
+        return NATIVE_ORDER;
+    }
+
+    /**
+     * Answers the size of a native pointer type for the underlying platform.
+     * 
+     * @return the size of a pointer, in bytes.
+     */
+    private static native int getPointerSizeImpl();
+
+    public int getPointerSize() {
+        return POINTER_SIZE;
+    }
+
+    /**
+     * Allocates and returns a pointer to space for a memory block of
+     * <code>length</code> bytes. The space is uninitialized and may be larger
+     * than the number of bytes requested; however, the guaranteed usable memory
+     * block is exactly <code>length</code> bytes long.
+     * 
+     * @param length
+     *            number of bytes requested.
+     * @return the address of the start of the memory block.
+     * @throws OutOfMemoryError
+     *             if the request cannot be satisfied.
+     */
+    public native long malloc(long length) throws OutOfMemoryError;
+
+    /**
+     * Deallocates space for a memory block that was previously allocated by a
+     * call to {@link #malloc(long) malloc(long)}. The number of bytes freed is
+     * identical to the number of bytes acquired when the memory block was
+     * allocated. If <code>address</code> is zero the method does nothing.
+     * <p>
+     * Freeing a pointer to a memory block that was not allocated by
+     * <code>malloc()</code> has unspecified effect.
+     * </p>
+     * 
+     * @param address
+     *            the address of the memory block to deallocate.
+     */
+    public native void free(long address);
+
+    /**
+     * Places <code>value</code> into first <code>length</code> bytes of the
+     * memory block starting at <code>address</code>.
+     * <p>
+     * The behavior is unspecified if
+     * <code>(address ... address + length)</code> is not wholly within the
+     * range that was previously allocated using <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the address of the first memory location.
+     * @param value
+     *            the byte value to set at each location.
+     * @param length
+     *            the number of byte-length locations to set.
+     */
+    public native void memset(long address, byte value, long length);
+
+    /**
+     * Copies <code>length</code> bytes from <code>srcAddress</code> to
+     * <code>destAddress</code>. Where any part of the source memory block
+     * and the destination memory block overlap <code>memmove()</code> ensures
+     * that the original source bytes in the overlapping region are copied
+     * before being overwritten.
+     * <p>
+     * The behavior is unspecified if
+     * <code>(srcAddress ... srcAddress + length)</code> and
+     * <code>(destAddress ... destAddress + length)</code> are not both wholly
+     * within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param destAddress
+     *            the address of the destination memory block.
+     * @param srcAddress
+     *            the address of the source memory block.
+     * @param length
+     *            the number of bytes to move.
+     */
+    public native void memmove(long destAddress, long srcAddress, long length);
+
+    /**
+     * Copies <code>length</code> bytes from the memory block at
+     * <code>address</code> into the byte array <code>bytes</code> starting
+     * at element <code>offset</code> within the byte array.
+     * <p>
+     * The behavior of this method is undefined if the range
+     * <code>(address ... address + length)</code> is not within a memory
+     * block that was allocated using {@link #malloc(long) malloc(long)}.
+     * </p>
+     * 
+     * @param address
+     *            the address of the OS memory block from which to copy bytes.
+     * @param bytes
+     *            the byte array into which to copy the bytes.
+     * @param offset
+     *            the index of the first element in <code>bytes</code> that
+     *            will be overwritten.
+     * @param length
+     *            the total number of bytes to copy into the byte array.
+     * @throws NullPointerException
+     *             if <code>bytes</code> is <code>null</code>.
+     * @throws IndexOutOfBoundsException
+     *             if <code>offset + length > bytes.length</code>.
+     */
+    public native void getByteArray(long address, byte[] bytes, int offset,
+            int length) throws NullPointerException, IndexOutOfBoundsException;
+
+    /**
+     * Copies <code>length</code> bytes from the byte array <code>bytes</code>
+     * into the memory block at <code>address</code>, starting at element
+     * <code>offset</code> within the byte array.
+     * <p>
+     * The behavior of this method is undefined if the range
+     * <code>(address ... address + length)</code> is not within a memory
+     * block that was allocated using {@link #malloc(long) malloc(long)}.
+     * </p>
+     * 
+     * @param address
+     *            the address of the OS memory block into which to copy the
+     *            bytes.
+     * @param bytes
+     *            the byte array from which to copy the bytes.
+     * @param offset
+     *            the index of the first element in <code>bytes</code> that
+     *            will be read.
+     * @param length
+     *            the total number of bytes to copy from <code>bytes</code>
+     *            into the memory block.
+     * @throws NullPointerException
+     *             if <code>bytes</code> is <code>null</code>.
+     * @throws IndexOutOfBoundsException
+     *             if <code>offset + length > bytes.length</code>.
+     */
+    public native void setByteArray(long address, byte[] bytes, int offset,
+            int length) throws NullPointerException, IndexOutOfBoundsException;
+
+    // Primitive get & set methods
+
+    /**
+     * Gets the value of the single byte at the given address.
+     * <p>
+     * The behavior is unspecified if <code>address</code> is not in the range
+     * that was previously allocated using <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the byte.
+     * @return the byte value.
+     */
+    public native byte getByte(long address);
+
+    /**
+     * Sets the given single byte value at the given address.
+     * <p>
+     * The behavior is unspecified if <code>address</code> is not in the range
+     * that was previously allocated using <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the address at which to set the byte value.
+     * @param value
+     *            the value to set.
+     */
+    public native void setByte(long address, byte value);
+
+    /**
+     * Gets the value of the signed two-byte integer stored in platform byte
+     * order at the given address.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 2)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the two-byte value.
+     * @return the value of the two-byte integer as a Java <code>short</code>.
+     */
+    public native short getShort(long address);
+
+    public short getShort(long address, Endianness endianness) {
+        return (endianness == NATIVE_ORDER) ? getShort(address)
+                : swap(getShort(address));
+    }
+
+    /**
+     * Sets the value of the signed two-byte integer at the given address in
+     * platform byte order.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 2)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the two-byte value.
+     * @param value
+     *            the value of the two-byte integer as a Java <code>short</code>.
+     */
+    public native void setShort(long address, short value);
+
+    public void setShort(long address, short value, Endianness endianness) {
+        if (endianness == NATIVE_ORDER) {
+            setShort(address, value);
+        } else {
+            setShort(address, swap(value));
+        }
+    }
 
-	public long mmap(long fileDescriptor, long alignment, long size,
-			int mapMode) throws IOException {
+    /**
+     * Gets the value of the signed four-byte integer stored in platform
+     * byte-order at the given address.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 4)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the four-byte value.
+     * @return the value of the four-byte integer as a Java <code>int</code>.
+     */
+    public native int getInt(long address);
+
+    public int getInt(long address, Endianness endianness) {
+        return (endianness == NATIVE_ORDER) ? getInt(address)
+                : swap(getInt(address));
+    }
+
+    /**
+     * Sets the value of the signed four-byte integer at the given address in
+     * platform byte order.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 4)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the four-byte value.
+     * @param value
+     *            the value of the four-byte integer as a Java <code>int</code>.
+     */
+    public native void setInt(long address, int value);
+
+    public void setInt(long address, int value, Endianness endianness) {
+        if (endianness == NATIVE_ORDER) {
+            setInt(address, value);
+        } else {
+            setInt(address, swap(value));
+        }
+    }
+
+    /**
+     * Gets the value of the signed eight-byte integer stored in platform byte
+     * order at the given address.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 8)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the eight-byte value.
+     * @return the value of the eight-byte integer as a Java <code>long</code>.
+     */
+    public native long getLong(long address);
+
+    public long getLong(long address, Endianness endianness) {
+        return (endianness == NATIVE_ORDER) ? getLong(address)
+                : swap(getLong(address));
+    }
+
+    /**
+     * Sets the value of the signed eight-byte integer at the given address in
+     * the platform byte order.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 8)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the eight-byte value.
+     * @param value
+     *            the value of the eight-byte integer as a Java
+     *            <code>long</code>.
+     */
+    public native void setLong(long address, long value);
+
+    public void setLong(long address, long value, Endianness endianness) {
+        if (endianness == NATIVE_ORDER) {
+            setLong(address, value);
+        } else {
+            setLong(address, swap(value));
+        }
+    }
+
+    /**
+     * Gets the value of the IEEE754-format four-byte float stored in platform
+     * byte order at the given address.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 4)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the eight-byte value.
+     * @return the value of the four-byte float as a Java <code>float</code>.
+     */
+    public native float getFloat(long address);
+
+    public float getFloat(long address, Endianness endianness) {
+        if (endianness == NATIVE_ORDER) {
+            return getFloat(address);
+        }
+        int floatBits = swap(getInt(address));
+        return Float.intBitsToFloat(floatBits);
+    }
+
+    /**
+     * Sets the value of the IEEE754-format four-byte float stored in platform
+     * byte order at the given address.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 4)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the eight-byte value.
+     * @param value
+     *            the value of the four-byte float as a Java <code>float</code>.
+     */
+    public native void setFloat(long address, float value);
+
+    public void setFloat(long address, float value, Endianness endianness) {
+        if (endianness == NATIVE_ORDER) {
+            setFloat(address, value);
+        } else {
+            int floatBits = Float.floatToIntBits(value);
+            setInt(address, swap(floatBits));
+        }
+    }
+
+    /**
+     * Gets the value of the IEEE754-format eight-byte float stored in platform
+     * byte order at the given address.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 8)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the eight-byte value.
+     * @return the value of the eight-byte float as a Java <code>double</code>.
+     */
+    public native double getDouble(long address);
+
+    public double getDouble(long address, Endianness endianness) {
+        if (endianness == NATIVE_ORDER) {
+            return getDouble(address);
+        }
+        long doubleBits = swap(getLong(address));
+        return Double.longBitsToDouble(doubleBits);
+    }
+
+    /**
+     * Sets the value of the IEEE754-format eight-byte float store in platform
+     * byte order at the given address.
+     * <p>
+     * The behavior is unspecified if <code>(address ... address + 8)</code>
+     * is not wholly within the range that was previously allocated using
+     * <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the eight-byte value.
+     * @param value
+     *            the value of the eight-byte float as a Java
+     *            <code>double</code>.
+     */
+    public native void setDouble(long address, double value);
+
+    public void setDouble(long address, double value, Endianness endianness) {
+        if (endianness == NATIVE_ORDER) {
+            setDouble(address, value);
+        } else {
+            long doubleBits = Double.doubleToLongBits(value);
+            setLong(address, swap(doubleBits));
+        }
+    }
+
+    /**
+     * Gets the value of the platform pointer at the given address.
+     * <p>
+     * The length of the platform pointer is defined by
+     * <code>POINTER_SIZE</code>.
+     * </p>
+     * The behavior is unspecified if
+     * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
+     * the range that was previously allocated using <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the platform pointer.
+     * @return the value of the platform pointer as a Java <code>long</code>.
+     */
+    public native long getAddress(long address);
+
+    /**
+     * Sets the value of the platform pointer at the given address.
+     * <p>
+     * The length of the platform pointer is defined by
+     * <code>POINTER_SIZE</code>. This method only sets
+     * <code>POINTER_SIZE</code> bytes at the given address.
+     * </p>
+     * The behavior is unspecified if
+     * <code>(address ... address + POINTER_SIZE)</code> is not wholly within
+     * the range that was previously allocated using <code>malloc()</code>.
+     * </p>
+     * 
+     * @param address
+     *            the platform address of the start of the platform pointer.
+     * @param value
+     *            the value of the platform pointer as a Java <code>long</code>.
+     */
+    public native void setAddress(long address, long value);
+
+    /*
+     * Memory mapped file
+     */
+    private native long mmapImpl(long fileDescriptor, long alignment,
+            long size, int mapMode);
+
+    public long mmap(long fileDescriptor, long alignment, long size,
+            int mapMode) throws IOException {
                 // No need to check mmapImpl return as it throws IOException in error cases
-		long address = mmapImpl(fileDescriptor, alignment, size, mapMode);
-		return address;
-	}
-
-	private native void unmapImpl(long addr, long size);
-
-	public void unmap(long addr, long size) {
-		unmapImpl(addr, size);
-	}
-
-	public void load(long addr, long size) {
-		loadImpl(addr, size);
-	}
-
-	private native int loadImpl(long l, long size);
-
-	public boolean isLoaded(long addr, long size) {
-		return size == 0 ? true : isLoadedImpl(addr, size);
-	}
-
-	private native boolean isLoadedImpl(long l, long size);
-
-	public void flush(long addr, long size) {
-		flushImpl(addr, size);
-	}
-
-	private native int flushImpl(long l, long size);
-
-	/*
-	 * Helper methods to change byte order.
-	 */
-	private short swap(short value) {
-		int topEnd = value << 8;
-		int btmEnd = (value >> 8) & 0xFF;
-		return (short) (topEnd | btmEnd);
-	}
-
-	private int swap(int value) {
-		short left = (short) (value >> 16);
-		short right = (short) value;
-		int topEnd = swap(right) << 16;
-		int btmEnd = swap(left) & 0xFFFF;
-		return topEnd | btmEnd;
-	}
-
-	private long swap(long value) {
-		int left = (int) (value >> 32);
-		int right = (int) value;
-		long topEnd = ((long) swap(right)) << 32;
-		long btmEnd = swap(left) & 0xFFFFFFFFL;
-		return topEnd | btmEnd;
-	}
+        long address = mmapImpl(fileDescriptor, alignment, size, mapMode);
+        return address;
+    }
+
+    private native void unmapImpl(long addr, long size);
+
+    public void unmap(long addr, long size) {
+        unmapImpl(addr, size);
+    }
+
+    public void load(long addr, long size) {
+        loadImpl(addr, size);
+    }
+
+    private native int loadImpl(long l, long size);
+
+    public boolean isLoaded(long addr, long size) {
+        return size == 0 ? true : isLoadedImpl(addr, size);
+    }
+
+    private native boolean isLoadedImpl(long l, long size);
+
+    public void flush(long addr, long size) {
+        flushImpl(addr, size);
+    }
+
+    private native int flushImpl(long l, long size);
+
+    /*
+     * Helper methods to change byte order.
+     */
+    private short swap(short value) {
+        int topEnd = value << 8;
+        int btmEnd = (value >> 8) & 0xFF;
+        return (short) (topEnd | btmEnd);
+    }
+
+    private int swap(int value) {
+        short left = (short) (value >> 16);
+        short right = (short) value;
+        int topEnd = swap(right) << 16;
+        int btmEnd = swap(left) & 0xFFFF;
+        return topEnd | btmEnd;
+    }
+
+    private long swap(long value) {
+        int left = (int) (value >> 32);
+        int right = (int) value;
+        long topEnd = ((long) swap(right)) << 32;
+        long btmEnd = swap(left) & 0xFFFFFFFFL;
+        return topEnd | btmEnd;
+    }
 }

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java?rev=824209&r1=824208&r2=824209&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/platform/RuntimeMemorySpy.java Mon Oct 12 00:55:27 2009
@@ -20,18 +20,18 @@
 
 final class RuntimeMemorySpy extends AbstractMemorySpy {
 
-	public RuntimeMemorySpy() {
-		super();
-	}
+    public RuntimeMemorySpy() {
+        super();
+    }
 
-	public void alloc(PlatformAddress address) {
-		// Pay a tax on the allocation to see if there are any frees pending.
-		Reference ref = notifyQueue.poll(); // non-blocking check
-		while (ref != null) {
-			orphanedMemory(ref);
-			ref = notifyQueue.poll();
-		}
+    public void alloc(PlatformAddress address) {
+        // Pay a tax on the allocation to see if there are any frees pending.
+        Reference ref = notifyQueue.poll(); // non-blocking check
+        while (ref != null) {
+            orphanedMemory(ref);
+            ref = notifyQueue.poll();
+        }
 
         super.alloc(address);
-	}
+    }
 }



Mime
View raw message