Subversion Repositories Code-Repo

import java.nio.ByteBuffer;

// Assisting class for converting classes to a byte array and vice versa

public class NodeSerializer {

	private MemManager memoryManager;

	// Constructor

	public NodeSerializer(MemManager mem) {

		memoryManager = mem;

	}

	// Removes the handle and subhandles for leaf nodes (city name)

	public void removeHandle(Handle handle) {

		PRQuadTreeNode node = handleToNode(handle);

		if (node instanceof PRQuadTreeNodeFlyweight) {

			return;

		} else if (node instanceof PRQuadTreeNodeLeaf) {

			byte[] array = new byte[memoryManager.getDataBlockSize(handle)];

			memoryManager.get(array, handle);

			ByteBuffer buffer = ByteBuffer.wrap(array);

			int records = (int)buffer.get();

			records = (int)buffer.get();

			for (int i = 0; i < records; i++) {

				// Remove the CityRecord and the name of the city

				int addr = buffer.getInt();

				Handle cityhandle = new Handle(addr);

				removeCityRecordHandle(cityhandle);

			}

		} 

		memoryManager.remove(handle);

	}

	public void removeCityRecordHandle(Handle handle) {

		// Remove the handle to the city name

		byte[] data = new byte[memoryManager.getDataBlockSize(handle)];

		memoryManager.get(data, handle);

		ByteBuffer cityrecord = ByteBuffer.wrap(data);

		Handle name = new Handle(cityrecord.getInt(8));

		memoryManager.remove(name);

		memoryManager.remove(handle);

	}

	// Resets the empty block list in the memory manager to the size of the file

	public void clearMemory() {

		memoryManager.clear();

	}

	// Print debug info from the memory manager

	public void printDebug() {

		memoryManager.printBuffer();

		memoryManager.dump();

	}

	// Allocates the node onto disk and returns a handle to the node

	public Handle nodeToHandle(PRQuadTreeNode node) {

		if (node instanceof PRQuadTreeNodeInternal) {

			byte[] array = nodeInternalToByteArray((PRQuadTreeNodeInternal)node);

			Handle ret = memoryManager.insert(array, array.length);

			return ret;

		} else if (node instanceof PRQuadTreeNodeLeaf) {

			byte[] array = nodeLeafToByteArray((PRQuadTreeNodeLeaf)node);

			Handle ret = memoryManager.insert(array, array.length);

			return ret;

		} else {

			Handle ret = new Handle(-1);

			return ret;

		}

	}

	// Reads a handle off the disk and returns the corresponding

	public PRQuadTreeNode handleToNode(Handle handle) {

		if (handle.getAddress() == -1) {

			PRQuadTreeNodeFlyweight ret = new PRQuadTreeNodeFlyweight();

			return ret;

		} else {

			byte[] array = new byte[memoryManager.getDataBlockSize(handle)];

			memoryManager.get(array, handle);

			return byteArrayToNode(array);

		}

	}

	private byte[] stringToByteArray(String str) {

		// Use ByteBuffer to serialize to bytes

		byte[] byteArray = new byte[str.length() + 1];

		byte[] bstr = str.getBytes();

		ByteBuffer buffer = ByteBuffer.wrap(byteArray);

		// Set first byte as the length

		buffer.put((byte)bstr.length);

		// Set remaining bytes as the string

		buffer.put(bstr);

		return byteArray;

	}

	private byte[] nodeInternalToByteArray(PRQuadTreeNodeInternal node) {

		byte[] byteArray = new byte[17];

		ByteBuffer buffer = ByteBuffer.wrap(byteArray);

		buffer.put((byte)1);

		buffer.putInt((int)node.getNW().getAddress());

		buffer.putInt((int)node.getNE().getAddress());

		buffer.putInt((int)node.getSW().getAddress());

		buffer.putInt((int)node.getSE().getAddress());

		return byteArray;

	}

	private byte[] nodeLeafToByteArray(PRQuadTreeNodeLeaf node) {

		byte[] byteArray = new byte[14];

		ByteBuffer buffer = ByteBuffer.wrap(byteArray);

		// Set first byte to indicate leaf node

		buffer.put((byte)0);

		// Set second byte to hold number of records

		buffer.put((byte)node.getCount());

		CityRecord record = (CityRecord) node.getFirst();

		buffer.putInt((int)cityRecordToHandle(record).getAddress());

		record = (CityRecord) node.getNext(record);

		while (record != null) {

			buffer.putInt((int)cityRecordToHandle(record).getAddress());

			record = (CityRecord) node.getNext(record);

		}

		return byteArray;

	}

	private String byteArrayToString(byte[] byteArray) {

		ByteBuffer buffer = ByteBuffer.wrap(byteArray);

		byte[] bstr = new byte[(int)buffer.get()];

		buffer.get(bstr);

		String str = new String(bstr);

		return str;

	}

	private PRQuadTreeNode byteArrayToNode(byte[] data) {

		ByteBuffer buffer = ByteBuffer.wrap(data);

		// Internal node

		byte b = buffer.get();

		if (b == (byte)1) {

			PRQuadTreeNodeInternal newNode = new PRQuadTreeNodeInternal(new Handle(-1), this);

			Handle NW = new Handle(buffer.getInt());

			Handle NE = new Handle(buffer.getInt());

			Handle SW = new Handle(buffer.getInt());

			Handle SE = new Handle(buffer.getInt());

			newNode.setNW(NW);

			newNode.setNE(NE);

			newNode.setSW(SW);

			newNode.setSE(SE);

			return newNode;

		// Leaf node

		} else if (b == (byte)0) {

			PRQuadTreeNodeLeaf newNode = new PRQuadTreeNodeLeaf(3);

			int records = (int)buffer.get();

			for (int i = 0; i < records; i++) {

				int address = buffer.getInt();

				Handle handle = new Handle(address);

				CityRecord record = handleToCityRecord(handle);

				newNode.insert(record);

			}

			return newNode;

		} else {

			return null;

		}

	}

	public Handle cityRecordToHandle(CityRecord record) {

		byte[] data = new byte[12];

		ByteBuffer buffer = ByteBuffer.wrap(data);

		byte[] cityname = stringToByteArray(record.getName());

		Handle handle = memoryManager.insert(cityname, cityname.length);

		buffer.putInt(record.getX());

		buffer.putInt(record.getY());

		buffer.putInt((int)handle.getAddress());

		Handle ret = memoryManager.insert(data, 12);

		return ret;

	}

	public CityRecord handleToCityRecord(Handle handle) {

		byte[] data = new byte[12];

		memoryManager.get(data, handle);

		ByteBuffer buffer = ByteBuffer.wrap(data);

		int x = buffer.getInt();

		int y = buffer.getInt();

		int addr = buffer.getInt();

		Handle cityhandle = new Handle(addr);

		byte[] city = new byte[memoryManager.getDataBlockSize(cityhandle)];

		memoryManager.get(city, cityhandle);

		String cityname = byteArrayToString(city);

		CityRecord record = new CityRecord(cityname, x, y);

		return record;

	}

}