From 7f10a67804313dc6f2d8838ecccbbea0497d7153 Mon Sep 17 00:00:00 2001
From: zzz <zzz@mail.i2p>
Date: Tue, 8 Feb 2011 00:41:33 +0000
Subject: [PATCH] BlockFile as downloaded

---
 LICENSE.txt                                   |   4 +
 core/java/src/net/metanotion/README-I2P.txt   |  30 ++
 core/java/src/net/metanotion/io/RAIFile.java  | 136 ++++++++
 .../metanotion/io/RandomAccessInterface.java  |  77 +++++
 .../src/net/metanotion/io/SerialStreams.java  |  62 ++++
 .../src/net/metanotion/io/Serializer.java     |  34 ++
 .../net/metanotion/io/block/BlockFile.java    | 291 ++++++++++++++++
 .../metanotion/io/block/FreeListBlock.java    |  89 +++++
 .../io/block/index/BSkipLevels.java           | 112 +++++++
 .../metanotion/io/block/index/BSkipList.java  | 122 +++++++
 .../metanotion/io/block/index/BSkipSpan.java  | 215 ++++++++++++
 .../metanotion/io/block/index/IBSkipSpan.java | 302 +++++++++++++++++
 .../src/net/metanotion/io/data/IntBytes.java  |  51 +++
 .../src/net/metanotion/io/data/LongBytes.java |  59 ++++
 .../src/net/metanotion/io/data/NullBytes.java |  36 ++
 .../net/metanotion/io/data/StringBytes.java   |  47 +++
 core/java/src/net/metanotion/package.html     | 156 +++++++++
 .../util/skiplist/SkipIterator.java           | 105 ++++++
 .../metanotion/util/skiplist/SkipLevels.java  | 168 ++++++++++
 .../metanotion/util/skiplist/SkipList.java    | 311 ++++++++++++++++++
 .../metanotion/util/skiplist/SkipSpan.java    | 267 +++++++++++++++
 licenses/LICENSE-BlockFile.txt                |  26 ++
 22 files changed, 2700 insertions(+)
 create mode 100644 core/java/src/net/metanotion/README-I2P.txt
 create mode 100644 core/java/src/net/metanotion/io/RAIFile.java
 create mode 100644 core/java/src/net/metanotion/io/RandomAccessInterface.java
 create mode 100644 core/java/src/net/metanotion/io/SerialStreams.java
 create mode 100644 core/java/src/net/metanotion/io/Serializer.java
 create mode 100644 core/java/src/net/metanotion/io/block/BlockFile.java
 create mode 100644 core/java/src/net/metanotion/io/block/FreeListBlock.java
 create mode 100644 core/java/src/net/metanotion/io/block/index/BSkipLevels.java
 create mode 100644 core/java/src/net/metanotion/io/block/index/BSkipList.java
 create mode 100644 core/java/src/net/metanotion/io/block/index/BSkipSpan.java
 create mode 100644 core/java/src/net/metanotion/io/block/index/IBSkipSpan.java
 create mode 100644 core/java/src/net/metanotion/io/data/IntBytes.java
 create mode 100644 core/java/src/net/metanotion/io/data/LongBytes.java
 create mode 100644 core/java/src/net/metanotion/io/data/NullBytes.java
 create mode 100644 core/java/src/net/metanotion/io/data/StringBytes.java
 create mode 100644 core/java/src/net/metanotion/package.html
 create mode 100644 core/java/src/net/metanotion/util/skiplist/SkipIterator.java
 create mode 100644 core/java/src/net/metanotion/util/skiplist/SkipLevels.java
 create mode 100644 core/java/src/net/metanotion/util/skiplist/SkipList.java
 create mode 100644 core/java/src/net/metanotion/util/skiplist/SkipSpan.java
 create mode 100644 licenses/LICENSE-BlockFile.txt

diff --git a/LICENSE.txt b/LICENSE.txt
index f36fa5a439..0539f2bcdb 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -72,6 +72,10 @@ Public domain except as listed below:
    Contains some code Copyright 2006 Sun Microsystems, Inc.
    See licenses/LICENSE-InstallCert.txt
 
+   BlockFile:
+   Copyright (c) 2006, Matthew Estes
+   See licenses/LICENSE-BlockFile.txt
+
 
 Router:
 Public domain except as listed below:
