public Task <object> Sql(string command, object[] parameters) { EnsureExecutor(); Dictionary <string, object> executionArgs = new Dictionary <string, object>(); executionArgs["connectionString"] = _connectionString; executionArgs["command"] = command; executionArgs["parameters"] = Script.Or(parameters, null); if (_localFile) { executionArgs["localFile"] = true; } Deferred <object> deferred = Deferred.Create <object>(); _executor(executionArgs, delegate(Exception e, object o) { if (e != null) { deferred.Reject(e); } else { deferred.Resolve(o); } }); return(deferred.Task); }
public Promise <MultiPlayerMessage> SendRequest(MultiPlayerMessage message, TimeSpan?timeout = null) { try { message.Sender = ClientId; message.RequestId = Guid.NewGuid().ToString(); var pendingRequest = new PendingRequest() { Id = message.RequestId, ResponseDeferred = Deferred <MultiPlayerMessage> .Create(), }; if (timeout.HasValue) { pendingRequest.Timeout = timeout.Value; } lock (pendingRequests) { pendingRequests.Add(message.RequestId, pendingRequest); } SendMessage(message); return(pendingRequest.ResponseDeferred.Promise); } catch (Exception ex) { var d = Deferred <MultiPlayerMessage> .Create(); d.Reject(ex); return(d.Promise); } }
public static Promise <ConsoleString> ShowRichTextInput(ConsoleString message, bool allowEscapeToCancel = true, int maxHeight = 12, ConsoleString initialValue = null) { var d = Deferred <ConsoleString> .Create(); ShowRichTextInput(message, (ret) => d.Resolve(ret), () => d.Resolve(null), allowEscapeToCancel, maxHeight, initialValue: initialValue); return(d.Promise); }
public static Promise <T?> PickFromEnum <T>(ConsoleString message) where T : struct { Deferred <T?> deferred = Deferred <T?> .Create(); var enumVals = Enum.GetValues(typeof(T)); List <T> genericVals = new List <T>(); foreach (T val in enumVals) { genericVals.Add(val); } var innerPromise = Pick(message, genericVals.Select(v => new DialogOption() { Id = v.ToString(), DisplayText = v.ToString().ToConsoleString() })); innerPromise.Finally((p) => { if (p.Exception != null) { deferred.Reject(p.Exception); } else { deferred.Resolve(innerPromise.Result != null ? (T)Enum.Parse(typeof(T), innerPromise.Result.Id) : default(T?)); } }); return(deferred.Promise); }
protected override Task <object> ExecuteQuery(DataRequest request, Dictionary <string, object> options) { DataQuery query = request.Query; Dictionary <string, Dictionary <string, object> > set = GetDataSet(query); object result; if (query.IsLookup) { result = Script.Or(set[query.ID], null); } else { // TODO: Apply query List <Dictionary <string, object> > items = new List <Dictionary <string, object> >(); foreach (KeyValuePair <string, Dictionary <string, object> > itemEntry in set) { items.Add(itemEntry.Value); } result = items; } return(Deferred.Create <object>(result).Task); }
public ApiRequestObject(ApiRequest request) { Verb = request.Verb; ActionName = request.ActionName; Arguments = request.ActionArguments; Headers = request.Headers; Data = request.Data; Respond = delegate(object data, Dictionary <string, object> options) { options = Script.Or(options, new Dictionary <string, object>()); HttpStatusCode statusCode = Script.Or((HttpStatusCode)options["statusCode"], (data == null) ? HttpStatusCode.NoContent : HttpStatusCode.OK); ServerResponse response = new ServerResponse(statusCode); if (data != null) { if (data is string) { response.AddTextContent((string)data, Script.Or((string)options["contentType"], "text/plain")); } else { response.AddObjectContent(data); } } return(Deferred.Create <ServerResponse>(response).Task); }; }
/// <summary> /// Does nothing /// </summary> /// <param name="soundId">unused</param> /// <returns>a promise that resolves immediately to a dummy disposable</returns> public Promise <IDisposable> Loop(string soundId) { var d = Deferred <IDisposable> .Create(); d.Resolve(new DummyDisposable()); return(d.Promise); }
public Promise Play() { introDeferred = Deferred.Create(); SpaceTime.QueueAction("GameIntro", PlaySceneInternal); SpaceTime.Start("PowerArgsGameIntro"); return(introDeferred.Promise); }
internal static Promise AcceptConnection(InProcClientNetworkProvider inProcClient, ServerInfo serverInfo) { var d = Deferred.Create(); try { var server = servers[serverInfo.Server + ":" + serverInfo.Port]; if (server.allowNewConnections) { server.inProcClients.Add(inProcClient.ClientId, inProcClient); server.ClientConnected.Fire(new MultiPlayerClientConnection() { ClientId = inProcClient.ClientId }); } else { throw new IOException("new connections not allowed"); } d.Resolve(); } catch (Exception ex) { d.Reject(ex); } return(d.Promise); }
public Promise Play() { introDeferred = Deferred.Create(); SpaceTime.QueueAction(PlaySceneInternal); SpaceTime.Start(); return(introDeferred.Promise); }
public static Task <MongoWineRepository> Create(string dbHost, int dbPort, string dbName, string userName, string password) { Deferred <MongoWineRepository> deferred = Deferred.Create <MongoWineRepository>(); Dictionary <string, object> serverOptions = new Dictionary <string, object>("auto_reconnect", true); Dictionary <string, object> dbOptions = new Dictionary <string, object>("w", "0"); MongoServer dbServer = new MongoServer(dbHost, dbPort, serverOptions); MongoConnector dbConnector = new MongoConnector(dbName, dbServer, dbOptions); dbConnector.Open(delegate(Exception openError, MongoDatabase db) { db.Authenticate(userName, password, delegate(Exception authError, bool success) { if (success) { db.CreateCollection("wines", delegate(Exception collectionError, MongoCollection collection) { if (collection != null) { MongoWineRepository repository = new MongoWineRepository(db, collection); deferred.Resolve(repository); } else { deferred.Reject(); } }); } else { deferred.Reject(); } }); }); return(deferred.Task); }
public Promise Connect(ServerInfo server) { var d = Deferred.Create(); try { client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); if (IPAddress.TryParse(server.Server, out IPAddress ip)) { client.Connect(ip, server.Port); } else { client.Connect(server.Server, server.Port); } this.ClientId = (client.LocalEndPoint as IPEndPoint).Address + ":" + (client.LocalEndPoint as IPEndPoint).Port; Thread t = new Thread(ListenForMessages); t.IsBackground = true; t.Start(d); } catch (Exception ex) { d.Reject(ex); } return(d.Promise); }
public async Task TestWhenAllWithExceptions() { var promises = new List <Promise>(); for (var i = 0; i < 10; i++) { var myI = i; Deferred d = Deferred.Create(); promises.Add(d.Promise); Task.Factory.StartNew(() => { if (myI % 2 == 0) { d.Resolve(); } else { d.Reject(new Exception("Failed")); } }); } try { await Promise.WhenAll(promises).AsAwaitable(); Assert.Fail("An exception should have been thrown"); } catch (PromiseWaitException ex) { Assert.AreEqual(5, ex.InnerExceptions.Count); } }
/// <summary> /// Shows a message and lets the user pick from a set of options defined by an enum /// </summary> /// <param name="message">the message to show</param> /// <param name="enumType">the enum type</param> /// <returns>A promise that resolves with the selected value or null if the dialog was cancelled. The promise never rejects.</returns> public static Promise <object> ShowEnumOptions(ConsoleString message, Type enumType) { Deferred <object> deferred = Deferred <object> .Create(); var rawPromise = ShowMessage(new DialogButtonOptions() { Message = message, Mode = DialogButtonsPresentationMode.Grid, Options = Enums.GetEnumValues(enumType).OrderBy(e => e.ToString()).Select(e => new DialogOption() { Id = e.ToString(), DisplayText = e.ToString().ToConsoleString(), Value = e }).ToList() }); rawPromise.Then((b) => { if (b == null) { deferred.Resolve(null); } else { deferred.Resolve(b.Value); } }); return(deferred.Promise); }
/// <summary> /// Starts the time simulation thread /// </summary> /// <param name="name">the name of the thread to start. This is useful when debugging.</param> /// <returns>A promise that represents the end of the time simulation</returns> public Promise Start(string name = "TimeThread") { runDeferred = Deferred.Create(); runDeferred.Promise.Finally((p) => { runDeferred = null; }); Thread t = new Thread(() => { SynchronizationContext.SetSynchronizationContext(syncContext); IsRunning = true; try { current = this; Loop(); } catch (StopTimeException) { IsRunning = false; runDeferred.Resolve(); } catch (Exception ex) { IsRunning = false; UnhandledException.Fire(ex); runDeferred.Reject(ex); } }) { Name = name }; t.Priority = ThreadPriority.AboveNormal; t.IsBackground = true; t.Start(); return(runDeferred.Promise); }
/// <summary> /// Shows a dialog with the given message and provides the user with a yes and no option /// </summary> /// <param name="message">the message to show</param> /// <returns>a promise that resolves if the yes option was cicked. it rejects if no was clicked or if the dialog was cancelled</returns> public static Promise ShowYesConfirmation(ConsoleString message) { var d = Deferred.Create(); var buttonPromise = ShowMessage(new DialogButtonOptions() { Message = message, Options = new List <DialogOption>() { DialogButtonOptions.Yes, DialogButtonOptions.No } }); buttonPromise.Then((button) => { if (button != null && button.Equals(DialogButtonOptions.Yes)) { d.Resolve(); } else { d.Reject(new Exception("No was selected")); } }); return(d.Promise); }
public Task <ServerResponse> ProcessRequest(ServerRequest request) { string controllerName = request.Route.Parameters["controllerName"]; Controller controller = _endpoints.GetController(controllerName); if (controller == null) { return(Deferred.Create <ServerResponse>(ServerResponse.NotFound).Task); } ApiRequest apiRequest = new ApiRequest(controller, request.HttpRequest.Method, request.Route.Parameters["actionName"], (Dictionary <string, string>)request.HttpRequest.Headers, request.UrlData.Query); if (controller.SupportsRequest(apiRequest) == false) { return(Deferred.Create <ServerResponse>(ServerResponse.MethodNotAllowed).Task); } if ((request.HttpRequest.Method == HttpVerb.POST) || (request.HttpRequest.Method == HttpVerb.PUT)) { Deferred <ServerResponse> deferred = Deferred.Create <ServerResponse>(); request.GetData().ContinueWith(delegate(Task <object> dataTask) { if (dataTask.Status == TaskStatus.Failed) { deferred.Reject(dataTask.Error); return; } Task <ServerResponse> executeTask; try { apiRequest.Data = dataTask.Result; executeTask = ExecuteRequest(controller, apiRequest); } catch (Exception e) { deferred.Resolve(ServerResponse.CreateServerError(e.Message)); return; } executeTask.ContinueWith(delegate(Task <ServerResponse> t) { if (t.Status == TaskStatus.Done) { deferred.Resolve(t.Result); } else { deferred.Resolve(ServerResponse.CreateServerError(t.Error.Message)); } }); }); return(deferred.Task); } else { return(ExecuteRequest(controller, apiRequest)); } }
public Promise OpenForNewConnections() { var d = Deferred.Create(); allowNewConnections = true; d.Resolve(); return(d.Promise); }
public Promise CloseForNewConnections() { var d = Deferred.Create(); allowNewConnections = false; d.Resolve(); return(d.Promise); }
public Test() { Deferred deferredObject = Deferred.Create(); Deferred <int> deferredNumber = Deferred.Create <int>(); Deferred <int> availabledNumber = Deferred.Create <int>(10); deferredNumber.Reject(); }
/// <summary> /// Shows the dialog on top of the current app /// </summary> /// <returns>a promise that resolves when this dialog is dismissed. This promise never rejects.</returns> private Promise Show() { ConsoleApp.AssertAppThread(); var deferred = Deferred.Create(); ConsoleApp.Current.LayoutRoot.Add(this); RemovedFromVisualTree.SubscribeForLifetime(deferred.Resolve, this); return(deferred.Promise); }
/// <summary> /// Shows a message and lets the user pick from a set of options defined by an enum /// </summary> /// <typeparam name="T">the enum type</typeparam> /// <param name="message">the message to show</param> /// <returns>A promise that resolves with the selected value or null if the dialog was cancelled. The promise never rejects.</returns> public static Promise <T?> ShowEnumOptions <T>(ConsoleString message) where T : struct { var d = Deferred <T?> .Create(); var rawPromise = ShowEnumOptions(message, typeof(T)); rawPromise.Then((o) => d.Resolve(o == null ? new T?() : (T)o)); return(d.Promise); }
/// <summary> /// Shows a dialog that presents the user with a message and a text box /// </summary> /// <param name="options">the options used to configure the dialog</param> /// <returns>a promise that resolves with the value of the text box at the time of dismissal. This promise never rejects.</returns> public static Promise <ConsoleString> ShowRichTextInput(RichTextDialogOptions options) { var d = Deferred <ConsoleString> .Create(); var rawPromise = new Dialog(options).Show(); rawPromise.Then(() => d.Resolve(options.TextBox.Value)); return(d.Promise); }
/// <summary> /// Shows a dialog with a message and a set of options for the user to choose from /// </summary> /// <param name="options">the options used to configure the dialog</param> /// <returns>a promise that resolves with the selected option or null if the dialog was cancelled. The promise never rejects.</returns> public static Promise <DialogOption> ShowMessage(DialogButtonOptions options) { var d = Deferred <DialogOption> .Create(); var rawPromise = new Dialog(options).Show(); rawPromise.Then(() => d.Resolve(options.SelectedOption)); return(d.Promise); }
protected override Task <object> ExecuteNonQuery(DataRequest request, Dictionary <string, object> options) { Dictionary <string, Dictionary <string, object> > set = GetDataSet(request.Query); string id = request.Query.ID; object result = false; if (request.Operation == DataOperation.Insert) { if (set.ContainsKey(id) == false) { Dictionary <string, object> item = request.Item; item["id"] = id; set[id] = item; result = true; } } else if (request.Operation == DataOperation.Update) { if (set.ContainsKey(id)) { Dictionary <string, object> item = request.Item; item["id"] = id; set[id] = item; result = true; } } else if (request.Operation == DataOperation.Merge) { if (set.ContainsKey(id)) { Dictionary <string, object> existingItem = set[id]; Dictionary <string, object> updatedItem = request.Item; foreach (KeyValuePair <string, object> fieldEntry in updatedItem) { existingItem[fieldEntry.Key] = fieldEntry.Value; } existingItem["id"] = id; result = true; } } else if (request.Operation == DataOperation.Delete_) { if (set.ContainsKey(id)) { set.Remove(id); result = true; } } return(Deferred.Create <object>(result).Task); }
/// <summary> /// Does nothing /// </summary> /// <param name="soundId">unused</param> public Promise <Lifetime> Play(string soundId) { var d = Deferred <Lifetime> .Create(); var l = new Lifetime(); l.Dispose(); d.Resolve(l); return(d.Promise); }
/// <summary> /// Queues up a request to paint the app. The system will dedupe multiple paint requests when there are multiple in the pump's work queue /// <returns>a promise that resolves after the paint happens</returns> /// </summary> public Promise Paint() { var d = Deferred.Create(); QueueAction(new PaintMessage(PaintInternal) { Deferred = d }); return(d.Promise); }
protected override Promise <List <T> > FetchRangeAsync(int min, int count) { var d = Deferred <List <T> > .Create(); new Thread(() => { Thread.Sleep(50); d.Resolve(items.Skip(min).Take(count).ToList()); }).Start(); return(d.Promise); }
protected override Promise <int> FetchCountAsync() { var d = Deferred <int> .Create(); new Thread(() => { Thread.Sleep(50); d.Resolve(items.Count); }).Start(); return(d.Promise); }
/// <summary> /// Puts the given action into the work queue, but skips it to the front of the queue /// </summary> /// <param name="a">the action code to run</param> /// <returns>a promise that will resolve when the work is done</returns> protected Promise QueueActionInFront(Action a) { var d = Deferred.Create(); var pumpMessage = new PumpMessage(a) { Deferred = d }; QueueActionInFront(pumpMessage); return(d.Promise); }