multiple synchronous requests now possible; additional ObjectID stuff

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);

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;
+		}
 	}
 }

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>----------------------------------//		
+	}
+}