diff --git a/core/java/src/net/metanotion/README-I2P.txt b/core/java/src/net/metanotion/README-I2P.txt
new file mode 100644
index 0000000000..7e877d0442
--- /dev/null
+++ b/core/java/src/net/metanotion/README-I2P.txt
@@ -0,0 +1,30 @@
+Version 0.1.1 from http://www.metanotion.net/software/sandbox/block.html
+
+License: See any source file.
+
+Changes for i2p:
+
+- BSkipList has an option to not keep everything in memory.
+  When this option is enabled, we use the new IBSkipSpan instead of
+  BSkipSpan. IBSkipSpan has the following changes:
+   * Only the first key in the span, and no values, are stored in memory
+   * put() and remove() read the span keys and values in from disk first
+   * flush() nulls out the keys and values after flushing to disk
+   * get() does a linear search through the keys on disk
+
+- The metaIndex is stored in-memory. All "user" skiplists are not
+  stored in-memory.
+
+- Default span size changed from 127 to 16
+
+- Use I2P random source
+
+- Return the previous SkipList if still open from a call to getIndex()
+
+- Add a closeIndex() method
+
+- Commented out some System.out.println()
+
+TODO:
+
+- Change PAGESIZE from default 1024 to 4096? No, wastes too much disk.
diff --git a/core/java/src/net/metanotion/io/RAIFile.java b/core/java/src/net/metanotion/io/RAIFile.java
new file mode 100644
index 0000000000..c947a7291d
--- /dev/null
+++ b/core/java/src/net/metanotion/io/RAIFile.java
@@ -0,0 +1,136 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+public class RAIFile implements RandomAccessInterface, DataInput, DataOutput {
+	private File f;
+	private RandomAccessFile delegate;
+	private boolean r=false, w=false;
+
+	public RAIFile(RandomAccessFile file) throws FileNotFoundException {
+		this.f = null;
+		this.delegate = file;
+	}
+
+	public RAIFile(File file, boolean read, boolean write) throws FileNotFoundException {
+		this.f = file;
+		this.r = read;
+		this.w = write;
+		String mode = "";
+		if(this.r) { mode += "r"; }
+		if(this.w) { mode += "w"; }
+		this.delegate = new RandomAccessFile(file, mode);
+	}
+
+	public long getFilePointer()		throws IOException { return delegate.getFilePointer(); }
+	public long length()				throws IOException { return delegate.length(); }
+	public int read()					throws IOException { return delegate.read(); }
+	public int read(byte[] b)			throws IOException { return delegate.read(b); }
+	public int read(byte[] b, int off, int len) throws IOException { return delegate.read(b,off,len); }
+	public void seek(long pos)			throws IOException { delegate.seek(pos); }
+	public void setLength(long newLength) throws IOException { delegate.setLength(newLength); }
+
+	// Closeable Methods
+	// TODO May need to change.
+	public void close()					throws IOException { delegate.close(); }
+
+	// DataInput Methods
+	public boolean readBoolean()		throws IOException { return delegate.readBoolean(); }
+	public byte readByte()				throws IOException { return delegate.readByte(); }
+	public char readChar()				throws IOException { return delegate.readChar(); }
+	public double readDouble()			throws IOException { return delegate.readDouble(); }
+	public float readFloat()			throws IOException { return delegate.readFloat(); }
+	public void readFully(byte[] b)		throws IOException { delegate.readFully(b); }
+	public void readFully(byte[] b, int off, int len) throws IOException { delegate.readFully(b,off,len); }
+	public int readInt()				throws IOException { return delegate.readInt(); }
+	public String readLine()			throws IOException { return delegate.readLine(); }
+	public long readLong()				throws IOException { return delegate.readLong(); }
+	public short readShort()			throws IOException { return delegate.readShort(); }
+	public int readUnsignedByte()		throws IOException { return delegate.readUnsignedByte(); }
+	public int readUnsignedShort()		throws IOException { return delegate.readUnsignedShort(); }
+
+	/** Read a UTF encoded string
+	 	I would delegate here. But Java's read/writeUTF combo suck.
+	 	A signed 2 byte length is not enough.
+	 	This reads a 4 byte length.
+	 	The upper byte MUST be zero, if its not, then its not this method and has used an
+	 	extensible length encoding.
+	 	This is followed by the bytes of the UTF encoded string, as
+	 	returned by String.getBytes("UTF-8");
+	*/
+	public String readUTF()				throws IOException {
+		int len = delegate.readInt();
+		if((len < 0) || (len >= 16777216)) { throw new IOException("Bad Length Encoding"); }
+		byte[] bytes = new byte[len];
+		int l = delegate.read(bytes);
+		if(l==-1) { throw new IOException("EOF while reading String"); }
+		String s = new String(bytes, "UTF-8");
+		return s;
+	}
+
+	public int skipBytes(int n)			throws IOException { return delegate.skipBytes(n); }
+
+	// DataOutput Methods
+	public void write(int b)			throws IOException { delegate.write(b); }
+	public void write(byte[] b)			throws IOException { delegate.write(b); }
+	public void write(byte[] b, int off, int len) throws IOException { delegate.write(b,off,len); }
+	public void writeBoolean(boolean v)	throws IOException { delegate.writeBoolean(v); }
+	public void writeByte(int v)		throws IOException { delegate.writeByte(v); }
+	public void writeShort(int v)		throws IOException { delegate.writeShort(v); }
+	public void writeChar(int v)		throws IOException { delegate.writeChar(v); }
+	public void writeInt(int v)			throws IOException {  delegate.writeInt(v); }
+	public void writeLong(long v)		throws IOException {  delegate.writeLong(v); }
+	public void writeFloat(float v)		throws IOException { delegate.writeFloat(v); }
+	public void writeDouble(double v)	throws IOException { delegate.writeDouble(v); }
+	public void writeBytes(String s)	throws IOException { delegate.writeBytes(s); }
+	public void writeChars(String s)	throws IOException { delegate.writeChars(s); }
+
+	/** Write a UTF encoded string
+	 	I would delegate here. But Java's read/writeUTF combo suck.
+	 	A signed 2 byte length is not enough.
+	 	This writes a 4 byte length.
+	 	The upper byte MUST be zero, if its not, then its not this method and has used an
+	 	extensible length encoding.
+	 	This is followed by the bytes of the UTF encoded string, as
+	 	returned by String.getBytes("UTF-8");
+	*/
+	public void writeUTF(String str)	throws IOException {
+		byte[] string = str.getBytes("UTF-8");
+		if(string.length >= 16777216) { throw new IOException("String to long for encoding type"); }
+		delegate.writeInt(string.length);
+		delegate.write(string);
+	}
+}
diff --git a/core/java/src/net/metanotion/io/RandomAccessInterface.java b/core/java/src/net/metanotion/io/RandomAccessInterface.java
new file mode 100644
index 0000000000..227e36c666
--- /dev/null
+++ b/core/java/src/net/metanotion/io/RandomAccessInterface.java
@@ -0,0 +1,77 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io;
+
+import java.io.IOException;
+
+public interface RandomAccessInterface {
+	public long getFilePointer() throws IOException;
+	public long length() throws IOException;
+	public int read() throws IOException;
+	public int read(byte[] b) throws IOException;
+	public int read(byte[] b, int off, int len) throws IOException;
+	public void seek(long pos) throws IOException;
+	public void setLength(long newLength) throws IOException;
+
+	// Closeable Methods
+	public void close() throws IOException;
+
+	// DataInput Methods
+	public boolean readBoolean() throws IOException;
+	public byte readByte() throws IOException;
+	public char readChar() throws IOException;
+	public double readDouble() throws IOException;
+	public float readFloat() throws IOException;
+	public void readFully(byte[] b) throws IOException;
+	public void readFully(byte[] b, int off, int len) throws IOException;
+	public int readInt() throws IOException;
+	public String readLine() throws IOException;
+	public long readLong() throws IOException;
+	public short readShort() throws IOException;
+	public int readUnsignedByte() throws IOException;
+	public int readUnsignedShort() throws IOException;
+	public String readUTF() throws IOException;
+	public int skipBytes(int n) throws IOException;
+
+	// DataOutput Methods
+	public void write(int b) throws IOException;
+	public void write(byte[] b) throws IOException;
+	public void write(byte[] b, int off, int len) throws IOException;
+	public void writeBoolean(boolean v) throws IOException;
+	public void writeByte(int v) throws IOException;
+	public void writeShort(int v) throws IOException;
+	public void writeChar(int v) throws IOException;
+	public void writeInt(int v) throws IOException;
+	public void writeLong(long v) throws IOException;
+	public void writeFloat(float v) throws IOException;
+	public void writeDouble(double v) throws IOException;
+	public void writeBytes(String s) throws IOException;
+	public void writeChars(String s) throws IOException;
+	public void writeUTF(String str) throws IOException;
+}
diff --git a/core/java/src/net/metanotion/io/SerialStreams.java b/core/java/src/net/metanotion/io/SerialStreams.java
new file mode 100644
index 0000000000..c8c430e93a
--- /dev/null
+++ b/core/java/src/net/metanotion/io/SerialStreams.java
@@ -0,0 +1,62 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import net.metanotion.io.Serializer;
+
+public abstract class SerialStreams implements Serializer {
+	public byte[] getBytes(Object o) {
+		try {
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(baos);
+			writeOut(dos, o);
+			return baos.toByteArray();
+		} catch (IOException ioe) { throw new Error(); }
+	}
+
+	public Object construct(byte[] b) {
+		try {
+			ByteArrayInputStream bais = new ByteArrayInputStream(b);
+			DataInputStream dis = new DataInputStream(bais);
+			return readIn(dis);
+		} catch (IOException ioe) {
+			ioe.printStackTrace();
+			throw new Error();
+		}
+	}
+
+	abstract public void writeOut(DataOutputStream dos, Object o) throws IOException;
+	abstract public Object readIn(DataInputStream dis) throws IOException;
+}
diff --git a/core/java/src/net/metanotion/io/Serializer.java b/core/java/src/net/metanotion/io/Serializer.java
new file mode 100644
index 0000000000..40cab22552
--- /dev/null
+++ b/core/java/src/net/metanotion/io/Serializer.java
@@ -0,0 +1,34 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io;
+
+public interface Serializer {
+	public byte[] getBytes(Object o);
+	public Object construct(byte[] b);
+}
diff --git a/core/java/src/net/metanotion/io/block/BlockFile.java b/core/java/src/net/metanotion/io/block/BlockFile.java
new file mode 100644
index 0000000000..205a33c927
--- /dev/null
+++ b/core/java/src/net/metanotion/io/block/BlockFile.java
@@ -0,0 +1,291 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.block;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Set;
+
+import net.metanotion.io.RAIFile;
+import net.metanotion.io.RandomAccessInterface;
+import net.metanotion.io.Serializer;
+import net.metanotion.io.data.IntBytes;
+import net.metanotion.io.data.LongBytes;
+import net.metanotion.io.data.NullBytes;
+import net.metanotion.io.data.StringBytes;
+
+import net.metanotion.io.block.index.BSkipList;
+
+class CorruptFileException extends IOException { }
+class BadFileFormatException extends IOException { }
+class BadVersionException extends IOException { }
+
+public class BlockFile {
+	public static final long PAGESIZE = 1024;
+	public static final long OFFSET_MOUNTED = 20;
+
+	public RandomAccessInterface file;
+
+	private long magicBytes = 0x3141deadbeef0100L;
+	private long fileLen = PAGESIZE * 2;
+	private int freeListStart = 0;
+	private short mounted = 0;
+	public short spanSize = 127;
+
+	private BSkipList metaIndex = null;
+	private HashMap openIndices = new HashMap();
+
+	private void mount() throws IOException {
+		file.seek(BlockFile.OFFSET_MOUNTED);
+		mounted = 1;
+		file.writeShort(mounted);
+	}
+
+	private void writeSuperBlock() throws IOException {
+		file.seek(0);
+		file.writeLong(	magicBytes);
+		file.writeLong(	fileLen);
+		file.writeInt(	freeListStart);
+		file.writeShort(mounted);
+		file.writeShort(spanSize);
+	}
+
+	private void readSuperBlock() throws IOException {
+		file.seek(0);
+		magicBytes		= file.readLong();
+		fileLen			= file.readLong();
+		freeListStart	= file.readInt();
+		mounted			= file.readShort();
+		spanSize		= file.readShort();
+	}
+
+	public static void main(String args[]) {
+		try {
+			RAIFile raif = new RAIFile(new File(args[0]), true, true);
+			BlockFile bf = new BlockFile(raif, true);
+
+			//bf.metaIndex.delete();
+			bf.makeIndex("foo", new NullBytes(), new NullBytes());
+
+
+			BSkipList b = bf.getIndex("foo", new NullBytes(), new NullBytes());
+			System.out.println(bf.allocPage());
+
+			bf.close();
+			raif.close();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public int writeMultiPageData(byte[] data, int page, int[] curPageOff, int[] nextPage) throws IOException {
+		int pageCounter = curPageOff[0];
+		int curNextPage = nextPage[0];
+		int curPage = page;
+		int dct = 0;
+		while(dct < data.length) {
+			int len = ((int) BlockFile.PAGESIZE) - pageCounter;
+			if(len <= 0) {
+				if(curNextPage==0) {
+					curNextPage = this.allocPage();
+					BlockFile.pageSeek(this.file, curNextPage);
+					this.file.writeInt(0);
+					BlockFile.pageSeek(this.file, curPage);
+					this.file.writeInt(curNextPage);
+				}
+				BlockFile.pageSeek(this.file, curNextPage);
+				curPage = curNextPage;
+				curNextPage = this.file.readInt();
+				pageCounter = 4;
+				len = ((int) BlockFile.PAGESIZE) - pageCounter;
+			}
+			this.file.write(data, dct, Math.min(len, data.length - dct));
+			pageCounter += Math.min(len, data.length - dct);
+			dct += Math.min(len, data.length - dct);
+		}
+		nextPage[0] = curNextPage;
+		curPageOff[0] = pageCounter;
+		return curPage;
+	}
+
+	public int readMultiPageData(byte[] arr, int page, int[] curPageOff, int[] nextPage) throws IOException {
+		int pageCounter = curPageOff[0];
+		int curNextPage = nextPage[0];
+		int curPage = page;
+		int dct = 0;
+		int res;
+		while(dct < arr.length) {
+			int len = ((int) BlockFile.PAGESIZE) - pageCounter;
+			if(len <= 0) {
+				BlockFile.pageSeek(this.file, curNextPage);
+				curPage = curNextPage;
+				curNextPage = this.file.readInt();
+				pageCounter = 4;
+				len = ((int) BlockFile.PAGESIZE) - pageCounter;
+			}
+			res = this.file.read(arr, dct, Math.min(len, arr.length - dct));
+			if(res == -1) { throw new IOException(); }
+			pageCounter += Math.min(len, arr.length - dct);
+			dct += res;
+		}
+		nextPage[0] = curNextPage;
+		curPageOff[0] = pageCounter;
+		return curPage;
+	}
+
+	public BlockFile(RandomAccessInterface rai) throws IOException { this(rai, false); }
+	public BlockFile(RandomAccessFile raf) throws IOException { this(new RAIFile(raf), false); }
+	public BlockFile(RandomAccessFile raf, boolean init) throws IOException { this(new RAIFile(raf), init); }
+	public BlockFile(File f, boolean init) throws IOException { this(new RAIFile(f, true, true), init); }
+
+	public BlockFile(RandomAccessInterface rai, boolean init) throws IOException {
+		if(rai==null) { throw new NullPointerException(); }
+		
+		file = rai;
+
+		if(init) {
+			file.setLength(fileLen);
+			writeSuperBlock();
+			BSkipList.init(this, 2, spanSize);
+		}
+
+		readSuperBlock();
+		if(magicBytes != 0x3141deadbeef0100L) {
+			if((magicBytes & 0x3141deadbeef0000L) == 0x3141deadbeef0000L) {
+				throw new BadVersionException();
+			} else {
+				throw new BadFileFormatException();
+			}
+		}
+//		if(mounted != 0) { throw new CorruptFileException(); }
+		if(fileLen != file.length()) { throw new CorruptFileException(); }
+		mount();
+
+		metaIndex = new BSkipList(spanSize, this, 2, new StringBytes(), new IntBytes());
+	}
+
+
+	public static void pageSeek(RandomAccessInterface file, int page) throws IOException { file.seek((((long)page) - 1L) * BlockFile.PAGESIZE ); }
+
+	public int allocPage() throws IOException {
+		if(freeListStart != 0) {
+			FreeListBlock flb = new FreeListBlock(file, freeListStart);
+			if(flb.len > 0) {
+				flb.len = flb.len - 1;
+				int page = flb.branches[flb.len];
+				flb.writeBlock();
+				return page;
+			} else {
+				freeListStart = flb.nextPage;
+				writeSuperBlock();
+				return flb.page;
+			}
+		}
+		long offset = file.length();
+		fileLen = offset + BlockFile.PAGESIZE;
+		file.setLength(fileLen);
+		writeSuperBlock();
+		return ((int) ((long) (offset / BlockFile.PAGESIZE))) + 1;
+	}
+
+	public void freePage(int page) throws IOException {
+		System.out.println("Free Page " + page);
+		if(freeListStart == 0) {
+			freeListStart = page;
+			FreeListBlock.initPage(file, page);
+			writeSuperBlock();
+			return;
+		}
+		FreeListBlock flb = new FreeListBlock(file, freeListStart);
+		if(flb.isFull()) {
+			FreeListBlock.initPage(file, page);
+			if(flb.nextPage == 0) {
+				flb.nextPage = page;
+				flb.writeBlock();
+				return;
+			} else {
+				flb = new FreeListBlock(file, page);
+				flb.nextPage = freeListStart;
+				flb.writeBlock();
+				freeListStart = page;
+				writeSuperBlock();
+				return;
+			}
+		}
+		flb.addPage(page);
+		flb.writeBlock();
+	}
+
+	public BSkipList getIndex(String name, Serializer key, Serializer val) throws IOException {
+		Integer page = (Integer) metaIndex.get(name);
+		if (page == null) { return null; }
+		BSkipList bsl = new BSkipList(spanSize, this, page.intValue(), key, val);
+		openIndices.put(name, bsl);
+		return bsl;
+	}
+
+	public BSkipList makeIndex(String name, Serializer key, Serializer val) throws IOException {
+		if(metaIndex.get(name) != null) { throw new IOException("Index already exists"); }
+		int page = allocPage();
+		metaIndex.put(name, new Integer(page));
+		BSkipList.init(this, page, spanSize);
+		BSkipList bsl = new BSkipList(spanSize, this, page, key, val);
+		openIndices.put(name, bsl);
+		return bsl;
+	}
+
+	public void delIndex(String name) throws IOException {
+		Integer page = (Integer) metaIndex.remove(name);
+		if (page == null) { return; }
+		NullBytes nb = new NullBytes();
+		BSkipList bsl = new BSkipList(spanSize, this, page.intValue(), nb, nb);
+		bsl.delete();
+	}
+
+	public void close() throws IOException {
+		metaIndex.close();
+		metaIndex = null;
+
+		Set oi = openIndices.keySet();
+		Iterator i = oi.iterator();
+		Object k;
+		while(i.hasNext()) {
+			k = i.next();
+			BSkipList bsl = (BSkipList) openIndices.get(k);
+			bsl.close();
+		}
+
+		// Unmount.
+		file.seek(BlockFile.OFFSET_MOUNTED);
+		file.writeShort(0);
+	}
+}
diff --git a/core/java/src/net/metanotion/io/block/FreeListBlock.java b/core/java/src/net/metanotion/io/block/FreeListBlock.java
new file mode 100644
index 0000000000..aec2a93349
--- /dev/null
+++ b/core/java/src/net/metanotion/io/block/FreeListBlock.java
@@ -0,0 +1,89 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.block;
+
+import java.io.IOException;
+
+import net.metanotion.io.RandomAccessInterface;
+
+public class FreeListBlock {
+	public int page;
+	public int nextPage;
+	public int len;
+	public int[] branches = null;
+	public RandomAccessInterface file;
+
+	public FreeListBlock(RandomAccessInterface file, int startPage) throws IOException {
+		this.file = file;
+		this.page = startPage;
+		BlockFile.pageSeek(file, startPage);
+		nextPage = file.readInt();
+		len = file.readInt();
+		if(len > 0) {
+			branches = new int[len];
+			for(int i=0;i<len;i++) {
+				branches[i] = file.readInt();
+			}
+		}
+	}
+
+	public void writeBlock() throws IOException {
+		BlockFile.pageSeek(file, page);
+		file.writeInt(nextPage);
+		if(len > 0) {
+			file.writeInt(len);
+			for(int i=0;i<len;i++) { file.writeInt(branches[i]); }
+		} else {
+			file.writeInt(0);
+		}
+	}
+
+	public boolean isFull() {
+		int cells = (int) ((BlockFile.PAGESIZE - 8) / 4);
+		if(cells - len > 0) { return false; }
+		return true;
+	}
+
+	public void addPage(int page) {
+		int[] t = new int[len + 1];
+		if(len > 0) {
+			for(int i=0;i<len;i++) { t[i] = branches[i]; }
+		}
+		t[len] = page;
+		len++;
+		branches = t;
+	}
+
+	public static void initPage(RandomAccessInterface file, int page) throws IOException {
+		BlockFile.pageSeek(file, page);
+		file.writeInt(0);
+		file.writeInt(0);
+	}
+}
+
diff --git a/core/java/src/net/metanotion/io/block/index/BSkipLevels.java b/core/java/src/net/metanotion/io/block/index/BSkipLevels.java
new file mode 100644
index 0000000000..0638003ff8
--- /dev/null
+++ b/core/java/src/net/metanotion/io/block/index/BSkipLevels.java
@@ -0,0 +1,112 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.block.index;
+
+import java.io.IOException;
+
+import net.metanotion.io.RandomAccessInterface;
+import net.metanotion.io.block.BlockFile;
+import net.metanotion.util.skiplist.SkipList;
+import net.metanotion.util.skiplist.SkipLevels;
+import net.metanotion.util.skiplist.SkipSpan;
+
+public class BSkipLevels extends SkipLevels {
+	public int levelPage;
+	public int spanPage;
+	public BlockFile bf;
+
+	protected BSkipLevels() { }
+	public BSkipLevels(BlockFile bf, int levelPage, BSkipList bsl) throws IOException {
+		this.levelPage = levelPage;
+		this.bf = bf;
+
+		BlockFile.pageSeek(bf.file, levelPage);
+
+		bsl.levelHash.put(new Integer(this.levelPage), this);
+
+		int maxLen = bf.file.readShort();
+		int nonNull = bf.file.readShort();
+		spanPage = bf.file.readInt();
+		bottom = (BSkipSpan) bsl.spanHash.get(new Integer(spanPage));
+
+		this.levels = new BSkipLevels[maxLen];
+		int lp;
+		for(int i=0;i<nonNull;i++) {
+			lp = bf.file.readInt();
+			if(lp != 0) {
+				levels[i] = (BSkipLevels) bsl.levelHash.get(new Integer(lp));
+				if(levels[i] == null) {
+					levels[i] = new BSkipLevels(bf, lp, bsl);
+					bsl.levelHash.put(new Integer(lp), levels[i]);
+				}
+			} else {
+				levels[i] = null;
+			}
+		}
+
+	}
+
+	public static void init(BlockFile bf, int page, int spanPage, int maxHeight) throws IOException {
+		BlockFile.pageSeek(bf.file, page);
+		bf.file.writeShort((short) maxHeight);
+		bf.file.writeShort(0);
+		bf.file.writeInt(spanPage);
+	}
+
+	public void flush() {
+		try {
+			BlockFile.pageSeek(bf.file, levelPage);
+			bf.file.writeShort((short) levels.length);
+			int i=0;
+			for(i=0;i<levels.length;i++) { if(levels[i] == null) { break; } }
+			bf.file.writeShort(i);
+			bf.file.writeInt(((BSkipSpan) bottom).page);
+			for(i=0;i<levels.length;i++) {
+				if(levels[i]==null) { break; }
+				bf.file.writeInt(((BSkipLevels) levels[i]).levelPage);
+			}
+		} catch (IOException ioe) { throw new Error(); }
+	}
+
+	public void killInstance() {
+		try {
+			bf.freePage(levelPage);
+		} catch (IOException ioe) { throw new Error(); }
+	}
+
+	public SkipLevels newInstance(int levels, SkipSpan ss, SkipList sl) {
+		try {
+			BSkipSpan bss = (BSkipSpan) ss;
+			BSkipList bsl = (BSkipList) sl;
+			int page = bf.allocPage();
+			BSkipLevels.init(bf, page, bss.page, levels);
+			return new BSkipLevels(bf, page, bsl);
+		} catch (IOException ioe) { throw new Error(); }
+	}
+}
diff --git a/core/java/src/net/metanotion/io/block/index/BSkipList.java b/core/java/src/net/metanotion/io/block/index/BSkipList.java
new file mode 100644
index 0000000000..b44003e3b5
--- /dev/null
+++ b/core/java/src/net/metanotion/io/block/index/BSkipList.java
@@ -0,0 +1,122 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.block.index;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Random;
+
+import net.metanotion.io.RandomAccessInterface;
+import net.metanotion.io.Serializer;
+import net.metanotion.io.block.BlockFile;
+import net.metanotion.util.skiplist.*;
+
+public class BSkipList extends SkipList {
+	public int firstSpanPage = 0;
+	public int firstLevelPage = 0;
+	public int skipPage = 0;
+	public BlockFile bf;
+
+	public HashMap spanHash = new HashMap();
+	public HashMap levelHash = new HashMap();
+
+	protected BSkipList() { }
+	public BSkipList(int spanSize, BlockFile bf, int skipPage, Serializer key, Serializer val) throws IOException {
+		if(spanSize < 1) { throw new Error("Span size too small"); }
+
+		this.skipPage = skipPage;
+		this.bf = bf;
+
+		BlockFile.pageSeek(bf.file, skipPage);
+		firstSpanPage = bf.file.readInt();
+		firstLevelPage = bf.file.readInt();
+		size = bf.file.readInt();
+		spans = bf.file.readInt();
+		System.out.println(size + " " + spans); 
+
+		first = new BSkipSpan(bf, this, firstSpanPage, key, val);
+		stack = new BSkipLevels(bf, firstLevelPage, this);
+		rng = new Random(System.currentTimeMillis());
+	}
+
+	public void close() {
+		System.out.println("Closing index " + size + " and " + spans);
+		flush();
+		first = null;
+		stack = null;
+	}
+
+	public void flush() {
+		try {
+			BlockFile.pageSeek(bf.file, skipPage);
+			bf.file.writeInt(firstSpanPage);
+			bf.file.writeInt(firstLevelPage);
+			bf.file.writeInt(size);
+			bf.file.writeInt(spans);
+			
+		} catch (IOException ioe) { throw new Error(); }
+	}
+
+	public void delete() throws IOException {
+		SkipLevels curLevel = stack, nextLevel;
+		while(curLevel != null) {
+			nextLevel = curLevel.levels[0];
+			curLevel.killInstance();
+			curLevel = nextLevel;
+		}
+
+		SkipSpan curSpan = first, nextSpan;
+		while(curSpan != null) {
+			nextSpan = curSpan.next;
+			curSpan.killInstance();
+			curSpan = nextSpan;
+		}
+
+		bf.freePage(skipPage);
+	}
+
+	public static void init(BlockFile bf, int page, int spanSize) throws IOException {
+		int firstSpan = bf.allocPage();
+		int firstLevel = bf.allocPage();
+		BlockFile.pageSeek(bf.file, page);
+		bf.file.writeInt(firstSpan);
+		bf.file.writeInt(firstLevel);
+		bf.file.writeInt(0);
+		bf.file.writeInt(1);
+		BSkipSpan.init(bf, firstSpan, spanSize);
+		BSkipLevels.init(bf, firstLevel, firstSpan, 4);
+	}
+
+	public int maxLevels() {
+		int max = super.maxLevels();
+		int cells = (int) ((BlockFile.PAGESIZE - 8) / 4);
+		return (max > cells) ? cells : max;
+	}
+
+}
diff --git a/core/java/src/net/metanotion/io/block/index/BSkipSpan.java b/core/java/src/net/metanotion/io/block/index/BSkipSpan.java
new file mode 100644
index 0000000000..2c9aed3a1e
--- /dev/null
+++ b/core/java/src/net/metanotion/io/block/index/BSkipSpan.java
@@ -0,0 +1,215 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.block.index;
+
+import java.io.IOException;
+
+import net.metanotion.io.RandomAccessInterface;
+import net.metanotion.io.Serializer;
+import net.metanotion.io.block.BlockFile;
+import net.metanotion.io.data.NullBytes;
+import net.metanotion.util.skiplist.SkipList;
+import net.metanotion.util.skiplist.SkipSpan;
+
+public class BSkipSpan extends SkipSpan {
+
+	protected BlockFile bf;
+	protected int page;
+	protected int overflowPage;
+
+	protected int prevPage;
+	protected int nextPage;
+	protected Serializer keySer;
+	protected Serializer valSer;
+
+	public static void init(BlockFile bf, int page, int spanSize) throws IOException {
+		BlockFile.pageSeek(bf.file, page);
+		bf.file.writeInt(0);
+		bf.file.writeInt(0);
+		bf.file.writeInt(0);
+		bf.file.writeShort((short) spanSize);
+		bf.file.writeShort(0);
+	}
+
+	public SkipSpan newInstance(SkipList sl) {
+		try {
+			int newPage = bf.allocPage();
+			init(bf, newPage, bf.spanSize);
+			return new BSkipSpan(bf, (BSkipList) sl, newPage, keySer, valSer);
+		} catch (IOException ioe) { throw new Error(); }
+	}
+
+	public void killInstance() {
+		try {
+			int curPage = overflowPage;
+			int next;
+			while(curPage != 0) {
+				BlockFile.pageSeek(bf.file, curPage);
+				next = bf.file.readInt();
+				bf.freePage(curPage);
+				curPage = next;
+			}
+			bf.freePage(page);
+		} catch(IOException ioe) { throw new Error(); }
+	}
+
+	public void flush() {
+		try {
+			BlockFile.pageSeek(bf.file, page);
+			bf.file.writeInt(overflowPage);
+			bf.file.writeInt((prev != null) ? ((BSkipSpan) prev).page : 0);
+			bf.file.writeInt((next != null) ? ((BSkipSpan) next).page : 0);
+			bf.file.writeShort((short) keys.length);
+			bf.file.writeShort((short) nKeys);
+
+			int ksz, vsz;
+			int curPage = this.page;
+			int[] curNextPage = new int[1];
+			curNextPage[0] = this.overflowPage;
+			int[] pageCounter = new int[1];
+			pageCounter[0] = 16;
+			byte[] keyData;
+			byte[] valData;
+
+			for(int i=0;i<nKeys;i++) {
+				if((pageCounter[0] + 4) > BlockFile.PAGESIZE) {
+					if(curNextPage[0] == 0) {
+						curNextPage[0] = bf.allocPage();
+						BlockFile.pageSeek(bf.file, curNextPage[0]);
+						bf.file.writeInt(0);
+						BlockFile.pageSeek(bf.file, curPage);
+						bf.file.writeInt(curNextPage[0]);
+					}
+					BlockFile.pageSeek(bf.file, curNextPage[0]);
+					curPage = curNextPage[0];
+					curNextPage[0] = bf.file.readInt();
+					pageCounter[0] = 4;
+				}
+				keyData = this.keySer.getBytes(keys[i]);
+				valData = this.valSer.getBytes(vals[i]);
+				pageCounter[0] += 4;
+				bf.file.writeShort(keyData.length);
+				bf.file.writeShort(valData.length);
+				curPage = bf.writeMultiPageData(keyData, curPage, pageCounter, curNextPage);
+				curPage = bf.writeMultiPageData(valData, curPage, pageCounter, curNextPage);
+			}
+			BlockFile.pageSeek(bf.file, this.page);
+			this.overflowPage = bf.file.readInt();
+		} catch(IOException ioe) { throw new Error(); }
+	}
+
+	private static void load(BSkipSpan bss, BlockFile bf, BSkipList bsl, int spanPage, Serializer key, Serializer val) throws IOException {
+		bss.bf = bf;
+		bss.page = spanPage;
+		bss.keySer = key;
+		bss.valSer = val;
+
+		bsl.spanHash.put(new Integer(spanPage), bss);
+
+		BlockFile.pageSeek(bf.file, spanPage);
+
+		bss.overflowPage = bf.file.readInt();
+		bss.prevPage = bf.file.readInt();
+		bss.nextPage = bf.file.readInt();
+		int sz = bf.file.readShort();
+		bss.nKeys = bf.file.readShort();
+
+		bss.keys = new Comparable[sz];
+		bss.vals = new Object[sz];
+
+		int ksz, vsz;
+		int curPage = spanPage;
+		int[] curNextPage = new int[1];
+		curNextPage[0] = bss.overflowPage;
+		int[] pageCounter = new int[1];
+		pageCounter[0] = 16;
+//		System.out.println("Span Load " + sz + " nKeys " + nKeys + " page " + curPage);
+		for(int i=0;i<bss.nKeys;i++) {
+			if((pageCounter[0] + 4) > BlockFile.PAGESIZE) {
+				BlockFile.pageSeek(bf.file, curNextPage[0]);
+				curPage = curNextPage[0];
+				curNextPage[0] = bf.file.readInt();
+				pageCounter[0] = 4;
+			}
+			ksz = bf.file.readShort();
+			vsz = bf.file.readShort();
+			pageCounter[0] +=4;
+			byte[] k = new byte[ksz];
+			byte[] v = new byte[vsz];
+			curPage = bf.readMultiPageData(k, curPage, pageCounter, curNextPage);
+			curPage = bf.readMultiPageData(v, curPage, pageCounter, curNextPage);
+//			System.out.println("i=" + i + ", Page " + curPage + ", offset " + pageCounter[0] + " ksz " + ksz + " vsz " + vsz);
+			bss.keys[i] = (Comparable) bss.keySer.construct(k);
+			bss.vals[i] = bss.valSer.construct(v);
+		}
+
+	}
+
+	protected BSkipSpan() { }
+	public BSkipSpan(BlockFile bf, BSkipList bsl, int spanPage, Serializer key, Serializer val) throws IOException {
+		BSkipSpan.load(this, bf, bsl, spanPage, key, val);
+		this.next = null;
+		this.prev = null;
+
+		BSkipSpan bss = this;
+		BSkipSpan temp;
+		int np = nextPage;
+		while(np != 0) {
+			temp = (BSkipSpan) bsl.spanHash.get(new Integer(np));
+			if(temp != null) {
+				bss.next = temp;
+				break;
+			}
+			bss.next = new BSkipSpan();
+			bss.next.next = null;
+			bss.next.prev = bss;
+			bss = (BSkipSpan) bss.next;
+			
+			BSkipSpan.load(bss, bf, bsl, np, key, val);
+			np = bss.nextPage;
+		}
+
+		bss = this;
+		np = prevPage;
+		while(np != 0) {
+			temp = (BSkipSpan) bsl.spanHash.get(new Integer(np));
+			if(temp != null) {
+				bss.next = temp;
+				break;
+			}
+			bss.prev = new BSkipSpan();
+			bss.prev.next = bss;
+			bss.prev.prev = null;
+			bss = (BSkipSpan) bss.prev;
+			
+			BSkipSpan.load(bss, bf, bsl, np, key, val);
+			np = bss.prevPage;
+		}
+	}
+}
diff --git a/core/java/src/net/metanotion/io/block/index/IBSkipSpan.java b/core/java/src/net/metanotion/io/block/index/IBSkipSpan.java
new file mode 100644
index 0000000000..529ba2ed23
--- /dev/null
+++ b/core/java/src/net/metanotion/io/block/index/IBSkipSpan.java
@@ -0,0 +1,302 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.block.index;
+
+import java.io.IOException;
+
+import net.metanotion.io.Serializer;
+import net.metanotion.io.block.BlockFile;
+import net.metanotion.util.skiplist.SkipList;
+import net.metanotion.util.skiplist.SkipSpan;
+
+/**
+ * I2P version of BSkipSpan
+ *
+ * BSkipSpan stores all keys and values in-memory, backed by the file.
+ * IBSkipSpan stores only the first key, and no values, in-memory.
+ *
+ * For a get(), here we do a linear search through the span in the file 
+ * and load only the found value (super() does a binary search in-memory).
+ *
+ * For a put() or remove(), we load all keys and values for the span from
+ * the file, make the modification, flush() out the keys and values,
+ * and null out the keys and values in-memory.
+ *
+ * Recommended span size is 16.
+ *
+ * @author zzz
+ */
+public class IBSkipSpan extends BSkipSpan {
+
+	private Comparable firstKey;
+	private static final boolean DEBUG = false;
+
+	@Override
+	public SkipSpan newInstance(SkipList sl) {
+		if (DEBUG)
+			System.err.println("Splitting page " + this.page + " containing " + this.nKeys + '/' + this.spanSize);
+		try {
+			int newPage = bf.allocPage();
+			init(bf, newPage, bf.spanSize);
+			SkipSpan rv = new IBSkipSpan(bf, (BSkipList) sl, newPage, keySer, valSer);
+			// this is called after a split, so we need the data arrays initialized
+			rv.keys = new Comparable[bf.spanSize];
+			rv.vals = new Object[bf.spanSize];
+			return rv;
+		} catch (IOException ioe) { throw new Error(ioe); }
+	}
+
+	/**
+	 * Flush to disk and null out in-memory keys and values, saving only the first key
+	 */
+	@Override
+	public void flush() {
+		super.flush();
+		if (nKeys > 0)
+			this.firstKey = keys[0];
+		else
+			this.firstKey = null;
+		this.keys = null;
+		this.vals = null;
+		if (DEBUG)
+			System.err.println("Flushed data for page " + this.page + " containing " + this.nKeys + '/' + this.spanSize);
+	}
+
+	/**
+	 * I2P - second half of load()
+	 * Load the whole span's keys and values into memory
+	 */
+	protected static void loadData(IBSkipSpan bss, BlockFile bf, int spanPage, Serializer key, Serializer val) throws IOException {
+		BSkipSpan.loadData(bss, bf, spanPage, key, val);
+		if (bss.nKeys > 0)
+			bss.firstKey = bss.keys[0];
+		if (DEBUG)
+			System.err.println("Loaded data for page " + spanPage + " containing " + bss.nKeys + '/' + bss.spanSize + " first key: " + bss.firstKey);
+	}
+
+	/**
+	 * Must already be seeked to the end of the span header
+         * via loadInit() or seekData()
+	 */
+	private void loadFirstKey() throws IOException {
+		if (this.nKeys <= 0)
+			return;
+		int ksz;
+		int curPage = this.page;
+		int[] curNextPage = new int[1];
+		curNextPage[0] = this.overflowPage;
+		int[] pageCounter = new int[1];
+		pageCounter[0] = 16;
+		ksz = this.bf.file.readShort();
+		this.bf.file.skipBytes(2);  //vsz
+		pageCounter[0] +=4;
+		byte[] k = new byte[ksz];
+		curPage = this.bf.readMultiPageData(k, curPage, pageCounter, curNextPage);
+		this.firstKey = (Comparable) this.keySer.construct(k);
+		if (DEBUG)
+			System.err.println("Loaded header for page " + this.page + " containing " + this.nKeys + '/' + this.spanSize + " first key: " + this.firstKey);
+	}
+
+	/**
+	 * Seek past the span header
+	 */
+	private void seekData() throws IOException {
+		BlockFile.pageSeek(this.bf.file, this.page);
+		// 3 ints and 2 shorts
+		this.bf.file.skipBytes(16);
+	}
+
+	/**
+	 * Seek to the start of the span and load the data
+	 */
+	private void seekAndLoadData() throws IOException {
+		seekData();
+		loadData(this, this.bf, this.page, this.keySer, this.valSer);
+	}
+
+	/**
+	 * Linear search through the span in the file for the value.
+	 */
+	private Object getData(Comparable key) throws IOException {
+		seekData();
+		int ksz, vsz;
+		int curPage = this.page;
+		int[] curNextPage = new int[1];
+		curNextPage[0] = this.overflowPage;
+		int[] pageCounter = new int[1];
+		pageCounter[0] = 16;
+		//System.out.println("Span Load " + sz + " nKeys " + nKeys + " page " + curPage);
+		for(int i=0;i<this.nKeys;i++) {
+			if((pageCounter[0] + 4) > BlockFile.PAGESIZE) {
+				BlockFile.pageSeek(this.bf.file, curNextPage[0]);
+				curPage = curNextPage[0];
+				curNextPage[0] = this.bf.file.readInt();
+				pageCounter[0] = 4;
+			}
+			ksz = this.bf.file.readShort();
+			vsz = this.bf.file.readShort();
+			pageCounter[0] +=4;
+			byte[] k = new byte[ksz];
+			byte[] v = new byte[vsz];
+			curPage = this.bf.readMultiPageData(k, curPage, pageCounter, curNextPage);
+			curPage = this.bf.readMultiPageData(v, curPage, pageCounter, curNextPage);
+			//System.out.println("i=" + i + ", Page " + curPage + ", offset " + pageCounter[0] + " ksz " + ksz + " vsz " + vsz);
+			Comparable ckey = (Comparable) this.keySer.construct(k);
+			int diff = ckey.compareTo(key);
+			if (diff == 0) {
+				//System.err.println("Found " + key + " at " + i + " (first: " + this.firstKey + ')');
+				return this.valSer.construct(v);
+			}
+			if (diff > 0) {
+				//System.err.println("NOT Found " + key + " at " + i + " (first: " + this.firstKey + " current: " + ckey + ')');
+				return null;
+			}
+		}
+		//System.err.println("NOT Found " + key + " at end (first: " + this.firstKey + ')');
+		return null;
+	}
+
+	protected IBSkipSpan() { }
+
+	public IBSkipSpan(BlockFile bf, BSkipList bsl, int spanPage, Serializer key, Serializer val) throws IOException {
+		if (DEBUG)
+			System.err.println("New ibss page " + spanPage);
+		BSkipSpan.loadInit(this, bf, bsl, spanPage, key, val);
+		loadFirstKey();
+		this.next = null;
+		this.prev = null;
+
+		IBSkipSpan bss = this;
+		IBSkipSpan temp;
+		int np = nextPage;
+		while(np != 0) {
+			temp = (IBSkipSpan) bsl.spanHash.get(new Integer(np));
+			if(temp != null) {
+				bss.next = temp;
+				break;
+			}
+			bss.next = new IBSkipSpan();
+			bss.next.next = null;
+			bss.next.prev = bss;
+			bss = (IBSkipSpan) bss.next;
+			
+			BSkipSpan.loadInit(bss, bf, bsl, np, key, val);
+			bss.loadFirstKey();
+			np = bss.nextPage;
+		}
+
+		bss = this;
+		np = prevPage;
+		while(np != 0) {
+			temp = (IBSkipSpan) bsl.spanHash.get(new Integer(np));
+			if(temp != null) {
+				bss.next = temp;
+				break;
+			}
+			bss.prev = new IBSkipSpan();
+			bss.prev.next = bss;
+			bss.prev.prev = null;
+			bss = (IBSkipSpan) bss.prev;
+			
+			BSkipSpan.loadInit(bss, bf, bsl, np, key, val);
+			bss.loadFirstKey();
+			np = bss.prevPage;
+		}
+	}
+
+	/**
+         * Does not call super, we always store first key here
+	 */
+	@Override
+	public Comparable firstKey() {
+		return this.firstKey;
+	}
+
+	/**
+	 * Load whole span from file, do the operation, flush out, then null out in-memory data again.
+	 * This is called only via SkipList.find()
+	 */
+	@Override
+	public SkipSpan getSpan(Comparable key, int[] search) {
+		try {
+			seekAndLoadData();
+		} catch (IOException ioe) {
+			throw new Error(ioe);
+		}
+		SkipSpan rv = super.getSpan(key, search);
+		this.keys = null;
+		this.vals = null;
+		return rv;
+	}
+
+	/**
+	 * Linear search if in file, Binary search if in memory
+	 */
+	@Override
+	public Object get(Comparable key) {
+		try {
+			if (nKeys == 0) { return null; }
+			if (this.next != null && this.next.firstKey().compareTo(key) <= 0)
+				return next.get(key);
+			return getData(key);
+		} catch (IOException ioe) {
+			throw new Error(ioe);
+		}
+	}
+
+	/**
+	 * Load whole span from file, do the operation, flush out, then null out in-memory data again.
+	 */
+	@Override
+	public SkipSpan put(Comparable key, Object val, SkipList sl)	{
+		try {
+			seekAndLoadData();
+		} catch (IOException ioe) {
+			throw new Error(ioe);
+		}
+		SkipSpan rv = super.put(key, val, sl);
+		// flush() nulls out the data
+		return rv;
+	}
+
+	/**
+	 * Load whole span from file, do the operation, flush out, then null out in-memory data again.
+	 */
+	@Override
+	public Object[] remove(Comparable key, SkipList sl) {
+		try {
+			seekAndLoadData();
+		} catch (IOException ioe) {
+			throw new Error(ioe);
+		}
+		Object[] rv = super.remove(key, sl);
+		// flush() nulls out the data
+		return rv;
+	}
+}
diff --git a/core/java/src/net/metanotion/io/data/IntBytes.java b/core/java/src/net/metanotion/io/data/IntBytes.java
new file mode 100644
index 0000000000..489ae296cb
--- /dev/null
+++ b/core/java/src/net/metanotion/io/data/IntBytes.java
@@ -0,0 +1,51 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.data;
+
+import net.metanotion.io.Serializer;
+
+public class IntBytes implements Serializer {
+	public byte[] getBytes(Object o) {
+		byte[] b = new byte[4];
+		int v = ((Integer) o).intValue();
+ 		b[0] = (byte)(0xff & (v >> 24));
+ 		b[1] = (byte)(0xff & (v >> 16));
+		b[2] = (byte)(0xff & (v >>  8));
+ 		b[3] = (byte)(0xff & v);
+ 		return b;
+	}
+
+	public Object construct(byte[] b) {
+		int v = (((int)(b[0] & 0xff) << 24) |
+				 ((int)(b[1] & 0xff) << 16) |
+				 ((int)(b[2] & 0xff) <<  8) |
+				 ((int)(b[3] & 0xff)));
+		return new Integer(v);
+	}
+}
diff --git a/core/java/src/net/metanotion/io/data/LongBytes.java b/core/java/src/net/metanotion/io/data/LongBytes.java
new file mode 100644
index 0000000000..1223a8799e
--- /dev/null
+++ b/core/java/src/net/metanotion/io/data/LongBytes.java
@@ -0,0 +1,59 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.data;
+
+import net.metanotion.io.Serializer;
+
+public class LongBytes implements Serializer {
+	public byte[] getBytes(Object o) {
+		byte[] b = new byte[8];
+		long v = ((Long) o).longValue();
+ 		b[0] = (byte)(0xff & (v >> 56));
+		b[1] = (byte)(0xff & (v >> 48));
+ 		b[2] = (byte)(0xff & (v >> 40));
+ 		b[3] = (byte)(0xff & (v >> 32));
+ 		b[4] = (byte)(0xff & (v >> 24));
+ 		b[5] = (byte)(0xff & (v >> 16));
+		b[6] = (byte)(0xff & (v >>  8));
+ 		b[7] = (byte)(0xff & v);
+ 		return b;
+	}
+
+	public Object construct(byte[] b) {
+		long v =(((long)(b[0] & 0xff) << 56) |
+				 ((long)(b[1] & 0xff) << 48) |
+				 ((long)(b[2] & 0xff) << 40) |
+				 ((long)(b[3] & 0xff) << 32) |
+				 ((long)(b[4] & 0xff) << 24) |
+				 ((long)(b[5] & 0xff) << 16) |
+				 ((long)(b[6] & 0xff) <<  8) |
+				 ((long)(b[7] & 0xff)));
+		return new Long(v);
+	}
+}
diff --git a/core/java/src/net/metanotion/io/data/NullBytes.java b/core/java/src/net/metanotion/io/data/NullBytes.java
new file mode 100644
index 0000000000..c3849b0ed5
--- /dev/null
+++ b/core/java/src/net/metanotion/io/data/NullBytes.java
@@ -0,0 +1,36 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.data;
+
+import net.metanotion.io.Serializer;
+
+public class NullBytes implements Serializer {
+	public byte[] getBytes(Object o) { return null; }
+	public Object construct(byte[] b) { return null; }
+}
diff --git a/core/java/src/net/metanotion/io/data/StringBytes.java b/core/java/src/net/metanotion/io/data/StringBytes.java
new file mode 100644
index 0000000000..18740b7b5a
--- /dev/null
+++ b/core/java/src/net/metanotion/io/data/StringBytes.java
@@ -0,0 +1,47 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.io.data;
+
+import java.io.UnsupportedEncodingException;
+
+import net.metanotion.io.Serializer;
+
+public class StringBytes implements Serializer {
+	public byte[] getBytes(Object o) {
+		try {
+			return ((String) o).getBytes("US-ASCII");
+		} catch (UnsupportedEncodingException uee) { throw new Error("Unsupported Encoding"); }
+	}
+
+	public Object construct(byte[] b) {
+		try {
+			return new String(b, "US-ASCII");
+		} catch (UnsupportedEncodingException uee) { throw new Error("Unsupported Encoding"); }
+	}
+}
diff --git a/core/java/src/net/metanotion/package.html b/core/java/src/net/metanotion/package.html
new file mode 100644
index 0000000000..82e22b737a
--- /dev/null
+++ b/core/java/src/net/metanotion/package.html
@@ -0,0 +1,156 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+	<head>
+		<link rel="home" title="Home" href="http://www.metanotion.net/software/sandbox/" />
+
+		<meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
+		<meta name="robots" content="all" />
+
+		<title>BlockFile</title>
+	</head>
+	<body>
+		<h1>Metanotion BlockFile Database</h1>
+		<p>A 100% Java 1.3, BSD Licensed, embeddable single file database engine in 32KB. This database was designed for PDA based and J2ME applications.</p>
+
+		<h2>Table of Contents</h2>
+		<ul>
+			<li><a href="#features">Features</a></li>
+			<li><a href="#unfeatures">Unfeatures</a></li>
+			<li><a href="#future">Future Plans</a></li>
+			<li><a href="#design">What kind of database is this?</a></li>
+			<li><a href="#examples">Examples and API</a></li>
+			<li><a href="#download">Download</a></li>
+		</ul>
+		
+		<a name="features"><h2>Features</h2></a>
+		<ul>
+			<li>100% Java 1.3. No JNI.</li>
+			<li>Will work with any "file" as long as you can approximate something like <a href="http://java.sun.com/j2se/1.3/docs/api/java/io/RandomAccessFile.html">java.io.RandomAccessFile</a>, you can use this.</li>
+			<li>BSD Licensed. Yes, this means you can use it for free in a commercial project. However, if you base some really cool mobile technology startup on this code we'll gladly accept stock options...</p>
+			<li>No dependence on file API's(useful for mobile apps)</li>
+			<li>Small. 32KB in a JAR file. &lt;2000 lines of code.</li>
+			<li>Reasonably fast. This is used in an app running on a sub 200MHz StrongARM PocketPC, and quite handily deals with 70,000 records. The load time is a little slow, but its been tested with a <a href="http://java.sun.com/javame/reference/apis.jsp">CDC 1.0/Personal Profile</a> device.
+			</li>
+		</ul>
+
+		<a name="unfeatures"><h2>Unfeatures</h2></a>
+		<p>A good, ACID database is a nice thing to work with. Unfortunately, in the goal to make this small, fast, and work with minimal dependencies, something had to give. So I list things which this database will likely never have. Of course, since it is BSD Licensed, patches welcome...</p>
+		
+		<ul>
+			<li>No transactions.</li>
+			<li>No SQL.</li>
+			<li>No JDBC.</li>
+			<li>No use of reflection or automagical serialization tricks.</li>
+		</ul>
+
+		<a name="future"><h2>Future Plans</h2></a>
+		<p>There are still bugs(none known...). The app that this was written for is still in testing, but we should most of the issues sorted by the time we deploy it in a few weeks(early November, 2006). Some loading speed issues on large record sets, and memory usage could still be improved. All this and feedback from other uses will direct this products evolution.</p>
+		<p>What is currently up here is not "1.0" code, but we will release a labeled "1.0" version once we feel happy with the state of the codebase.</p>
+	
+		<a name="design"><h2>What KIND of database is this?</h2></a>
+		<p>You probably store at least part of your application data in memory in a class from the <a href="http://java.sun.com/j2se/1.4.2/docs/guide/collections/">Java Collections Framework</a>. The BlockFile database stores data in a <a href="http://en.wikipedia.org/wiki/Skip_list">Skip</a> <a href="http://eternallyconfuzzled.com/tuts/skip.html">List</a> that almost implements <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/SortedMap.html">java.util.SortedMap</a>. You can create and store as many named(with a string) SkipList in the database as you want.</p>
+		<p>To serialize your data, you have to either extend our SerialStreams class or implement our Serializer interface. We could have done something cool and fancy with reflection(and other cool stuff with Java 1.5), but that would probably not do the Right Thing&trade; most of the time.  As you can see, there's not a lot to it anyway:</p>
+		<h3>net.metanotion.io.SerialStreams</h3>
+<pre>
+public abstract class SerialStreams implements Serializer {
+// ...
+	abstract public void writeOut(DataOutputStream dos, Object o) throws IOException;
+	abstract public Object readIn(DataInputStream dis) throws IOException;
+}
+</pre>
+		<h3>net.metanotion.io.Serializer</h3>
+<pre>
+public interface Serializer {
+	public byte[] getBytes(Object o);
+	public Object construct(byte[] b);
+}
+</pre>
+
+		<p>Now, about those skip lists. They implement a <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/ListIterator.html">java.util.ListIterator</a> so you can get "nearby" values, and you can use anything for a key that implements <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html">java.lang.Comparable</a>. So, here's the interface to a SkipList:
+<pre>
+public class SkipList {
+	...
+	public void put(Comparable key, Object val) ...
+	public Object remove(Comparable key) ...
+	public Object get(Comparable key) ...
+	public ListIterator iterator() ...
+	public ListIterator min() ...
+	public ListIterator max() ...
+	// Find the first key bigger than or equal to key,
+	// or the biggest key less than key if there is no bigger or equal.
+	public ListIterator find(Comparable key) ...
+}
+</pre>
+</p>
+
+		<a name="examples"><h2>Examples</h2></a>
+		<p>Better documentation is forthcoming, but there really isn't much to know. The entire public interface to the library is on this page. Where possible, it sticks to idiomatic Java and standard interfaces.</p>
+		<ul>
+			<li>Open a database:
+<pre>
+import net.metanotion.io.block.BlockFile;
+...
+	try {
+		BlockFile db = new BlockFile(new File("my.db"), false); // true will create
+	} catch (IOException ioe) {
+		System.out.println("Bummer");
+	}
+</pre>
+			<li>
+			<li>Load or Create a SkipList:
+<pre>
+import net.metanotion.util.skiplist.SkipList;
+import net.metanotion.io.Serializer;
+...
+class KeySerializer implements Serializer ...
+class ValueSerializer implements Serializer ...
+...
+// Open preexisting
+SkipList index = db.getIndex("My Index", new KeySerializer(), new ValueSerializer());
+// Create
+SkipList index = db.makeIndex("My Index", new KeySerializer(), new ValueSerializer());
+</pre>
+			</li>
+		</ul>
+
+		<h3>net.metanotion.io.block.BlockFile</h3>
+All the public interface methods:
+<pre>
+public class BlockFile implements Closeable {
+	public BlockFile(RandomAccessInterface rai) ...
+	public BlockFile(RandomAccessFile raf) ...
+	public BlockFile(RandomAccessFile raf, boolean init) ...
+	public BlockFile(File f, boolean init) ...
+	public BlockFile(RandomAccessInterface rai, boolean init) ...
+
+	public SkipList getIndex(String name, Serializer key, Serializer val) ...
+	public SkipList makeIndex(String name, Serializer key, Serializer val) ...
+	public void delIndex(String name) ...
+
+	public void close() ...
+}
+</pre>
+
+		<h3>What's this "net.metanotion.io.RandomAccessInterface"?</h3>
+		<p>Basically, its an interface version of <a href="http://java.sun.com/j2se/1.3/docs/api/java/io/RandomAccessFile.html">java.io.RandomAccessFile</a>(which itself implements <a href="http://java.sun.com/j2se/1.3/docs/api/java/io/DataInput.html">DataInput</a>, <a href="http://java.sun.com/j2se/1.3/docs/api/java/io/DataOutput.html">DataOutput</a> and a few methods for getting/setting the file pointer).</p>
+		
+		<p>So, in other words, if you can provide an implementation of this interface, you can use the BlockFile database. This frees it from dependence on the RandomAccessFile class. If you don't see why this is useful and you're going to be using "files" on PDA's and phone's, well, you'll understand soon enough...</p>
+
+		<a name="download"><h2>Download</h2></a>
+		<h3>Bugfix and cleanup Release 10/6/2006</h2>
+		<p>An unnecessary class was removed, some junk methods removed, and a couple of JDK compatability issues were fixed. The StringBytes class was switched to ASCII(from UTF-8) for better compatibility.</p>
+		<ul>
+			<li><a href="BlockFile.2006.10.06.jar">BlockFile binary JAR, version 0.1.1</a></li>
+			<li><a href="BlockFile.src.2006.10.06.zip">BlockFile source code</a></li>
+		</ul>
+		
+		<h3>Initial Release 9/28/2006</h3>
+		<ul>
+			<li><a href="BlockFile.2006.09.28.jar">BlockFile binary JAR, version 0.1</a></li>
+			<li><a href="BlockFile.src.2006.09.28.zip">BlockFile source code</a></li>
+		</ul>
+
+		<hr />
+		<center>&copy; 2006 <a href="http://www.metanotion.net/">Metanotion Software</a></center>
+	</body>
+</html>
\ No newline at end of file
diff --git a/core/java/src/net/metanotion/util/skiplist/SkipIterator.java b/core/java/src/net/metanotion/util/skiplist/SkipIterator.java
new file mode 100644
index 0000000000..cf2d6e0677
--- /dev/null
+++ b/core/java/src/net/metanotion/util/skiplist/SkipIterator.java
@@ -0,0 +1,105 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.util.skiplist;
+
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+
+/**	A basic iterator for a skip list.
+ 	This is not a complete ListIterator, in particular, since the
+ 	skip list is a map and is therefore indexed by Comparable objects instead
+ 	of int's, the nextIndex and previousIndex methods are not really relevant.
+*/
+public class SkipIterator implements ListIterator {
+	SkipSpan ss;
+	int index;
+
+	protected SkipIterator() { }
+	public SkipIterator(SkipSpan ss, int index) {
+		if(ss==null) { throw new NullPointerException(); }
+		this.ss = ss;
+		this.index = index;
+	}
+
+	public boolean hasNext() {
+		if(index < ss.nKeys) { return true; }
+		return false;
+	}
+
+	public Object next() {
+		Object o;
+		if(index < ss.nKeys) {
+			o = ss.vals[index];
+		} else {
+			throw new NoSuchElementException();
+		}
+
+		if(index < (ss.nKeys-1)) {
+			index++;
+		} else if(ss.next != null) {
+			ss = ss.next;
+			index = 0;
+		} else {
+			index = ss.nKeys;
+		}
+		return o;
+	}
+
+	public Comparable nextKey() {
+		Comparable c;
+		if(index < ss.nKeys) { return ss.keys[index]; }
+		throw new NoSuchElementException();
+	}
+
+	public boolean hasPrevious() {
+		if(index > 0) { return true; }
+		if((ss.prev != null) && (ss.prev.nKeys > 0)) { return true; }
+		return false;
+	}
+
+	public Object previous() {
+		if(index > 0) {
+			index--;
+		} else if(ss.prev != null) {
+			ss = ss.prev;
+			if(ss.nKeys <= 0) { throw new NoSuchElementException(); }
+			index = (ss.nKeys - 1);
+		}
+		return ss.vals[index];
+	}
+
+
+	// Optional methods
+	public void add(Object o)	{ throw new UnsupportedOperationException(); }
+	public void remove()		{ throw new UnsupportedOperationException(); }
+	public void set(Object o)	{ throw new UnsupportedOperationException(); }
+	public int nextIndex()		{ throw new UnsupportedOperationException(); }
+	public int previousIndex()	{ throw new UnsupportedOperationException(); }
+
+}
diff --git a/core/java/src/net/metanotion/util/skiplist/SkipLevels.java b/core/java/src/net/metanotion/util/skiplist/SkipLevels.java
new file mode 100644
index 0000000000..f62b9fb51c
--- /dev/null
+++ b/core/java/src/net/metanotion/util/skiplist/SkipLevels.java
@@ -0,0 +1,168 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.util.skiplist;
+
+public class SkipLevels {
+	/*	"Next" pointers
+		The highest indexed level is the "highest" level in the list.
+		The "bottom" level is the direct pointer to a SkipSpan.
+	*/
+	public SkipLevels[] levels;
+	public SkipSpan bottom;
+
+	public SkipLevels newInstance(int levels, SkipSpan ss, SkipList sl) { return new SkipLevels(levels, ss); }
+	public void killInstance() { }
+	public void flush() { }
+
+	protected SkipLevels() { }
+	public SkipLevels(int size, SkipSpan span) {
+		if(size < 1) { throw new Error("Invalid Level Skip size"); }
+		levels = new SkipLevels[size];
+		bottom = span;
+	}
+
+	public void print() {
+		SkipLevels prev = null;
+		SkipLevels max = null;
+		System.out.print("SL:" + key() + "::");
+		for(int i=0;i<levels.length;i++) {
+			if(levels[i] != null) {
+				max = levels[i];
+				System.out.print(i + "->" + levels[i].key() + " ");
+			} else {
+				System.out.print(i + "->() ");
+			}
+		}
+		System.out.print("\n");
+		if(levels[0] != null) {
+			levels[0].print();
+		}
+	}
+
+	public SkipSpan getEnd() {
+		for(int i=(levels.length - 1);i>=0;i--) {
+			if(levels[i] != null) { return levels[i].getEnd(); }
+		}
+		return bottom.getEnd();
+	}
+
+	public SkipSpan getSpan(int start, Comparable key, int[] search) {
+		for(int i=Math.min(start, levels.length - 1);i>=0;i--) {
+			if((levels[i] != null) && (levels[i].key().compareTo(key) <= 0)) {
+				return levels[i].getSpan(i,key,search);
+			}
+		}
+		return bottom.getSpan(key, search);
+	}
+
+	public Comparable key() { return bottom.keys[0]; }
+
+	public Object get(int start, Comparable key) {
+		for(int i=Math.min(start, levels.length - 1);i>=0;i--) {
+			if((levels[i] != null) && (levels[i].key().compareTo(key) <= 0)) {
+				return levels[i].get(i,key);
+			}
+		}
+		return bottom.get(key);
+	}
+
+	public Object[] remove(int start, Comparable key, SkipList sl) {
+		SkipSpan ss = null;
+		Object[] res = null;
+		SkipLevels slvls = null;
+		for(int i=Math.min(start, levels.length - 1);i>=0;i--) {
+			if(levels[i] != null) {
+				int cmp = levels[i].key().compareTo(key);
+				if((cmp < 0) || ((i==0) && (cmp <= 0)))  {
+					res = levels[i].remove(i, key, sl);
+					if((res != null) && (res[1] != null)) {
+						slvls = (SkipLevels) res[1];
+						if(levels.length >= slvls.levels.length) { res[1] = null; }
+						for(int j=0;j<(Math.min(slvls.levels.length,levels.length));j++) {
+							if(levels[j] == slvls) {
+								levels[j] = slvls.levels[j];
+							}
+						}
+						this.flush();
+					}
+					return res;
+				}
+			}
+		}
+		res = bottom.remove(key, sl);
+		if((res!=null) && (res[1] != null)) {
+			if(res[1] == bottom) {
+				res[1] = this;
+			} else {
+				res[1] = null;
+			}
+		}
+		if((bottom.nKeys == 0) && (sl.first != bottom)) { this.killInstance(); }
+		return res;
+	}
+
+	public SkipLevels put(int start, Comparable key, Object val, SkipList sl) {
+		SkipSpan ss = null;
+		SkipLevels slvls = null;
+		for(int i=Math.min(start, levels.length - 1);i>=0;i--) {
+			if((levels[i] != null) && (levels[i].key().compareTo(key) <= 0)) {
+				slvls = levels[i].put(i, key, val, sl);
+				if(slvls != null) {
+					for(int j=i+1;j<(Math.min(slvls.levels.length,levels.length));j++) {
+						slvls.levels[j] = levels[j];
+						levels[j] = slvls;
+					}
+					if(levels.length < slvls.levels.length) {
+						this.flush();
+						return slvls;
+					}
+				}
+				this.flush();
+				return null;
+			}
+		}
+		ss = bottom.put(key,val,sl);
+		if(ss!=null) {
+			int height = sl.generateColHeight();
+			if(height != 0) {
+				slvls = this.newInstance(height, ss, sl);
+				for(int i=0;i<(Math.min(height,levels.length));i++) {
+					slvls.levels[i] = levels[i];
+					levels[i] = slvls;
+				}
+			}
+			this.flush();
+			if(levels.length >= height) { return null; }
+			return slvls;
+		} else {
+			return null;
+		}
+	}
+}
+
diff --git a/core/java/src/net/metanotion/util/skiplist/SkipList.java b/core/java/src/net/metanotion/util/skiplist/SkipList.java
new file mode 100644
index 0000000000..a2d184d7c9
--- /dev/null
+++ b/core/java/src/net/metanotion/util/skiplist/SkipList.java
@@ -0,0 +1,311 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.util.skiplist;
+
+import java.util.Random;
+
+public class SkipList {
+	protected SkipSpan first;
+	protected SkipLevels stack;
+	public Random rng;
+
+	public int size=0;
+	public int spans=0;
+
+	public void flush() { }
+	protected SkipList() { }
+
+	public SkipList(int span) {
+		if(span < 1) { throw new Error("Span size too small"); }
+		first = new SkipSpan(span);
+		stack = new SkipLevels(1, first);
+		spans = 1;
+		rng = new Random(System.currentTimeMillis());
+	}
+
+	public int size() { return size; }
+
+	public int maxLevels() {
+		int hob = 0, s = spans;
+		while(spans > 0) {
+			hob++;
+			spans = spans / 2;
+		}
+		return (hob > 4) ? hob : 4;
+	}
+
+	public int generateColHeight() {
+		int bits = rng.nextInt();
+		boolean cont = true;
+		int res=0;
+		for(res=0; cont; res++) {
+			cont = ((bits % 2) == 0) ? true : false;
+			bits = bits / 2;
+		}
+		return Math.max(0, Math.min(res, maxLevels()));
+	}
+
+	public void put(Comparable key, Object val)	{
+		if(key == null) { throw new NullPointerException(); }
+		if(val == null) { throw new NullPointerException(); }
+		SkipLevels slvls = stack.put(stack.levels.length - 1, key, val, this);
+		if(slvls != null) {
+			SkipLevels[] levels = new SkipLevels[slvls.levels.length];
+			for(int i=0;i < slvls.levels.length; i++) {
+				if(i < stack.levels.length) {
+					levels[i] = stack.levels[i];
+				} else {
+					levels[i] = slvls;
+				}
+			}
+			stack.levels = levels;
+			stack.flush();
+			flush();
+		}
+	}
+
+	public Object remove(Comparable key) {
+		if(key == null) { throw new NullPointerException(); }
+		Object[] res = stack.remove(stack.levels.length - 1, key, this);
+		if(res != null) {
+			if(res[1] != null) {
+				SkipLevels slvls = (SkipLevels) res[1];
+				for(int i=0;i < slvls.levels.length; i++) {
+					if(stack.levels[i] == slvls) {
+						stack.levels[i] = slvls.levels[i];
+					}
+				}
+				stack.flush();
+			}
+			flush();
+			return res[0];
+		}
+		return null;
+	}
+
+	public void printSL() {
+		System.out.println("List size " + size + " spans " + spans);
+		stack.print();
+	}
+
+	public void print() {
+		System.out.println("List size " + size + " spans " + spans);
+		first.print();
+	}
+
+	public Object get(Comparable key) {
+		if(key == null) { throw new NullPointerException(); }
+		return stack.get(stack.levels.length - 1, key);
+	}
+
+	public SkipIterator iterator() { return new SkipIterator(first, 0); }
+
+	public SkipIterator min() { return new SkipIterator(first, 0); }
+
+	public SkipIterator max() {
+		SkipSpan ss = stack.getEnd();
+		return new SkipIterator(ss, ss.nKeys - 1);
+	}
+
+	public SkipIterator find(Comparable key) {
+		int[] search = new int[1];
+		SkipSpan ss = stack.getSpan(stack.levels.length - 1, key, search);
+		if(search[0] < 0) { search[0] = -1 * (search[0] + 1); }
+		return new SkipIterator(ss, search[0]);
+	}
+
+
+	// Levels adjusted to guarantee O(log n) search
+	// This is expensive proportional to the number of spans.
+	public void balance() {
+		// TODO Skip List Balancing Algorithm
+	}
+
+
+
+/*
+	Basic Error generating conditions to test
+		insert into empty
+		insert into non empty
+		remove from empty
+		remove from non-empty a non-existant key
+		get from empty
+		get from non-empty a non-existant key
+
+		Repeat, with splits induced, and collapse induced.
+*/
+	public static void main(String args[]) {
+		SkipList sl = new SkipList(3);
+		sl.put(".1", "1");
+		sl.remove("2");
+		sl.remove("1");
+		sl.put(".1", "1-1");
+		sl.put(".2", "2");
+		sl.put(".3", "3");
+/*		System.out.println("\n#1");
+		sl.print();
+*/
+
+		sl.put(".4", "4");
+/*		System.out.println("\n#2");
+		sl.print();
+
+		sl.remove("1");
+		System.out.println("\n#2.1");
+		sl.print();
+		sl.remove("2");
+		System.out.println("\n#2.2");
+		sl.print();
+		sl.remove("3");
+		System.out.println("\n#2.3");
+		sl.print();
+		sl.remove("4");
+
+		System.out.println("\n#3");
+		sl.print();
+*/
+		sl.put(".1", "1-2");
+		sl.put(".2", "2-1");
+		sl.put(".3", "3-1");
+		sl.put(".4", "4-1");
+//		System.out.println("\n#4");
+//		sl.print();
+		sl.put(".5", "5-1");
+		sl.put(".6", "6-1");
+		sl.put(".7", "7-1");
+
+//		System.out.println("\n#5");
+//		sl.print();
+
+//		sl.remove("5");
+		sl.put(".5", "5-2");
+//		System.out.println("\n#6");
+//		sl.print();
+
+		sl.put(".8", "8");
+		sl.put(".9", "9");
+		sl.put("10", "10");
+		sl.put("11", "11");
+		sl.put("12", "12");
+		sl.put("13", "13");
+		sl.put("14", "14");
+		sl.put("15", "15");
+		sl.put("16", "16");
+		sl.put("17", "17");
+		sl.put("18", "18");
+		sl.put("19", "19");
+		sl.put("20", "20");
+		sl.put("21", "21");
+		sl.put("22", "22");
+		sl.put("23", "23");
+		sl.put("24", "24");
+		sl.put("25", "25");
+		sl.put("26", "26");
+		sl.put("27", "27");
+		sl.put("28", "28");
+		sl.put("29", "29");
+		sl.put("30", "30");
+		sl.put("31", "31");
+		sl.put("32", "32");
+		sl.put("33", "33");
+		sl.put("34", "34");
+		sl.put("35", "35");
+		sl.put("36", "36");
+		sl.put("37", "37");
+		sl.put("38", "38");
+		sl.put("39", "39");
+		sl.put("40", "40");
+
+//		System.out.println("\n#7");
+//		sl.print();
+		System.out.println("GET " + sl.get("10"));
+		System.out.println("GET " + sl.get("12"));
+		System.out.println("GET " + sl.get("32"));
+		System.out.println("GET " + sl.get("33"));
+		System.out.println("GET " + sl.get("37"));
+		System.out.println("GET " + sl.get("40"));
+
+		sl.printSL();
+
+		sl.remove("33");
+		sl.printSL();
+		sl.remove("34");
+		sl.printSL();
+		sl.remove("36");
+		sl.printSL();
+		sl.remove("35");
+		sl.printSL();
+
+//		System.out.println("\n#8");
+		sl.print();
+		System.out.println("GET " + sl.get("10"));
+		System.out.println("GET " + sl.get("12"));
+		System.out.println("GET " + sl.get("32"));
+		System.out.println("GET " + sl.get("33"));
+		System.out.println("GET " + sl.get("37"));
+		System.out.println("GET " + sl.get("40"));
+
+		System.out.println("Height " + sl.stack.levels.length);
+
+		SkipIterator si = sl.iterator();
+		for(int i=0;i<5;i++) {
+			System.out.println("Iterator: " + si.next());
+		}
+		for(int i=0;i<3;i++) {
+			System.out.println("Iterator: " + si.previous());
+		}
+
+		System.out.println("Find 10");
+		si = sl.find("10");
+		for(int i=0;i<5;i++) {
+			System.out.println("Iterator: " + si.next());
+		}
+		for(int i=0;i<3;i++) {
+			System.out.println("Iterator: " + si.previous());
+		}
+
+		System.out.println("Find 34");
+		si = sl.find("34");
+		for(int i=0;i<3;i++) {
+			System.out.println("Iterator: " + si.previous());
+		}
+		for(int i=0;i<5;i++) {
+			System.out.println("Iterator: " + si.next());
+		}
+
+		System.out.println("Max");
+		si = sl.max();
+		for(int i=0;i<3;i++) {
+			System.out.println("Iterator: " + si.previous());
+		}
+		for(int i=0;i<5;i++) {
+			System.out.println("Iterator: " + si.next());
+		}
+	}
+}
diff --git a/core/java/src/net/metanotion/util/skiplist/SkipSpan.java b/core/java/src/net/metanotion/util/skiplist/SkipSpan.java
new file mode 100644
index 0000000000..9945f0bcee
--- /dev/null
+++ b/core/java/src/net/metanotion/util/skiplist/SkipSpan.java
@@ -0,0 +1,267 @@
+/*
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+package net.metanotion.util.skiplist;
+
+public class SkipSpan {
+	public int nKeys = 0;
+	public Comparable[] keys;
+	public Object[] vals;
+	public SkipSpan next, prev;
+
+	public SkipSpan newInstance(SkipList sl) { return new SkipSpan(keys.length); }
+	public void killInstance() { }
+	public void flush() { }
+
+	protected SkipSpan() { }
+	public SkipSpan(int size) {
+		keys = new Comparable[size];
+		vals = new Object[size];
+	}
+
+	public void print() {
+		System.out.println("Span");
+		for(int i=0;i<nKeys;i++) {
+			System.out.println("\t" + keys[i] + " => " + vals[i]);
+		}
+		if(next != null) { next.print(); }
+	}
+
+	private int binarySearch(Comparable key) {
+ 		int high = nKeys - 1;
+ 		int low = 0;
+ 		int cur;
+ 		int cmp;
+ 		while(low <= high) {
+ 			cur = (low + high) >>> 1;
+ 			cmp = keys[cur].compareTo(key);
+ 			if(cmp > 0) {
+ 				high = cur - 1;
+ 			} else if(cmp < 0) {
+ 				low = cur + 1;
+ 			} else {
+ 				return cur;
+ 			}
+ 		}
+ 		return (-1 * (low + 1));
+	}
+
+	public SkipSpan getEnd() {
+		if(next == null) { return this; }
+		return next.getEnd();
+	}
+
+	public SkipSpan getSpan(Comparable key, int[] search) {
+		if(nKeys == 0) {
+			search[0] = -1;
+			return this;
+		}
+
+		if(keys[nKeys - 1].compareTo(key) < 0) {
+			if(next == null) {
+				search[0] = (-1 * (nKeys - 1)) - 1;
+				return this;
+			}
+			return next.getSpan(key, search);
+		}
+		search[0] = binarySearch(key);
+		return this;
+	}
+
+	public Object get(Comparable key) {
+		if(nKeys == 0) { return null; }
+		if(keys[nKeys - 1].compareTo(key) < 0) {
+			if(next == null) { return null; }
+			return next.get(key);
+		}
+		int loc = binarySearch(key);
+		if(loc < 0) { return null; }
+		return vals[loc];
+	}
+
+	private void pushTogether(int hole) {
+		for(int i=hole;i<(nKeys - 1);i++) {
+			keys[i] = keys[i+1];
+			vals[i] = vals[i+1];
+		}
+		nKeys--;
+	}
+
+	private void pushApart(int start) {
+		for(int i=(nKeys-1);i>=start;i--) {
+			keys[i+1] = keys[i];
+			vals[i+1] = vals[i];
+		}
+		nKeys++;
+	}
+
+	private void split(int loc, Comparable key, Object val, SkipList sl) {
+		SkipSpan right = newInstance(sl);
+		sl.spans++;
+
+		if(this.next != null) { this.next.prev = right; }
+		right.next = this.next;
+		right.prev = this;
+		this.next = right;
+
+		int start = ((keys.length+1)/2);
+		for(int i=start;i < keys.length; i++) {
+			try {
+			right.keys[i-start] = keys[i];
+			right.vals[i-start] = vals[i];
+			right.nKeys++;
+			this.nKeys--;
+			} catch (ArrayIndexOutOfBoundsException e) {
+				System.out.println("i " + i + " start " + start);
+				System.out.println("key: " + keys[i].toString());
+				throw e;
+			}
+		}
+		if(loc >= start) {
+			right.pushApart(loc - start);
+			right.keys[loc - start] = key;
+			right.vals[loc - start] = val;
+		} else {
+			pushApart(loc);
+			keys[loc] = key;
+			vals[loc] = val;
+		}
+		this.flush();
+		this.next.flush();
+	}
+
+	private SkipSpan insert(int loc, Comparable key, Object val, SkipList sl) {
+		sl.size++;
+		if(nKeys == keys.length) {
+			// split.
+			split(loc, key, val, sl);
+			return next;
+		} else {
+			pushApart(loc);
+			keys[loc] = key;
+			vals[loc] = val;
+			this.flush();
+			return null;
+		}
+	}
+
+	public SkipSpan put(Comparable key, Object val, SkipList sl)	{
+		if(nKeys == 0) {
+			sl.size++;
+			keys[0] = key;
+			vals[0] = val;
+			nKeys++;
+			this.flush();
+			return null;
+		}
+		int loc = binarySearch(key);
+		if(loc < 0) {
+			loc = -1 * (loc + 1);
+			if(next != null) {
+				int cmp = next.keys[0].compareTo(key);
+				if((loc >= nKeys) && (cmp > 0)) {
+					// It fits in between this span and the next
+					// Try to avoid a split...
+					if(nKeys == keys.length) {
+						if(next.nKeys == keys.length) {
+							return insert(loc, key, val, sl);
+						} else {
+							return next.put(key, val, sl);
+						}
+					} else {
+						return insert(loc, key, val, sl);
+					}
+				} else {
+					// Its either clearly in the next span or this span.
+					if(cmp > 0) {
+						return insert(loc, key, val, sl);
+					} else {
+						return next.put(key, val, sl);
+					}
+				}
+			} else {
+				// There is no next span, So
+				// either it goes here, or causes a split.
+				return insert(loc, key, val, sl);
+			}
+		} else {
+			// Key already exists. Overwrite value.
+			vals[loc] = val;
+			this.flush();
+			return null;
+		}
+	}
+
+	public Object[] remove(Comparable key, SkipList sl) {
+		if(nKeys == 0) { return null; }
+		if(keys[nKeys - 1].compareTo(key) < 0) {
+			if(next == null) { return null; }
+			return next.remove(key, sl);
+		}
+		int loc = binarySearch(key);
+		if(loc < 0) { return null; }
+		Object o = vals[loc];
+		Object[] res = new Object[2];
+		res[0] = o;
+		sl.size--;
+		if(nKeys == 1) {
+			if(sl.spans > 1) { sl.spans--; }
+			if((this.prev == null) && (this.next != null)) {
+				res[1] = this.next;
+				// We're the first node in the list...
+				for(int i=0;i<next.nKeys;i++) {
+					keys[i] = next.keys[i];
+					vals[i] = next.vals[i];
+				}
+				nKeys = next.nKeys;
+				SkipSpan nn = next.next;
+				next.killInstance();
+				this.flush();
+				this.next = nn;
+			} else {
+				res[1] = this;
+				if(this.prev != null) {
+					this.prev.next = this.next;
+					this.prev.flush();
+				}
+				if(this.next != null) {
+					this.next.prev = this.prev;
+					this.next.flush();
+				}
+				this.next = null;
+				this.prev = null;
+				nKeys = 0;
+				this.killInstance();
+			}
+		} else {
+			pushTogether(loc);
+			this.flush();
+		}
+		return res;
+	}
+}
diff --git a/licenses/LICENSE-BlockFile.txt b/licenses/LICENSE-BlockFile.txt
new file mode 100644
index 0000000000..d98565b1a4
--- /dev/null
+++ b/licenses/LICENSE-BlockFile.txt
@@ -0,0 +1,26 @@
+Copyright (c) 2006, Matthew Estes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+	* Neither the name of Metanotion Software nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-- 
GitLab