diff --git a/src/as3/mongo/db/DB.as b/src/as3/mongo/db/DB.as
index 16f19d0..7cd4a99 100644
--- a/src/as3/mongo/db/DB.as
+++ b/src/as3/mongo/db/DB.as
@@ -17,7 +17,7 @@ package as3.mongo.db
 	{
 		protected var _authenticated:Signal         = new Signal(DB);
 		protected var _authenticationProblem:Signal = new Signal(DB);
-		protected var _connected:Signal             = new Signal(DB);
+//		protected var _connected:Signal             = new Signal(DB);
 		protected var _connectionFailed:Signal      = new Signal(DB);
 		protected var _socketPolicyFileError:Signal = new Signal(DB);
 
@@ -41,12 +41,12 @@ package as3.mongo.db
 		{
 			return _connectionFailed;
 		}
-
+		/*
 		public function get connected():Signal
 		{
 			return _connected;
 		}
-
+		*/
 		public function get authenticationProblem():Signal
 		{
 			return _authenticationProblem;
@@ -76,12 +76,12 @@ package as3.mongo.db
 		{
 			return (_credentials is Credentials);
 		}
-
+		/*
 		public function get isConnected():Boolean
 		{
 			return _isConnected;
 		}
-
+		*/
 		public function get port():uint
 		{
 			return _port;
@@ -114,14 +114,14 @@ package as3.mongo.db
 
 		private function _initialize(databaseName:String, databaseHost:String, databasePort:uint):void
 		{
-			_wire = new Wire(this);
-
 			_collections = new Dictionary();
 			_authenticationFactory = new AuthenticationFactory();
 
 			_name = databaseName;
 			_host = databaseHost;
 			_port = databasePort;
+			
+			_wire = new Wire(this);
 		}
 
 		public function setCredentials(dbCredentials:Credentials):void
@@ -165,12 +165,12 @@ package as3.mongo.db
 		{
 			return wire.runCommand(command);
 		}
-
+		/*
 		public function connect():void
 		{
 			wire.connect();
 		}
-
+		*/
 		public function insert(collectionName:String, document:Document):void
 		{
 			wire.insert(name, collectionName, document);
diff --git a/src/as3/mongo/db/document/Document.as b/src/as3/mongo/db/document/Document.as
index 26242c6..5c9e540 100644
--- a/src/as3/mongo/db/document/Document.as
+++ b/src/as3/mongo/db/document/Document.as
@@ -1,7 +1,7 @@
 package as3.mongo.db.document
 {
 	import as3.mongo.error.MongoError;
-
+	
 	import org.serialization.bson.ObjectID;
 
 	public class Document
@@ -71,12 +71,86 @@ package as3.mongo.db.document
 		{
 			return _values[index];
 		}
+		
+		/**
+		 * ERICSOCO ADDED
+		 */
+		public function getValueByKey(key:String):*
+		{
+			var index:int = _keys.indexOf(key);
+			if (index == -1) { return null; }
+			else { return _values[index]; }
+		}
 
 		public function put(key:String, value:*):void
 		{
+			/**
+			 * ERICSOCO ADDED
+			 */
+			var existingIndex:int = _keys.indexOf(key);
+			if (existingIndex != -1) {
+				_values[existingIndex] = value;
+				return;
+			}
+			
 			const nextIndex:Number = _keys.length;
 			_keys[nextIndex] = key;
 			_values[nextIndex] = value;
 		}
+		
+		/**
+		 * ERICSOCO ADDED
+		 */
+		public function remove (key:String) :void {
+			var existingIndex:int = _keys.indexOf(key);
+			if (existingIndex != -1) {
+				_keys.splice(existingIndex, 1);
+				_values.splice(existingIndex, 1);
+			}
+		}
+		
+		/**
+		 * ERICSOCO ADDED
+		 */
+		public function toString (tabLevel:int=0) :String {
+			function addTabs () :String {
+				var tabStr:String = "";
+				for (var t:int=0; t<tabLevel; t++) {
+					tabStr += "\t";
+				}
+				return tabStr;
+			}
+			
+			var output:String = addTabs() + "{\n";
+			var len:int = _keys.length;
+			var value:*;
+			
+			tabLevel++;
+			for (var i:int=0; i<len; i++) {
+				output += addTabs();
+				output += (_keys[i] + " : ");
+				
+				value = _values[i];
+				if (value is Document) {
+					output += Document(value).toString(tabLevel);
+				} else if (value is Array) {
+					var arr:Array = value as Array;
+					output += "[\n";
+					tabLevel++;
+					for (var j:int=0; j<arr.length; j++) {
+						output += (arr[j].toString(tabLevel) + ",\n");
+					}
+					tabLevel--;
+					output += (addTabs() + "]");
+				} else {
+					output += String(value);
+				}
+				output += "\n";
+			}
+			tabLevel--;
+			
+			output += (addTabs() + "}")
+			return output;
+		}
 	}
 }
diff --git a/src/as3/mongo/wire/RequestSequence.as b/src/as3/mongo/wire/RequestSequence.as
new file mode 100644
index 0000000..178d8c3
--- /dev/null
+++ b/src/as3/mongo/wire/RequestSequence.as
@@ -0,0 +1,105 @@
+package as3.mongo.wire {
+	import as3.mongo.wire.cursor.Cursor;
+	import as3.mongo.wire.messages.IMessage;
+	import as3.mongo.wire.messages.database.OpReply;
+	import as3.mongo.wire.messages.database.OpReplyLoader;
+	
+	import com.transmote.utils.time.Timeout;
+	
+	import flash.events.ErrorEvent;
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.net.Socket;
+
+	public class RequestSequence extends EventDispatcher {
+		private var query:IMessage;
+		private var replyLoader:OpReplyLoader;
+		private var socket:Socket;
+		private var cursor:Cursor;
+		
+		public function RequestSequence (query:IMessage, replyLoader:OpReplyLoader, cursor:Cursor=null) {
+			this.query = query;
+			this.replyLoader = replyLoader;
+			this.cursor = cursor;
+			
+			init();
+		}
+		
+		public function begin (host:String, port:int) :void {
+			if (!socket.connected) {
+				socket.connect(host, port);
+			} else {
+				// force asynchronicity
+				var beginTimeout:Timeout = new Timeout(beginSequence, 1);
+			}
+		}
+		
+		private function init () :void {
+			initSocket();
+		}
+		
+		
+		
+		//-----<REQUEST SEQUENCE>------------------------------------//
+		private function beginSequence () :void {
+			initReplyLoader();
+			doQuery();
+		}
+		
+		private function initReplyLoader () :void {
+			replyLoader.initializeOpReplyLoader(socket);
+			replyLoader.LOADED.addOnce(onReplyLoaded);
+		}
+		
+		private function doQuery () :void {
+			socket.writeBytes(query.toByteArray());
+			socket.flush();
+		}
+		
+		private function onReplyLoaded (reply:OpReply) :void {
+			if (cursor) {
+				cursor.onReplyLoaded(reply);
+			}
+			
+			closeSocket();
+			dispatchEvent(new Event(Event.COMPLETE));
+		}
+		//-----</REQUEST SEQUENCE>-----------------------------------//
+		
+		
+		
+		//-----<SOCKET MANAGEMENT>-----------------------------------//
+		private function initSocket () :void {
+			socket = new Socket();
+			socket.addEventListener(IOErrorEvent.IO_ERROR, onSocketReady);
+			socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSocketReady);
+			socket.addEventListener(Event.CONNECT, onSocketReady);
+		}
+		
+		private function onSocketReady (evt:Event) :void {
+			var socket:Socket = evt.target as Socket;
+			if (!socket) { return; }
+			socket.removeEventListener(IOErrorEvent.IO_ERROR, onSocketReady);
+			socket.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onSocketReady);
+			socket.removeEventListener(Event.CONNECT, onSocketReady);
+			
+			if (evt is ErrorEvent) {
+				dispatchEvent(evt);
+				return;
+			}
+			
+			beginSequence();
+		}
+		
+		private function closeSocket () :void {
+			try {
+				socket.close();
+			} catch (e:Error) {}
+			
+			socket = null;
+		}
+		//-----</SOCKET MANAGEMENT>----------------------------------//		
+	}
+}
\ No newline at end of file
diff --git a/src/as3/mongo/wire/Wire.as b/src/as3/mongo/wire/Wire.as
index 92442b7..382ab63 100644
--- a/src/as3/mongo/wire/Wire.as
+++ b/src/as3/mongo/wire/Wire.as
@@ -5,6 +5,7 @@ package as3.mongo.wire
 	import as3.mongo.error.MongoError;
 	import as3.mongo.wire.cursor.Cursor;
 	import as3.mongo.wire.cursor.GetMoreMessage;
+	import as3.mongo.wire.messages.IMessage;
 	import as3.mongo.wire.messages.MessageFactory;
 	import as3.mongo.wire.messages.client.FindOptions;
 	import as3.mongo.wire.messages.client.OpDelete;
@@ -16,204 +17,177 @@ package as3.mongo.wire
 	import as3.mongo.wire.messages.database.OpReply;
 	import as3.mongo.wire.messages.database.OpReplyLoader;
 	
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
 	import flash.net.Socket;
+	import flash.utils.Dictionary;
 	
 	import org.osflash.signals.Signal;
 	import org.serialization.bson.Int64;
 
-	public class Wire
-	{
-		protected var _socket:Socket;
-		protected var _messageFactory:MessageFactory;
-
-		protected var _db:DB;
-		protected var _isConnected:Boolean;
-		protected var _messenger:Messenger;
-		protected var _connector:Connector;
-		protected var _cursorFactory:CursorFactory;
-		protected var _activeCursors:Array;
-
-		public function get connector():Connector
-		{
-			return _connector;
-		}
-
-		public function get messenger():Messenger
-		{
-			return _messenger;
-		}
-
-		public function get db():DB
-		{
-			return _db;
-		}
-
-		public function get messageFactory():MessageFactory
-		{
-			return _messageFactory;
-		}
-
-		public function get socket():Socket
-		{
-			return _socket;
-		}
-
-		public function get isConnected():Boolean
-		{
-			return _isConnected;
-		}
-
-		public function Wire(db:DB)
-		{
-			_initializeWire(db);
-		}
-
-		private function _initializeWire(db:DB):void
-		{
-			_db = db;
-			_socket = new Socket();
-			_messenger = new Messenger(this);
-			_connector = new Connector(this);
-			_messageFactory = new MessageFactory();
-			_cursorFactory = new CursorFactory();
-			_activeCursors = new Array();
-		}
-
-		public function connect():void
-		{
-			_connector.connect();
-		}
-
-		internal function setConnected(value:Boolean):void
-		{
-			_isConnected = value;
-		}
-
-		public function runCommand(command:Document):Signal
-		{
-			_checkIfSocketIsConnected();
-			const opQuery:OpQuery             = messageFactory.makeRunCommandOpQueryMessage(_db.name, "$cmd", command);
-			const opReplyLoader:OpReplyLoader = new OpReplyLoader(socket);
-			_messenger.sendMessage(opQuery);
-
-			_activeOpReplyLoaders.push(opReplyLoader);
-			opReplyLoader.LOADED.addOnce(_onOpReplyLoaded);
-			return opReplyLoader.LOADED;
-		}
-
-		private var _activeOpReplyLoaders:Vector.<OpReplyLoader> = new Vector.<OpReplyLoader>();
-
-		public function findOne(collectionName:String, query:Document, returnFields:Document=null):Signal
-		{
-			_checkIfSocketIsConnected();
-			const opQuery:OpQuery                           = messageFactory.makeFindOneOpQueryMessage(_db.name, collectionName, query, returnFields);
-			const findOneOpReplyLoader:FindOneOpReplyLoader = new FindOneOpReplyLoader(socket);
-			_messenger.sendMessage(opQuery);
-
-			_activeOpReplyLoaders.push(findOneOpReplyLoader);
-			findOneOpReplyLoader.LOADED.addOnce(_onOpReplyLoaded);
-			return findOneOpReplyLoader.LOADED;
-		}
-
-		private function _onOpReplyLoaded(document:Object):void
-		{
-			const loadedLoaders:Vector.<OpReplyLoader> = new Vector.<OpReplyLoader>();
-			var loader:OpReplyLoader
-			for each (loader in _activeOpReplyLoaders)
-			{
-				if (loader.isLoaded)
-					loadedLoaders.push(loader);
-			}
-
-			for each (loader in loadedLoaders)
-			{
-				if (_activeOpReplyLoaders.lastIndexOf(loader) != -1)
-					_activeOpReplyLoaders.splice(_activeOpReplyLoaders.lastIndexOf(loader), 1);
-			}
-		}
-
-		private function _checkIfSocketIsConnected():void
-		{
-			if (false === socket.connected)
-				throw new MongoError(MongoError.SOCKET_NOT_CONNECTED);
-		}
-
-		// TODO: Write integration tests for this
-		public function insert(dbName:String, collectionName:String, document:Document):void
-		{
-			_checkIfSocketIsConnected();
+	public class Wire {
+		private var db:DB;
+		private var messageFactory:MessageFactory;
+		
+		// for requests that just push bytes through the Socket and don't wait for a reply
+		private var noReplySocket:Socket;
+		private var pendingNoReplyMessages:Vector.<IMessage>;
+		
+		private var activeRequestSequences:Vector.<RequestSequence>;
+		
+
+		public function Wire (db:DB) {
+			this.db = db;
+			init();
+		}
+		
+		
+		//-----<REQUESTS>--------------------------------------------//
+		//-----no-reply requests-----//
+		public function insert (dbName:String, collectionName:String, document:Document) :void {
 			const opInsert:OpInsert = messageFactory.makeSaveOpInsertMessage(dbName, collectionName, document);
-			_messenger.sendMessage(opInsert);
+			sendMessage(opInsert);
 		}
-
-		// TODO: Write integration tests for this
-		public function remove(dbName:String, collectionName:String, selector:Document):void
-		{
-			_checkIfSocketIsConnected();
+		
+		public function remove (dbName:String, collectionName:String, selector:Document) :void {
 			const opDelete:OpDelete = messageFactory.makeRemoveOpDeleteMessage(dbName, collectionName, selector);
-			_messenger.sendMessage(opDelete);
+			sendMessage(opDelete);
 		}
-
-		// TODO: Write integration tests for this
-		public function updateFirst(dbName:String, collectionName:String, selector:Document, document:Document):void
-		{
-			_checkIfSocketIsConnected();
+		
+		public function updateFirst (dbName:String, collectionName:String, selector:Document, document:Document) :void {
 			const opUpdate:OpUpdate = messageFactory.makeUpdateFirstOpUpdateMessage(dbName, collectionName, selector, document);
-			_messenger.sendMessage(opUpdate);
+			sendMessage(opUpdate);
 		}
-
-		// TODO: Write integration tests for this
-		public function update(dbName:String, collectionName:String, selector:Document, modifier:Document):void
-		{
-			_checkIfSocketIsConnected();
+		
+		public function update (dbName:String, collectionName:String, selector:Document, modifier:Document) :void {
 			const opUpdate:OpUpdate = messageFactory.makeUpdateOpUpdateMessage(dbName, collectionName, selector, modifier);
-			_messenger.sendMessage(opUpdate);
+			sendMessage(opUpdate);
 		}
-
-		// TODO: Write integration tests for this
-		public function upsert(dbName:String, collectionName:String, selector:Document, document:Document):void
-		{
-			_checkIfSocketIsConnected();
+		
+		public function upsert (dbName:String, collectionName:String, selector:Document, document:Document) :void {
 			const opUpdate:OpUpdate = messageFactory.makeUpsertOpUpdateMessage(dbName, collectionName, selector, document);
-			_messenger.sendMessage(opUpdate);
+			sendMessage(opUpdate);
 		}
-
-		public function find(dbName:String, collectionName:String, query:Document, options:FindOptions=null):Signal
-		{
-			if (null == options)
+		
+		//-----request sequences-----//
+		public function find (dbName:String, collectionName:String, query:Document, options:FindOptions=null) :Signal {
+			if (null == options) {
 				options = new FindOptions();
+			}
 			
-			_checkIfSocketIsConnected();
-			const opQuery:OpQuery             = messageFactory.makeFindOpQueryMessage(dbName, collectionName, query, options);
-			const opReplyLoader:OpReplyLoader = new OpReplyLoader(socket);
-
-			const cursor:Cursor               = _cursorFactory.getCursor(opReplyLoader);
+			const opQuery:OpQuery = messageFactory.makeFindOpQueryMessage(dbName, collectionName, query, options);
+			const opReplyLoader:OpReplyLoader = new OpReplyLoader();
+			
+			var cursor:Cursor = new Cursor();
 			cursor.getMoreMessage = new GetMoreMessage(dbName, collectionName, options, this, cursor);
-			_activeCursors.push(cursor);
-			cursor.cursorReady.addOnce(_onCursorReady);
-
-			_messenger.sendMessage(opQuery);
+			
+			launchRequestSequence(opQuery, opReplyLoader, cursor);
+			
 			return cursor.cursorReady;
 		}
+		
+		public function findOne (collectionName:String, query:Document, returnFields:Document=null) :Signal {
+			const opQuery:OpQuery = messageFactory.makeFindOneOpQueryMessage(db.name, collectionName, query, returnFields);
+			const findOneOpReplyLoader:FindOneOpReplyLoader = new FindOneOpReplyLoader();
+			launchRequestSequence(opQuery, findOneOpReplyLoader);
 
-		private function _onCursorReady(cursor:Cursor):void
-		{
-			if (-1 < _activeCursors.lastIndexOf(cursor))
-			{
-				_activeCursors.splice(_activeCursors.lastIndexOf(cursor), 1);
-			}
+			return findOneOpReplyLoader.LOADED;
 		}
-
-		public function getMore(dbName:String, collectionName:String, options:FindOptions, cursorID:Int64):Signal
-		{
-			_checkIfSocketIsConnected();
-
-			const opGetMore:OpGetMore         = messageFactory.makeGetMoreOpGetMoreMessage(dbName, collectionName, options.numberToReturn, cursorID);
-			const opReplyLoader:OpReplyLoader = new OpReplyLoader(socket);
-			_messenger.sendMessage(opGetMore);
-			_activeOpReplyLoaders.push(opReplyLoader);
-			opReplyLoader.LOADED.addOnce(_onOpReplyLoaded);
+		
+		public function getMore (dbName:String, collectionName:String, options:FindOptions, cursorID:Int64) :Signal {
+			const opGetMore:OpGetMore = messageFactory.makeGetMoreOpGetMoreMessage(dbName, collectionName, options.numberToReturn, cursorID);
+			const opReplyLoader:OpReplyLoader = new OpReplyLoader();
+			launchRequestSequence(opGetMore, opReplyLoader);
+			
+			return opReplyLoader.LOADED;
+		}
+		
+		public function runCommand (command:Document) :Signal {
+			const opQuery:OpQuery = messageFactory.makeRunCommandOpQueryMessage(db.name, "$cmd", command);
+			const opReplyLoader:OpReplyLoader = new OpReplyLoader();
+			launchRequestSequence(opQuery, opReplyLoader);
+			
 			return opReplyLoader.LOADED;
 		}
+		//-----</REQUESTS>-------------------------------------------//
+		
+		
+		
+		private function init () :void {
+			initSocketResources();
+			messageFactory = new MessageFactory();
+			activeRequestSequences = new Vector.<RequestSequence>();
+		}
+		
+		private function sendMessage (message:IMessage) :void {
+			if (!noReplySocket.connected) {
+				pendingNoReplyMessages.push(message);
+				return;
+			}
+			
+			noReplySocket.writeBytes(message.toByteArray());
+			noReplySocket.flush();
+		}
+		
+		private function launchRequestSequence (query:IMessage, replyLoader:OpReplyLoader, cursor:Cursor=null) :void {
+			var rs:RequestSequence = new RequestSequence(query, replyLoader, cursor);
+			
+			rs.addEventListener(IOErrorEvent.IO_ERROR, onRequestSequenceComplete);
+			rs.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onRequestSequenceComplete);
+			rs.addEventListener(Event.COMPLETE, onRequestSequenceComplete);
+			
+			activeRequestSequences.push(rs);
+			rs.begin(db.host, db.port);
+		}
+		
+		private function onRequestSequenceComplete (evt:Event) :void {
+			var rs:RequestSequence = evt.target as RequestSequence;
+			if (!rs) { return; }
+			
+			rs.removeEventListener(IOErrorEvent.IO_ERROR, onRequestSequenceComplete);
+			rs.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onRequestSequenceComplete);
+			rs.removeEventListener(Event.COMPLETE, onRequestSequenceComplete);
+			
+			var i:int = activeRequestSequences.indexOf(rs);
+			if (i != -1) {
+				activeRequestSequences.splice(i, 1);
+			}
+			
+			if (evt is IOErrorEvent) {
+				db.connectionFailed.dispatch(db);
+			} else if (evt is SecurityErrorEvent) {
+				db.socketPolicyFileError.dispatch(db);
+			}
+		}
+		
+		private function initSocketResources () :void {
+			pendingNoReplyMessages = new Vector.<IMessage>();
+			
+			noReplySocket = new Socket();
+			noReplySocket.addEventListener(IOErrorEvent.IO_ERROR, onSocketReady);
+			noReplySocket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSocketReady);
+			noReplySocket.addEventListener(Event.CONNECT, onSocketReady);
+			noReplySocket.connect(db.host, db.port);
+		}
+		
+		private function onSocketReady (evt:Event) :void {
+			noReplySocket.removeEventListener(IOErrorEvent.IO_ERROR, onSocketReady);
+			noReplySocket.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onSocketReady);
+			noReplySocket.removeEventListener(Event.CONNECT, onSocketReady);
+			
+			if (evt is IOErrorEvent) {
+				db.connectionFailed.dispatch(db);
+				return;
+			} else if (evt is SecurityErrorEvent) {
+				db.socketPolicyFileError.dispatch(db);
+				return;
+			}
+			
+			for (var i:int=0; i<pendingNoReplyMessages.length; i++) {
+				sendMessage(pendingNoReplyMessages[i]);
+			}
+			pendingNoReplyMessages = null;
+		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/as3/mongo/wire/cursor/Cursor.as b/src/as3/mongo/wire/cursor/Cursor.as
index 4b42f97..7865e31 100644
--- a/src/as3/mongo/wire/cursor/Cursor.as
+++ b/src/as3/mongo/wire/cursor/Cursor.as
@@ -1,16 +1,14 @@
 package as3.mongo.wire.cursor
 {
 	import as3.mongo.wire.messages.database.OpReply;
-	import as3.mongo.wire.messages.database.OpReplyLoader;
-
+	
 	import flash.utils.Dictionary;
-
+	
 	import org.osflash.signals.Signal;
 	import org.serialization.bson.Int64;
 
 	public class Cursor
 	{
-		protected var _opReplyLoader:OpReplyLoader;
 		protected var _ready:Boolean;
 		protected var _totalDocumentsLoaded:uint;
 		protected var _cursorID:Int64;
@@ -22,9 +20,21 @@ package as3.mongo.wire.cursor
 		protected var _gotMore:Signal       = new Signal(Cursor);
 		protected var _getMoreMessage:GetMoreMessage;
 
-		public function Cursor(opReplyLoader:OpReplyLoader)
+		public function Cursor()
 		{
-			_initializeCursor(opReplyLoader);
+			//
+		}
+		
+		public function onReplyLoaded (opReply:OpReply) :void {
+			_totalDocumentsLoaded += opReply.numberReturned;
+			_cursorID = opReply.cursorID;
+			_cacheDocuments(opReply);
+			
+			if (!_ready)
+			{
+				_ready = true;
+				_cursorReady.dispatch(this);
+			}
 		}
 
 		public function set getMoreMessage(value:GetMoreMessage):void
@@ -44,7 +54,7 @@ package as3.mongo.wire.cursor
 
 		public function toString():String
 		{
-			return "Cursor{_opReplyLoader:" + _opReplyLoader + ", _ready:" + _ready + ", _totalDocumentsLoaded:" + _totalDocumentsLoaded + ", _cursorID:" + _cursorID + ", _documents:" + _documents + ", _currentIndex:" + _currentIndex + ", _lastIndexCached:" + _lastIndexCached + ", _activeIndices:[" + _activeIndices + "]}";
+			return "Cursor{_ready:" + _ready + ", _totalDocumentsLoaded:" + _totalDocumentsLoaded + ", _cursorID:" + _cursorID + ", _documents:" + _documents + ", _currentIndex:" + _currentIndex + ", _lastIndexCached:" + _lastIndexCached + ", _activeIndices:[" + _activeIndices + "]}";
 		}
 
 		public function get cursorID():Int64
@@ -62,25 +72,6 @@ package as3.mongo.wire.cursor
 			return _ready;
 		}
 
-		private function _initializeCursor(opReplyLoader:OpReplyLoader):void
-		{
-			_opReplyLoader = opReplyLoader;
-			_opReplyLoader.LOADED.addOnce(_onLoaded);
-		}
-
-		private function _onLoaded(opReply:OpReply):void
-		{
-			_totalDocumentsLoaded += opReply.numberReturned;
-			_cursorID = opReply.cursorID;
-			_cacheDocuments(opReply);
-
-			if (!_ready)
-			{
-				_ready = true;
-				_cursorReady.dispatch(this);
-			}
-		}
-
 		private function _cacheDocuments(opReply:OpReply):void
 		{
 			var returnIndex:uint;
diff --git a/src/as3/mongo/wire/messages/database/FindOneOpReplyLoader.as b/src/as3/mongo/wire/messages/database/FindOneOpReplyLoader.as
index e906206..09735e0 100644
--- a/src/as3/mongo/wire/messages/database/FindOneOpReplyLoader.as
+++ b/src/as3/mongo/wire/messages/database/FindOneOpReplyLoader.as
@@ -6,14 +6,14 @@ package as3.mongo.wire.messages.database
 
 	public class FindOneOpReplyLoader extends OpReplyLoader
 	{
-		public function FindOneOpReplyLoader(aSocket:Socket)
+		public function FindOneOpReplyLoader()
 		{
-			super(aSocket);
+			//
 		}
 
-		override protected function _initializeOpReplyLoader(aSocket:Socket):void
+		override public function initializeOpReplyLoader(aSocket:Socket):void
 		{
-			super._initializeOpReplyLoader(aSocket);
+			super.initializeOpReplyLoader(aSocket);
 
 			_LOADED = new Signal(FindOneResult);
 		}
diff --git a/src/as3/mongo/wire/messages/database/OpReplyLoader.as b/src/as3/mongo/wire/messages/database/OpReplyLoader.as
index 4467089..e436458 100644
--- a/src/as3/mongo/wire/messages/database/OpReplyLoader.as
+++ b/src/as3/mongo/wire/messages/database/OpReplyLoader.as
@@ -16,9 +16,9 @@ package as3.mongo.wire.messages.database
 		protected var _currentReplyLength:int;
 		protected var _amountOfBytesLoaded:uint;
 
-		public function OpReplyLoader(aSocket:Socket)
+		public function OpReplyLoader()
 		{
-			_initializeOpReplyLoader(aSocket);
+			_LOADED = new Signal(OpReply);
 		}
 
 		public function get opReply():OpReply
@@ -41,11 +41,10 @@ package as3.mongo.wire.messages.database
 			return _socket;
 		}
 
-		protected function _initializeOpReplyLoader(aSocket:Socket):void
+		public function initializeOpReplyLoader(aSocket:Socket):void
 		{
 			_socket = aSocket;
 			_socket.addEventListener(ProgressEvent.SOCKET_DATA, _handleSocketData, false, 0, true);
-			_LOADED = new Signal(OpReply);
 		}
 
 		private function _handleSocketData(event:ProgressEvent):void
diff --git a/src/org/serialization/bson/ObjectID.as b/src/org/serialization/bson/ObjectID.as
index 6266e6b..0718aaf 100644
--- a/src/org/serialization/bson/ObjectID.as
+++ b/src/org/serialization/bson/ObjectID.as
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2010 Claudio Alberto Andreoni.
+ * Modifications by Eric Socolofsky: http://transmote.com.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -21,24 +22,29 @@
  *
  */
 
-package org.serialization.bson
-{
+package org.serialization.bson {
+	import flash.net.NetworkInfo;
+	import flash.net.NetworkInterface;
 	import flash.utils.ByteArray;
-	import flash.utils.Endian;
+	import flash.utils.Endian;
 
-	public class ObjectID extends Object
-	{
+	public class ObjectID {
+		private static var incrementer : uint = Math.random() * uint.MAX_VALUE;
+		private static var machineAndProcessID : ByteArray = null;
 
 		// BSON is little-endian
-		private var rep:ByteArray;
+		private var rep : ByteArray;
+		private var time : uint;
 
 		/**
 		 * @brief Create a new ObjectID
 		 * @param bytearray A little-endian, 12-byte ByteArray containing the ID
 		 */
-		public function ObjectID(bytearray:ByteArray):void
-		{
-			setFromBytes(bytearray);
+		public function ObjectID( bytearray : ByteArray = null ) :void {
+			if (bytearray == null) {
+				bytearray = generateObjectID();
+			}
+			setFromBytes( bytearray );
 		}
 
 
@@ -47,13 +53,14 @@ package org.serialization.bson
 		 * @brief Set the value of this ObjectID
 		 * @param bytearray A little-endian, 12-byte ByteArray containing the ID
 		 */
-		public function setFromBytes(bytearray:ByteArray):void
-		{
+		public function setFromBytes( bytearray : ByteArray ) :void {
 			rep = new ByteArray();
-			for (var i:int = 0; i < 12; ++i)
-			{
+			for ( var i : int = 0; i < 12; ++i ) {
 				rep[i] = bytearray.readByte();
 			}
+			
+			time = rep.readUnsignedInt();
+			rep.position = 0;
 		}
 
 
@@ -62,19 +69,80 @@ package org.serialization.bson
 		 * @brief Get the value of this ObjectID
 		 * @return A little-endian, 12-byte ByteArray containing the ID
 		 */
-		public function getAsBytes():ByteArray
-		{
+		public function getAsBytes() : ByteArray {
 			return rep;
 		}
 
-		public function toString():String
-		{
+		public function toString() : String {
 			var str:String = "";
-			for (var i:int = 0; i < 12; ++i)
-			{
-				str += rep[i].toString(16);
+			for ( var i : int = 0; i < 12; ++i ) {
+				str += rep[i].toString( 16 );
 			}
 			return str;
 		}
+		
+		public function toDate() : Date {
+			return new Date( time * 1000 );
+		}
+		
+		private function generateObjectID() :ByteArray {
+			// from: http://www.mongodb.org/display/DOCS/Object+IDs
+			
+			// 4-byte timestamp
+			time = new Date().getTime();
+			var timeBytes:ByteArray = new ByteArray();
+			timeBytes.endian = Endian.BIG_ENDIAN;
+			timeBytes.writeInt( time );
+			timeBytes.length = 4;	// truncate as needed
+			
+			// 3-byte machine id + 2-byte process id
+			if ( machineAndProcessID == null ) {
+				generateMachineID();
+			}
+			
+			// 3-byte increment
+			var incBytes:ByteArray = new ByteArray();
+			incBytes.endian = Endian.BIG_ENDIAN;
+			incBytes.writeUnsignedInt( incrementer++ );
+			incBytes.length = 3;		// truncate as needed
+			
+			var idBytes:ByteArray = new ByteArray();
+			idBytes.writeBytes( timeBytes );
+			idBytes.writeBytes( machineAndProcessID );
+			idBytes.writeBytes( incBytes );
+			
+			idBytes.position = 0;
+			return idBytes;
+		}
+		
+		private function generateMachineID() :void {
+			machineAndProcessID = new ByteArray();
+			machineAndProcessID.endian = Endian.LITTLE_ENDIAN;
+			
+			var useRandom:Boolean = true;
+			for each ( var i : NetworkInterface in NetworkInfo.networkInfo.findInterfaces() ) {
+				if ( i.hardwareAddress ) {
+					machineAndProcessID.writeUTFBytes( i.hardwareAddress );
+					useRandom = false;
+					break;
+				}
+			}
+			
+			if ( useRandom ) {
+				// if no NetworkInterfaces with valid hardware addresses found, use random
+				var randomMachineID : uint = Math.floor( Math.random() * uint.MAX_VALUE );
+				machineAndProcessID.writeUnsignedInt( randomMachineID );
+			}
+			
+			machineAndProcessID.length = 3;		// truncate as needed
+			
+			// not possible to get process id from flash without launching a NativeProcess,
+			// which requires AIR application with extendedDesktop profile.
+			// so, use a random.
+			var processID:uint = Math.floor( Math.random() * uint.MAX_VALUE );
+			machineAndProcessID.writeUnsignedInt( processID );
+			
+			machineAndProcessID.length = 5;		// truncate as needed
+		}
 	}
 }