generator/src/main/java/com/google/archivepatcher/generator/bsdiff/RandomAccessObject.java - platform/external/archive-patcher - Git at Google

 // Copyright 2016 Google Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.google.archivepatcher.generator.bsdiff;

 import java.io.Closeable;
 import java.io.DataInput;
 import java.io.DataOutput;
 import java.io.File;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;

 // TODO(andrewhayden): clean up the implementations, we only really need two and they can be in
 // separate files.

 /**
  * Interface which offers random access interface. This class exists to allow BsDiff to use either
  * a RandomAccessFile for disk-based io, or a byte[] for fully in-memory operation.
  */
 public interface RandomAccessObject extends DataInput, DataOutput, Closeable {

   /**
    * Returns the length of the file or byte array associated with the RandomAccessObject.
    *
    * @return the length of the file or byte array associated with the RandomAccessObject
    * @throws IOException if unable to determine the length of the file, when backed by a file
    */
   public long length() throws IOException;

   /**
    * Seeks to a specified position, in bytes, into the file or byte array.
    *
    * @param pos the position to seek to
    * @throws IOException if seeking fails
    */
   public void seek(long pos) throws IOException;

   /**
    * Seek to a specified integer-aligned position in the associated file or byte array. For example,
    * seekToIntAligned(5) will seek to the beginning of the 5th integer, or in other words the 20th
    * byte. In general, seekToIntAligned(n) will seek to byte 4n.
    *
    * @param pos the position to seek to
    * @throws IOException if seeking fails
    */
   public void seekToIntAligned(long pos) throws IOException;

   /**
    * A {@link RandomAccessFile}-based implementation of {@link RandomAccessObject} which just
    * delegates all operations to the equivalents in {@link RandomAccessFile}. Slower than the
    * {@link RandomAccessMmapObject} implementation.
    */
   public static final class RandomAccessFileObject extends RandomAccessFile
       implements RandomAccessObject {
     private final boolean mShouldDeleteFileOnClose;
     private final File mFile;

     /**
      * This constructor takes in a temporary file. This constructor does not take ownership of the
      * file, and the file will not be deleted on {@link #close()}.
      *
      * @param tempFile the file backing this object
      * @param mode the mode to use, e.g. "r" or "w" for read or write
      * @throws IOException if unable to open the file for the specified mode
      */
     public RandomAccessFileObject(final File tempFile, final String mode) throws IOException {
       this(tempFile, mode, false);
     }

     /**
      * This constructor takes in a temporary file. If deleteFileOnClose is true, the constructor
      * takes ownership of that file, and this file is deleted on close().
      *
      * @param tempFile the file backing this object
      * @param mode the mode to use, e.g. "r" or "w" for read or write
      * @param deleteFileOnClose if true the constructor takes ownership of that file, and this file
      *     is deleted on close().
      * @throws IOException if unable to open the file for the specified mode
      * @throws IllegalArgumentException if the size of the file is too great
      */
     // TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
     // really be the responsibility of RandomAccessObject.
     public RandomAccessFileObject(final File tempFile, final String mode, boolean deleteFileOnClose)
         throws IOException {
       super(tempFile, mode);
       mShouldDeleteFileOnClose = deleteFileOnClose;
       mFile = tempFile;
       if (mShouldDeleteFileOnClose) {
         mFile.deleteOnExit();
       }
     }

     @Override
     public void seekToIntAligned(long pos) throws IOException {
       seek(pos * 4);
     }

     /**
      * Close the associated file. Also delete the associated temp file if specified in the
      * constructor. This should be called on every RandomAccessObject when it is no longer needed.
      */
     // TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
     // really be the responsibility of RandomAccessObject.
     @Override
     public void close() throws IOException {
       super.close();
       if (mShouldDeleteFileOnClose) {
         mFile.delete();
       }
     }
   }

   /**
    * An array-based implementation of {@link RandomAccessObject} for entirely in-memory operations.
    */
   public static class RandomAccessByteArrayObject implements RandomAccessObject {
     protected ByteBuffer mByteBuffer;

     /**
      * The passed-in byte array will be treated as big-endian when dealing with ints.
      *
      * @param byteArray the byte array to wrap
      */
     public RandomAccessByteArrayObject(final byte[] byteArray) {
       mByteBuffer = ByteBuffer.wrap(byteArray);
     }

     /**
      * Allocate a new ByteBuffer of given length. This will be treated as big-endian.
      *
      * @param length the length of the buffer to allocate
      */
     public RandomAccessByteArrayObject(final int length) {
       mByteBuffer = ByteBuffer.allocate(length);
     }

     protected RandomAccessByteArrayObject() {
       // No-op, this is just used by the extending class RandomAccessMmapObject.
     }

     @Override
     public long length() {
       return mByteBuffer.capacity();
     }

     @Override
     public byte readByte() {
       return mByteBuffer.get();
     }

     /**
      * Reads an integer from the underlying data array in big-endian order.
      */
     @Override
     public int readInt() {
       return mByteBuffer.getInt();
     }

     public void writeByte(byte b) {
       mByteBuffer.put(b);
     }

     @Override
     public void writeInt(int i) {
       mByteBuffer.putInt(i);
     }

     /**
      * RandomAccessByteArrayObject.seek() only supports addresses up to 2^31-1, due to the fact
      * that it needs to support byte[] backend (and in Java, arrays are indexable only by int).
      * This means that it can only seek up to a 2GiB byte[].
      */
     @Override
     public void seek(long pos) {
       if (pos > Integer.MAX_VALUE) {
         throw new IllegalArgumentException(
             "RandomAccessByteArrayObject can only handle seek() "
                 + "addresses up to Integer.MAX_VALUE.");
       }

       mByteBuffer.position((int) pos);
     }

     @Override
     public void seekToIntAligned(long pos) {
       seek(pos * 4);
     }

     @Override
     public void close() throws IOException {
       // Nothing necessary.
     }

     @Override
     public boolean readBoolean() {
       return readByte() != 0;
     }

     @Override
     public char readChar() {
       return mByteBuffer.getChar();
     }

     @Override
     public double readDouble() {
       return mByteBuffer.getDouble();
     }

     @Override
     public float readFloat() {
       return mByteBuffer.getFloat();
     }

     @Override
     public void readFully(byte[] b) {
       mByteBuffer.get(b);
     }

     @Override
     public void readFully(byte[] b, int off, int len) {
       mByteBuffer.get(b, off, len);
     }

     @Override
     public String readLine() {
       throw new UnsupportedOperationException();
     }

     @Override
     public long readLong() {
       return mByteBuffer.getLong();
     }

     @Override
     public short readShort() {
       return mByteBuffer.getShort();
     }

     @Override
     public int readUnsignedByte() {
       return mByteBuffer.get() & 0xff;
     }

     @Override
     public int readUnsignedShort() {
       throw new UnsupportedOperationException();
     }

     @Override
     public String readUTF() {
       throw new UnsupportedOperationException();
     }

     @Override
     public int skipBytes(int n) {
       mByteBuffer.position(mByteBuffer.position() + n);
       return n;
     }

     @Override
     public void write(byte[] b) {
       mByteBuffer.put(b);
     }

     @Override
     public void write(byte[] b, int off, int len) {
       mByteBuffer.put(b, off, len);
     }

     @Override
     public void write(int b) {
       writeByte((byte) b);
     }

     @Override
     public void writeBoolean(boolean v) {
       writeByte(v ? (byte) 1 : (byte) 0);
     }

     @Override
     public void writeByte(int v) {
       writeByte((byte) v);
     }

     @Override
     public void writeBytes(String s) {
       for (int x = 0; x < s.length(); x++) {
         writeByte((byte) s.charAt(x));
       }
     }

     @Override
     public void writeChar(int v) {
       mByteBuffer.putChar((char) v);
     }

     @Override
     public void writeChars(String s) {
       for (int x = 0; x < s.length(); x++) {
         writeChar(s.charAt(x));
       }
     }

     @Override
     public void writeDouble(double v) {
       mByteBuffer.putDouble(v);
     }

     @Override
     public void writeFloat(float v) {
       mByteBuffer.putFloat(v);
     }

     @Override
     public void writeLong(long v) {
       mByteBuffer.putLong(v);
     }

     @Override
     public void writeShort(int v) {
       mByteBuffer.putShort((short) v);
     }

     @Override
     public void writeUTF(String s) {
       throw new UnsupportedOperationException();
     }
   }

   /**
    * A {@link ByteBuffer}-based implementation of {@link RandomAccessObject} that uses files on
    * disk, but is significantly faster than the RandomAccessFile implementation.
    */
   public static final class RandomAccessMmapObject extends RandomAccessByteArrayObject {
     private final boolean mShouldDeleteFileOnRelease;
     private final File mFile;
     private final FileChannel mFileChannel;

     public RandomAccessMmapObject(final RandomAccessFile randomAccessFile, String mode)
         throws IOException, IllegalArgumentException {
       if (randomAccessFile.length() > Integer.MAX_VALUE) {
         throw new IllegalArgumentException("Only files up to 2GiB in size are supported.");
       }

       FileChannel.MapMode mapMode;
       if (mode.equals("r")) {
         mapMode = FileChannel.MapMode.READ_ONLY;
       } else {
         mapMode = FileChannel.MapMode.READ_WRITE;
       }

       mFileChannel = randomAccessFile.getChannel();
       mByteBuffer = mFileChannel.map(mapMode, 0, randomAccessFile.length());
       mByteBuffer.position(0);
       mShouldDeleteFileOnRelease = false;
       mFile = null;
     }

     /**
      * This constructor creates a temporary file. This file is deleted on close(), so be sure to
      * call it when you're done, otherwise it'll leave stray files.
      *
      * @param tempFileName the path to the file backing this object
      * @param mode the mode to use, e.g. "r" or "w" for read or write
      * @param length the size of the file to be read or written
      * @throws IOException if unable to open the file for the specified mode
      * @throws IllegalArgumentException if the size of the file is too great
      */
     // TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
     // really be the responsibility of RandomAccessObject.
     @SuppressWarnings("resource") // RandomAccessFile deliberately left open
     public RandomAccessMmapObject(final String tempFileName, final String mode, long length)
         throws IOException, IllegalArgumentException {
       if (length > Integer.MAX_VALUE) {
         throw new IllegalArgumentException(
             "RandomAccessMmapObject only supports file sizes up to " + "Integer.MAX_VALUE.");
       }

       mFile = File.createTempFile(tempFileName, "temp");
       mFile.deleteOnExit();
       mShouldDeleteFileOnRelease = true;

       FileChannel.MapMode mapMode;
       if (mode.equals("r")) {
         mapMode = FileChannel.MapMode.READ_ONLY;
       } else {
         mapMode = FileChannel.MapMode.READ_WRITE;
       }

       RandomAccessFile file = null;
       try {
         file = new RandomAccessFile(mFile, mode);
         mFileChannel = file.getChannel();
         mByteBuffer = mFileChannel.map(mapMode, 0, (int) length);
         mByteBuffer.position(0);
       } catch (IOException e) {
         if (file != null) {
           try {
             file.close();
           } catch (Exception ignored) {
             // Nothing more can be done
           }
         }
         close();
         throw new IOException("Unable to open file", e);
       }
     }

     /**
      * This constructor takes in a temporary file, and takes ownership of that file. This file is
      * deleted on close() OR IF THE CONSTRUCTOR FAILS. The main purpose of this constructor is to
      * test close() on the passed-in file.
      *
      * @param tempFile the the file backing this object
      * @param mode the mode to use, e.g. "r" or "w" for read or write
      * @throws IOException if unable to open the file for the specified mode
      * @throws IllegalArgumentException if the size of the file is too great
      */
     // TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
     // really be the responsibility of RandomAccessObject.
     @SuppressWarnings("resource") // RandomAccessFile deliberately left open
     public RandomAccessMmapObject(final File tempFile, final String mode)
         throws IOException, IllegalArgumentException {
       if (tempFile.length() > Integer.MAX_VALUE) {
         throw new IllegalArgumentException("Only files up to 2GiB in size are supported.");
       }

       mFile = tempFile;
       mFile.deleteOnExit();
       mShouldDeleteFileOnRelease = true;

       FileChannel.MapMode mapMode;
       if (mode.equals("r")) {
         mapMode = FileChannel.MapMode.READ_ONLY;
       } else {
         mapMode = FileChannel.MapMode.READ_WRITE;
       }

       RandomAccessFile file = null;
       try {
         file = new RandomAccessFile(mFile, mode);
         mFileChannel = file.getChannel();
         mByteBuffer = mFileChannel.map(mapMode, 0, tempFile.length());
         mByteBuffer.position(0);
       } catch (IOException e) {
         if (file != null) {
           try {
             file.close();
           } catch (Exception ignored) {
             // Nothing more can be done
           }
         }
         close();
         throw new IOException("Unable to open file", e);
       }
     }

     @Override
     public void close() throws IOException {
       if (mFileChannel != null) {
         mFileChannel.close();
       }

       // There is a long-standing bug with memory mapped objects in Java that requires the JVM to
       // finalize the MappedByteBuffer reference before the unmap operation is performed. This leaks
       // file handles and fills the virtual address space. Worse, on some systems (Windows for one)
       // the active mmap prevents the temp file from being deleted - even if File.deleteOnExit() is
       // used. The only safe way to ensure that file handles and actual files are not leaked by this
       // class is to force an explicit full gc after explicitly nulling the MappedByteBuffer
       // reference. This has to be done before attempting file deletion.
       //
       // See https://github.com/andrewhayden/archive-patcher/issues/5 for more information.
       mByteBuffer = null;
       System.gc();

       if (mShouldDeleteFileOnRelease && mFile != null) {
         mFile.delete();
       }

     }
   }
 }
	// Copyright 2016 Google Inc. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.google.archivepatcher.generator.bsdiff;

	import java.io.Closeable;
	import java.io.DataInput;
	import java.io.DataOutput;
	import java.io.File;
	import java.io.IOException;
	import java.io.RandomAccessFile;
	import java.nio.ByteBuffer;
	import java.nio.channels.FileChannel;

	// TODO(andrewhayden): clean up the implementations, we only really need two and they can be in
	// separate files.

	/**
	* Interface which offers random access interface. This class exists to allow BsDiff to use either
	* a RandomAccessFile for disk-based io, or a byte[] for fully in-memory operation.
	*/
	public interface RandomAccessObject extends DataInput, DataOutput, Closeable {

	/**
	* Returns the length of the file or byte array associated with the RandomAccessObject.
	*
	* @return the length of the file or byte array associated with the RandomAccessObject
	* @throws IOException if unable to determine the length of the file, when backed by a file
	*/
	public long length() throws IOException;

	/**
	* Seeks to a specified position, in bytes, into the file or byte array.
	*
	* @param pos the position to seek to
	* @throws IOException if seeking fails
	*/
	public void seek(long pos) throws IOException;

	/**
	* Seek to a specified integer-aligned position in the associated file or byte array. For example,
	* seekToIntAligned(5) will seek to the beginning of the 5th integer, or in other words the 20th
	* byte. In general, seekToIntAligned(n) will seek to byte 4n.
	*
	* @param pos the position to seek to
	* @throws IOException if seeking fails
	*/
	public void seekToIntAligned(long pos) throws IOException;

	/**
	* A {@link RandomAccessFile}-based implementation of {@link RandomAccessObject} which just
	* delegates all operations to the equivalents in {@link RandomAccessFile}. Slower than the
	* {@link RandomAccessMmapObject} implementation.
	*/
	public static final class RandomAccessFileObject extends RandomAccessFile
	implements RandomAccessObject {
	private final boolean mShouldDeleteFileOnClose;
	private final File mFile;

	/**
	* This constructor takes in a temporary file. This constructor does not take ownership of the
	* file, and the file will not be deleted on {@link #close()}.
	*
	* @param tempFile the file backing this object
	* @param mode the mode to use, e.g. "r" or "w" for read or write
	* @throws IOException if unable to open the file for the specified mode
	*/
	public RandomAccessFileObject(final File tempFile, final String mode) throws IOException {
	this(tempFile, mode, false);
	}

	/**
	* This constructor takes in a temporary file. If deleteFileOnClose is true, the constructor
	* takes ownership of that file, and this file is deleted on close().
	*
	* @param tempFile the file backing this object
	* @param mode the mode to use, e.g. "r" or "w" for read or write
	* @param deleteFileOnClose if true the constructor takes ownership of that file, and this file
	* is deleted on close().
	* @throws IOException if unable to open the file for the specified mode
	* @throws IllegalArgumentException if the size of the file is too great
	*/
	// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
	// really be the responsibility of RandomAccessObject.
	public RandomAccessFileObject(final File tempFile, final String mode, boolean deleteFileOnClose)
	throws IOException {
	super(tempFile, mode);
	mShouldDeleteFileOnClose = deleteFileOnClose;
	mFile = tempFile;
	if (mShouldDeleteFileOnClose) {
	mFile.deleteOnExit();
	}
	}

	@Override
	public void seekToIntAligned(long pos) throws IOException {
	seek(pos * 4);
	}

	/**
	* Close the associated file. Also delete the associated temp file if specified in the
	* constructor. This should be called on every RandomAccessObject when it is no longer needed.
	*/
	// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
	// really be the responsibility of RandomAccessObject.
	@Override
	public void close() throws IOException {
	super.close();
	if (mShouldDeleteFileOnClose) {
	mFile.delete();
	}
	}
	}

	/**
	* An array-based implementation of {@link RandomAccessObject} for entirely in-memory operations.
	*/
	public static class RandomAccessByteArrayObject implements RandomAccessObject {
	protected ByteBuffer mByteBuffer;

	/**
	* The passed-in byte array will be treated as big-endian when dealing with ints.
	*
	* @param byteArray the byte array to wrap
	*/
	public RandomAccessByteArrayObject(final byte[] byteArray) {
	mByteBuffer = ByteBuffer.wrap(byteArray);
	}

	/**
	* Allocate a new ByteBuffer of given length. This will be treated as big-endian.
	*
	* @param length the length of the buffer to allocate
	*/
	public RandomAccessByteArrayObject(final int length) {
	mByteBuffer = ByteBuffer.allocate(length);
	}

	protected RandomAccessByteArrayObject() {
	// No-op, this is just used by the extending class RandomAccessMmapObject.
	}

	@Override
	public long length() {
	return mByteBuffer.capacity();
	}

	@Override
	public byte readByte() {
	return mByteBuffer.get();
	}

	/**
	* Reads an integer from the underlying data array in big-endian order.
	*/
	@Override
	public int readInt() {
	return mByteBuffer.getInt();
	}

	public void writeByte(byte b) {
	mByteBuffer.put(b);
	}

	@Override
	public void writeInt(int i) {
	mByteBuffer.putInt(i);
	}

	/**
	* RandomAccessByteArrayObject.seek() only supports addresses up to 2^31-1, due to the fact
	* that it needs to support byte[] backend (and in Java, arrays are indexable only by int).
	* This means that it can only seek up to a 2GiB byte[].
	*/
	@Override
	public void seek(long pos) {
	if (pos > Integer.MAX_VALUE) {
	throw new IllegalArgumentException(
	"RandomAccessByteArrayObject can only handle seek() "
	+ "addresses up to Integer.MAX_VALUE.");
	}

	mByteBuffer.position((int) pos);
	}

	@Override
	public void seekToIntAligned(long pos) {
	seek(pos * 4);
	}

	@Override
	public void close() throws IOException {
	// Nothing necessary.
	}

	@Override
	public boolean readBoolean() {
	return readByte() != 0;
	}

	@Override
	public char readChar() {
	return mByteBuffer.getChar();
	}

	@Override
	public double readDouble() {
	return mByteBuffer.getDouble();
	}

	@Override
	public float readFloat() {
	return mByteBuffer.getFloat();
	}

	@Override
	public void readFully(byte[] b) {
	mByteBuffer.get(b);
	}

	@Override
	public void readFully(byte[] b, int off, int len) {
	mByteBuffer.get(b, off, len);
	}

	@Override
	public String readLine() {
	throw new UnsupportedOperationException();
	}

	@Override
	public long readLong() {
	return mByteBuffer.getLong();
	}

	@Override
	public short readShort() {
	return mByteBuffer.getShort();
	}

	@Override
	public int readUnsignedByte() {
	return mByteBuffer.get() & 0xff;
	}

	@Override
	public int readUnsignedShort() {
	throw new UnsupportedOperationException();
	}

	@Override
	public String readUTF() {
	throw new UnsupportedOperationException();
	}

	@Override
	public int skipBytes(int n) {
	mByteBuffer.position(mByteBuffer.position() + n);
	return n;
	}

	@Override
	public void write(byte[] b) {
	mByteBuffer.put(b);
	}

	@Override
	public void write(byte[] b, int off, int len) {
	mByteBuffer.put(b, off, len);
	}

	@Override
	public void write(int b) {
	writeByte((byte) b);
	}

	@Override
	public void writeBoolean(boolean v) {
	writeByte(v ? (byte) 1 : (byte) 0);
	}

	@Override
	public void writeByte(int v) {
	writeByte((byte) v);
	}

	@Override
	public void writeBytes(String s) {
	for (int x = 0; x < s.length(); x++) {
	writeByte((byte) s.charAt(x));
	}
	}

	@Override
	public void writeChar(int v) {
	mByteBuffer.putChar((char) v);
	}

	@Override
	public void writeChars(String s) {
	for (int x = 0; x < s.length(); x++) {
	writeChar(s.charAt(x));
	}
	}

	@Override
	public void writeDouble(double v) {
	mByteBuffer.putDouble(v);
	}

	@Override
	public void writeFloat(float v) {
	mByteBuffer.putFloat(v);
	}

	@Override
	public void writeLong(long v) {
	mByteBuffer.putLong(v);
	}

	@Override
	public void writeShort(int v) {
	mByteBuffer.putShort((short) v);
	}

	@Override
	public void writeUTF(String s) {
	throw new UnsupportedOperationException();
	}
	}

	/**
	* A {@link ByteBuffer}-based implementation of {@link RandomAccessObject} that uses files on
	* disk, but is significantly faster than the RandomAccessFile implementation.
	*/
	public static final class RandomAccessMmapObject extends RandomAccessByteArrayObject {
	private final boolean mShouldDeleteFileOnRelease;
	private final File mFile;
	private final FileChannel mFileChannel;

	public RandomAccessMmapObject(final RandomAccessFile randomAccessFile, String mode)
	throws IOException, IllegalArgumentException {
	if (randomAccessFile.length() > Integer.MAX_VALUE) {
	throw new IllegalArgumentException("Only files up to 2GiB in size are supported.");
	}

	FileChannel.MapMode mapMode;
	if (mode.equals("r")) {
	mapMode = FileChannel.MapMode.READ_ONLY;
	} else {
	mapMode = FileChannel.MapMode.READ_WRITE;
	}

	mFileChannel = randomAccessFile.getChannel();
	mByteBuffer = mFileChannel.map(mapMode, 0, randomAccessFile.length());
	mByteBuffer.position(0);
	mShouldDeleteFileOnRelease = false;
	mFile = null;
	}

	/**
	* This constructor creates a temporary file. This file is deleted on close(), so be sure to
	* call it when you're done, otherwise it'll leave stray files.
	*
	* @param tempFileName the path to the file backing this object
	* @param mode the mode to use, e.g. "r" or "w" for read or write
	* @param length the size of the file to be read or written
	* @throws IOException if unable to open the file for the specified mode
	* @throws IllegalArgumentException if the size of the file is too great
	*/
	// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
	// really be the responsibility of RandomAccessObject.
	@SuppressWarnings("resource") // RandomAccessFile deliberately left open
	public RandomAccessMmapObject(final String tempFileName, final String mode, long length)
	throws IOException, IllegalArgumentException {
	if (length > Integer.MAX_VALUE) {
	throw new IllegalArgumentException(
	"RandomAccessMmapObject only supports file sizes up to " + "Integer.MAX_VALUE.");
	}

	mFile = File.createTempFile(tempFileName, "temp");
	mFile.deleteOnExit();
	mShouldDeleteFileOnRelease = true;

	FileChannel.MapMode mapMode;
	if (mode.equals("r")) {
	mapMode = FileChannel.MapMode.READ_ONLY;
	} else {
	mapMode = FileChannel.MapMode.READ_WRITE;
	}

	RandomAccessFile file = null;
	try {
	file = new RandomAccessFile(mFile, mode);
	mFileChannel = file.getChannel();
	mByteBuffer = mFileChannel.map(mapMode, 0, (int) length);
	mByteBuffer.position(0);
	} catch (IOException e) {
	if (file != null) {
	try {
	file.close();
	} catch (Exception ignored) {
	// Nothing more can be done
	}
	}
	close();
	throw new IOException("Unable to open file", e);
	}
	}

	/**
	* This constructor takes in a temporary file, and takes ownership of that file. This file is
	* deleted on close() OR IF THE CONSTRUCTOR FAILS. The main purpose of this constructor is to
	* test close() on the passed-in file.
	*
	* @param tempFile the the file backing this object
	* @param mode the mode to use, e.g. "r" or "w" for read or write
	* @throws IOException if unable to open the file for the specified mode
	* @throws IllegalArgumentException if the size of the file is too great
	*/
	// TODO(hartmanng): rethink the handling of these temp files. It's confusing and shouldn't
	// really be the responsibility of RandomAccessObject.
	@SuppressWarnings("resource") // RandomAccessFile deliberately left open
	public RandomAccessMmapObject(final File tempFile, final String mode)
	throws IOException, IllegalArgumentException {
	if (tempFile.length() > Integer.MAX_VALUE) {
	throw new IllegalArgumentException("Only files up to 2GiB in size are supported.");
	}

	mFile = tempFile;
	mFile.deleteOnExit();
	mShouldDeleteFileOnRelease = true;

	FileChannel.MapMode mapMode;
	if (mode.equals("r")) {
	mapMode = FileChannel.MapMode.READ_ONLY;
	} else {
	mapMode = FileChannel.MapMode.READ_WRITE;
	}

	RandomAccessFile file = null;
	try {
	file = new RandomAccessFile(mFile, mode);
	mFileChannel = file.getChannel();
	mByteBuffer = mFileChannel.map(mapMode, 0, tempFile.length());
	mByteBuffer.position(0);
	} catch (IOException e) {
	if (file != null) {
	try {
	file.close();
	} catch (Exception ignored) {
	// Nothing more can be done
	}
	}
	close();
	throw new IOException("Unable to open file", e);
	}
	}

	@Override
	public void close() throws IOException {
	if (mFileChannel != null) {
	mFileChannel.close();
	}

	// There is a long-standing bug with memory mapped objects in Java that requires the JVM to
	// finalize the MappedByteBuffer reference before the unmap operation is performed. This leaks
	// file handles and fills the virtual address space. Worse, on some systems (Windows for one)
	// the active mmap prevents the temp file from being deleted - even if File.deleteOnExit() is
	// used. The only safe way to ensure that file handles and actual files are not leaked by this
	// class is to force an explicit full gc after explicitly nulling the MappedByteBuffer
	// reference. This has to be done before attempting file deletion.
	//
	// See https://github.com/andrewhayden/archive-patcher/issues/5 for more information.
	mByteBuffer = null;
	System.gc();

	if (mShouldDeleteFileOnRelease && mFile != null) {
	mFile.delete();
	}

	}
	}
	}