public static void registerDep(IRef aref) { var v = REGISTER_DEP.deref(); if(v != null) { ((RegisterDep)v).register(aref); } }
/// Construct a multifunction. /// </summary> /// <param name="name">The name</param> /// <param name="dispatchFn">The dispatch function.</param> /// <param name="defaultDispatchVal">The default dispatch value.</param> /// <param name="hierarchy">The hierarchy for this multifunction</param> public MultiFn(string name, IFn dispatchFn, object defaultDispatchVal, IRef hierarchy) { _name = name; _dispatchFn = dispatchFn; _defaultDispatchVal = defaultDispatchVal; _methodTable = PersistentHashMap.EMPTY; _methodCache = MethodTable; _preferTable = PersistentHashMap.EMPTY; _hierarchy = hierarchy; _cachedHierarchy = null; }
/// <inheritdoc /> public void DrawBitmap(IRef <IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode) { var drawableImage = (IDrawableBitmapImpl)source.Item; var s = sourceRect.ToSKRect(); var d = destRect.ToSKRect(); using (var paint = new SKPaint { Color = new SKColor(255, 255, 255, (byte)(255 * opacity * _currentOpacity)) }) { paint.FilterQuality = bitmapInterpolationMode.ToSKFilterQuality(); paint.BlendMode = _currentBlendingMode.ToSKBlendMode(); drawableImage.Draw(this, s, d, paint); } }
public static async Task <HttpResponseMessage> CreateAsync( [Property(Name = IdPropertyName)] IRef <TableBackup> tableBackupRef, [Property(Name = WhenPropertyName)] DateTime when, [Property(Name = TableNamePropertyName)] string tableName, [Property(Name = IdPropertyName)] IRef <RepositoryBackup> repositoryBackupRef, [Resource] TableBackup tableBackup, RequestMessage <TableBackup> requestQuery, HttpRequestMessage request, EastFive.Analytics.ILogger logger, CreatedBodyResponse <InvocationMessage> onCreated, AlreadyExistsResponse onAlreadyExists) { return(await await tableBackup.StorageCreateAsync( async (entity) => { var invocationMessage = await requestQuery .ById(tableBackupRef) .HttpPatch(default)
/// <summary> /// Draws a bitmap image. /// </summary> /// <param name="source">The bitmap image.</param> /// <param name="opacityMask">The opacity mask to draw with.</param> /// <param name="opacityMaskRect">The destination rect for the opacity mask.</param> /// <param name="destRect">The rect in the output to draw to.</param> public void DrawImage(IRef <IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect) { using (var d2dSource = ((BitmapImpl)source.Item).GetDirect2DBitmap(_deviceContext)) using (var sourceBrush = new BitmapBrush(_deviceContext, d2dSource.Value)) using (var d2dOpacityMask = CreateBrush(opacityMask, opacityMaskRect.Size)) using (var geometry = new SharpDX.Direct2D1.RectangleGeometry(_deviceContext.Factory, destRect.ToDirect2D())) { if (d2dOpacityMask.PlatformBrush != null) { d2dOpacityMask.PlatformBrush.Transform = Matrix.CreateTranslation(opacityMaskRect.Position).ToDirect2D(); } _deviceContext.FillGeometry( geometry, sourceBrush, d2dOpacityMask.PlatformBrush); } }
private void RenderOverlay(Scene scene, IDrawingContextImpl parentContent) { if (DrawDirtyRects) { var overlay = GetOverlay(parentContent, scene.Size, scene.Scaling); using (var context = overlay.Item.CreateDrawingContext(this)) { context.Clear(Colors.Transparent); RenderDirtyRects(context); } } else { _overlay?.Dispose(); _overlay = null; } }
public static Task <HttpResponseMessage> UpdateBodyAsync( [UpdateId(Name = SessionIdPropertyName)] IRef <Session> sessionRef, [PropertyOptional(Name = AuthorizationPropertyName)] IRefOptional <Authorization> authorizationRefMaybe, Api.Azure.AzureApplication application, ContentTypeResponse <Session> onUpdated, NotFoundResponse onNotFound, ForbiddenResponse forbidden, ConfigurationFailureResponse onConfigurationFailure, GeneralConflictResponse onFailure) { return(sessionRef.StorageUpdateAsync( (sessionStorage, saveSessionAsync) => { return Security.AppSettings.TokenScope.ConfigurationUri( scope => { return Security.SessionServer.Configuration.AppSettings.TokenExpirationInMinutes.ConfigurationDouble( async(tokenExpirationInMinutes) => { return await await GetClaimsAsync(application, authorizationRefMaybe, async(claims, accountIdMaybe, authorized) => { sessionStorage.authorization = authorizationRefMaybe; sessionStorage.authorized = authorized; sessionStorage.account = accountIdMaybe; return await BlackBarLabs.Security.Tokens.JwtTools.CreateToken(sessionRef.id, scope, TimeSpan.FromMinutes(tokenExpirationInMinutes), claims, async(tokenNew) => { sessionStorage.token = tokenNew; await saveSessionAsync(sessionStorage); return onUpdated(sessionStorage); }, (missingConfig) => onConfigurationFailure("Missing", missingConfig).AsTask(), (configName, issue) => onConfigurationFailure(configName, issue).AsTask()); }, why => onFailure(why).AsTask()); }, why => onConfigurationFailure("Missing", why).AsTask()); }, (why) => onConfigurationFailure("Missing", why).AsTask()); }, onNotFound: () => onNotFound())); }
/// <summary> /// Add a new reference to be tracked /// </summary> /// <param name="refId">The ID of the reference</param> /// <param name="_ref">The object we're tracking</param> /// <param name="incrementCount">If true, we increment the <see cref="refCounts" /> at this ID</param> public void Add(int refId, IRef _ref, bool incrementCount = true) { int previousCount; if (!refs.ContainsKey(refId)) { refs[refId] = _ref; previousCount = 0; } else { previousCount = refCounts[refId]; } if (incrementCount) { refCounts[refId] = previousCount + 1; } }
public static Task <IHttpResponse> HttpGetAsync <TResource>( this IRef <TResource> resourceRef, ContentTypeResponse <TResource> onFound, NotFoundResponse onNotFound, Func <TResource, TResource> mutation = default) where TResource : IReferenceable { return(resourceRef.StorageGetAsync( (resource) => { if (mutation.IsDefaultOrNull()) { return onFound(resource); } var updatedResource = mutation(resource); return onFound(updatedResource); }, () => onNotFound())); }
public static async Task <IHttpResponse> CreateAsync( [Property(Name = IdPropertyName)] IRef <TableBackupOperation> tableBackupOperationRef, [Property(Name = WhenPropertyName)] DateTime when, [Property(Name = TableBackupPropertyName)] IRef <TableBackup> tableBackupRef, [Property(Name = OperationSetPropertyName)] string operationSet, [Resource] TableBackupOperation tableBackup, RequestMessage <TableBackupOperation> requestQuery, IHttpRequest request, EastFive.Api.Security security, EastFive.Analytics.ILogger logger, CreatedBodyResponse <InvocationMessage> onCreated, AlreadyExistsResponse onAlreadyExists) { return(await await tableBackup.StorageCreateAsync( async (discard) => { var invocationMessage = await requestQuery .ById(tableBackupOperationRef) .HttpPatch(default)
/// <summary> /// Remove all references contained in <see cref="deletedRefs"></see> from the tracking maps (<see cref="refs" /> and /// <see cref="refCounts" />). Clears <see cref="deletedRefs" /> afterwards /// </summary> public void GarbageCollection() { int totalDeletedRefs = deletedRefs.Count; for (int i = 0; i < totalDeletedRefs; i++) { int refId = deletedRefs[i]; if (refCounts[refId] <= 0) { IRef _ref = refs[refId]; if (_ref is Schema) { foreach (KeyValuePair <string, System.Type> field in ((Schema)_ref).GetFieldChildTypes()) { object fieldValue = ((Schema)_ref)[field.Key]; if ( fieldValue is IRef && Remove(((IRef)fieldValue).__refId)) { totalDeletedRefs++; } } } else if (_ref is ISchemaCollection && ((ISchemaCollection)_ref).HasSchemaChild) { IDictionary items = ((ISchemaCollection)_ref).GetItems(); foreach (IRef item in items.Values) { if (Remove(item.__refId)) { totalDeletedRefs++; } } } refs.Remove(refId); refCounts.Remove(refId); } } deletedRefs.Clear(); }
public static Task <HttpResponseMessage> GetByRequestIdAsync( [QueryParameter(Name = SessionIdPropertyName, CheckFileName = true)] IRef <Session> sessionRef, [QueryParameter(Name = "request_id")] IRef <Authorization> authorization, EastFive.Api.SessionToken security, Api.Azure.AzureApplication application, UrlHelper urlHelper, ContentTypeResponse <Session> onUpdated, NotFoundResponse onNotFound, ForbiddenResponse forbidden, ConfigurationFailureResponse onConfigurationFailure, GeneralConflictResponse onFailure) { return(UpdateBodyAsync(sessionRef, authorization.Optional(), application, onUpdated, onNotFound, forbidden, onConfigurationFailure, onFailure)); }
/// <summary> /// Disposes of the renderer and detaches from the render loop. /// </summary> public void Dispose() { lock (_sceneLock) { if (_disposed) { return; } _disposed = true; var scene = _scene; _scene = null; scene?.Dispose(); } Stop(); // Wait for any in-progress rendering to complete lock (_renderLoopIsRenderingLock){} DisposeRenderTarget(); }
public static async Task <HttpResponseMessage> QueryByIntegrationAsync( [QueryParameter(Name = "integration")] IRef <Integration> integrationRef, Api.Azure.AzureApplication application, EastFive.Api.SessionToken security, MultipartResponseAsync <Method> onContent, UnauthorizedResponse onUnauthorized, ReferencedDocumentNotFoundResponse <Integration> onIntegrationNotFound) { return(await await integrationRef.StorageGetAsync( async (integration) => { var accountId = integration.accountId; if (!await application.CanAdministerCredentialAsync(accountId, security)) { return onUnauthorized(); } var integrationProviders = application.LoginProviders .Where(loginProvider => loginProvider.Value.GetType().IsSubClassOfGeneric(typeof(IProvideIntegration))) .Select( async loginProvider => { var integrationProvider = loginProvider.Value as IProvideIntegration; var supportsIntegration = await integrationProvider.SupportsIntegrationAsync(accountId); return supportsIntegration.PairWithValue(loginProvider); }) .Await() .Where(kvp => kvp.Key) .SelectValues() .Select( (loginProvider) => { var integrationProvider = loginProvider.Value as IProvideIntegration; return new Method { authenticationId = new Ref <Method>(loginProvider.Value.Id), name = integrationProvider.GetDefaultName(new Dictionary <string, string>()), }; }); return await onContent(integrationProviders); }, () => onIntegrationNotFound().AsTask())); }
public static async Task <IntermediaryItem> MakeIntermediaryItemAsync( IRef <ExampleParentItem> exampleParentItemRef, int children) { var ii = MakeIntermediaryItem(exampleParentItemRef); var iiStored = await ii.StorageCreateAsync( tr => tr.Entity); ExampleLinkedStorage [] childrenMade = await Enumerable .Range(0, children) .Select( i => { return(ExampleLinkedStorage.MakeAsync(ii.intermediaryItemRef)); }) .AsyncEnumerable() .ToArrayAsync(); return(iiStored); }
public static async Task <HttpResponseMessage> GetAsync( [QueryParameter(Name = AuthenticationPropertyName)] IRef <Authentication> authenticationRef, [Accepts(Media = "text/html")] MediaTypeWithQualityHeaderValue accept, HttpRequestMessage request, Api.Azure.AzureApplication application, UrlHelper urlHelper, ContentTypeResponse <Authentication> onFound, HtmlResponse onHtmlWanted, NotFoundResponse onNotFound) { if (!accept.IsDefaultOrNull()) { return(onHtmlWanted(EastFive.Azure.Properties.Resources.loginHtml)); } return(await authenticationRef.StorageGetAsync( (authentication) => { return onFound(authentication); }, () => onNotFound())); }
public static Task <HttpResponseMessage> GetAsync( [QueryParameter(CheckFileName = true, Name = AuthorizationIdPropertyName)] IRef <Authorization> authorizationRef, Api.Azure.AzureApplication application, UrlHelper urlHelper, EastFive.Api.SessionToken?securityMaybe, ContentTypeResponse <Authorization> onFound, NotFoundResponse onNotFound, UnauthorizedResponse onUnauthorized, BadRequestResponse onBadRequest) { return(authorizationRef.StorageUpdateAsync( async(authorization, saveAsync) => { if (authorization.deleted.HasValue) { return onNotFound(); } if (authorization.authorized) { authorization.LocationAuthentication = default(Uri); } if (!securityMaybe.HasValue) { if (authorization.authorized) { if (authorization.expired) { return onBadRequest(); } if (authorization.lastModified - DateTime.UtcNow > TimeSpan.FromMinutes(1.0)) { return onBadRequest(); } authorization.expired = true; await saveAsync(authorization); return onFound(authorization); } } return onFound(authorization); }, () => onNotFound())); }
public static Task <TResult> LoadImageAsync <TResult>(this IRef <Content> contentRef, Func <System.Drawing.Image, string, TResult> onFound, Func <TResult> onNotFound, Func <Stream, string, TResult> onInvalidImage = default) { return(contentRef.id.BlobLoadStreamAsync("content", (imageStream, contentType) => { //var image = System.Drawing.Image.FromStream(imageStream); if (imageStream.TryReadImage(out Image image)) { return onFound(image, contentType); } if (onInvalidImage.IsDefaultOrNull()) { return onNotFound(); } return onInvalidImage(imageStream, contentType); },
public static IEnumerableAsync <KeyValuePair <XIntegration, Authorization> > GetParametersByAccountId( IRef <Method> methodId, Guid accountId) { return(accountId .StorageGetByIdProperty((XIntegration intgration) => intgration.accountId) .Where(integration => integration.Method != null) .Where(integration => integration.Method.id == methodId.id) .Where(integration => integration.authorization.HasValue) .Select( integration => { return integration.authorization.StorageGetAsync( authorization => { return authorization.PairWithKey(integration); }, () => default(KeyValuePair <XIntegration, Authorization>?)); }) .Await() .SelectWhereHasValue()); }
public virtual PlaceResult Place(IPlayer player, IRef referee) { string placePos = player.getMove("Select place position: "); if (!referee.isValidPlacement(placePos, player, this)) { return(PlaceResult.Invalid); } board[placePos].changeState(player.playerID); player.Placed(); if (isInMill(placePos)) { return(PlaceResult.MillMade); } else { return(PlaceResult.Done); } }
public virtual MoveResult Move(IPlayer player, IRef referee) { string piecePos = player.getMove("Enter piece to move: "); if (!referee.isValidPickUp(piecePos, player, this)) { return(MoveResult.InvalidPickUp); } string placePos = player.getMove($@"Place {piecePos} at position: "); if (!referee.isValidPutDown(piecePos, placePos, player, this)) { return(MoveResult.InvalidPutDown); } board[piecePos].changeState(Player.None); board[placePos].changeState(player.playerID); if (isInMill(placePos)) { return(MoveResult.MillMade); } return(MoveResult.Done); }
public async static Task <IHttpResponse> AuthorizeAsync( [QueryParameter(Name = "session")] IRef <Session> sessionRef, [UpdateId(Name = AuthorizationIdPropertyName)] IRef <Authorization> authorizationRef, [Property(Name = ParametersPropertyName)] IDictionary <string, string> parameters, Api.Azure.AzureApplication application, IInvokeApplication endpoints, IHttpRequest request, CreatedBodyResponse <Session> onCreated, NotFoundResponse onAuthorizationDoesNotExist, ForbiddenResponse onAuthorizationFailed, ServiceUnavailableResponse onServiceUnavailable, ForbiddenResponse onInvalidMethod, GeneralConflictResponse onFailure) { return(await await authorizationRef.StorageGetAsync( (authorization) => { return AuthenticateWithSessionAsync(authorizationRef, sessionRef, authorization.Method, parameters, application, endpoints, request, onAuthorized: (sessionCreated, redirect) => { var response = onCreated(sessionCreated, contentType: "application/json"); response.SetLocation(redirect); return response; }, onAuthorizationDoesNotExist: () => onAuthorizationDoesNotExist(), onServiceUnavailable: (why) => onServiceUnavailable().AddReason(why), onInvalidMethod: (why) => onInvalidMethod().AddReason(why), onAuthorizationFailed: why => onAuthorizationFailed().AddReason(why)); }, () => onAuthorizationDoesNotExist().AsTask())); }
public static async Task <IHttpResponse> LaunchAsync( [Api.Meta.Flows.WorkflowParameter(Value = "{{AuthenticationMethod}}")] [QueryParameter(Name = "method")] IRef <Method> methodRef, RequestMessage <AccountRequest> api, IHttpRequest request, IAzureApplication application, IProvideUrl urlHelper, [Api.Meta.Flows.WorkflowVariableRedirectUrl( VariableName = Workflows.AuthorizationFlow.Variables.RedirectUrl)] RedirectResponse onLaunched, BadRequestResponse onInvalidMethod) { return(await await Method.ById(methodRef, application, async method => { var authRef = Ref <Authorization> .SecureRef(); var authorization = new Authorization { authorizationRef = authRef, LocationAuthenticationReturn = api // .Where(query => query.authorization == authRef) .HttpAction(ResponseAction) .CompileRequest(request) .RequestUri, Method = methodRef, }; return await await authorization.StorageCreateAsync( async(discard) => { var redir = await method.GetLoginUrlAsync( application, urlHelper, authRef.id); return onLaunched(redir); }); }, () => onInvalidMethod().AsTask())); }
public static Task <IHttpResponse> HttpPatchAsync <TResource>( this IRef <TResource> resourceRef, MutateResource <TResource> modifyResource, ContentTypeResponse <TResource> onUpdated, NotFoundResponse onNotFound, Func <TResource, TResource> additionalMutations = default) where TResource : IReferenceable { return(resourceRef.StorageUpdateAsync( async(resource, saveAsync) => { var resourceToSave = modifyResource(resource); if (additionalMutations.IsNotDefaultOrNull()) { resourceToSave = additionalMutations(resourceToSave); } await saveAsync(resource); return onUpdated(resource); }, () => onNotFound())); }
public static async Task <TResult> DeleteInternalAsync <TResult>( IRef <Integration> integrationRef, Api.Azure.AzureApplication application, Func <TResult> onDeleted, Func <TResult> onNotFound) { var integrationMaybe = await integrationRef.StorageGetAsync(i => i, () => default(Integration?)); if (!integrationMaybe.HasValue) { return(onNotFound()); } var integration = integrationMaybe.Value; return(await await integrationRef.StorageDeleteAsync( onDeleted: async(discard) => { if (integration.authorization.HasValue) { var authorizationId = integration.authorization.id.Value; var authorizationLookupRef = authorizationId.AsRef <AuthorizationIntegrationLookup>(); await authorizationLookupRef.StorageDeleteAsync( onDeleted: (discard) => true); } var accountIntegrationRef = integration.accountId.AsRef <AccountIntegrationLookup>(); await accountIntegrationRef.StorageUpdateAsync( async(accountLookup, saveAsync) => { accountLookup.integrationRefs = accountLookup.integrationRefs.ids .Where(id => id != integration.id) .AsRefs <Integration>(); await saveAsync(accountLookup); return true; }); return onDeleted(); }, () => onNotFound().AsTask())); }
public static async Task <IHttpResponse> DeleteAsync( [UpdateId(Name = IntegrationIdPropertyName)] IRef <XIntegration> integrationRef, IAuthApplication application, EastFive.Api.SessionToken security, NoContentResponse onDeleted, NotFoundResponse onNotFound, ForbiddenResponse onForbidden) { var integrationMaybe = await integrationRef.StorageGetAsync(i => i, () => default(XIntegration?)); if (!integrationMaybe.HasValue) { return(onNotFound()); } var integration = integrationMaybe.Value; if (!await application.CanAdministerCredentialAsync(integration.accountId, security)) { return(onForbidden()); } return(await DeleteInternalAsync(integrationRef, () => onDeleted(), () => onNotFound())); }
public async static Task <IHttpResponse> CreateAuthorizedAsync( [UpdateId(Name = AuthorizationIdPropertyName)] IRef <Authorization> authorizationRef, [Property(Name = MethodPropertyName)] IRef <Method> methodRef, [Property(Name = ParametersPropertyName)] IDictionary <string, string> parameters, [Resource] Authorization authorization, Api.Azure.AzureApplication application, IProvideUrl urlHelper, IInvokeApplication endpoints, IHttpRequest request, CreatedResponse onCreated, AlreadyExistsResponse onAlreadyExists, ForbiddenResponse onAuthorizationFailed, ServiceUnavailableResponse onServericeUnavailable, ForbiddenResponse onInvalidMethod) { authorization.accountIdMaybe = default; authorization.authorized = false; return(await await Auth.Method.ById(methodRef, application, (method) => { var paramsUpdated = parameters; //.Append( // authorizationRef.id.ToString().PairWithKey("state")) //.ToDictionary(); return Redirection.AuthenticationAsync( method, paramsUpdated, application, request, endpoints, request.RequestUri, authorizationRef.Optional(), (redirect, accountIdMaybe, discardModifier) => onCreated(), () => onAuthorizationFailed().AddReason("Authorization was not found"), // Bad credentials why => onServericeUnavailable().AddReason(why), why => onAuthorizationFailed().AddReason(why)); }, () => onInvalidMethod().AddReason("The method was not found.").AsTask())); }
public async static Task <IHttpResponse> CreateAsync( [Api.Meta.Flows.WorkflowNewId] [Property(Name = AuthorizationIdPropertyName)] IRef <Authorization> authorizationRef, [Api.Meta.Flows.WorkflowParameter(Value = "{{AuthenticationMethod}}")] [Property(Name = MethodPropertyName)] IRef <Method> method, [Api.Meta.Flows.WorkflowParameter(Value = "http://example.com")] [Property(Name = LocationAuthorizationReturnPropertyName)] Uri locationAuthenticationReturn, [Resource] Authorization authorization, IAuthApplication application, IProvideUrl urlHelper, CreatedBodyResponse <Authorization> onCreated, AlreadyExistsResponse onAlreadyExists, ReferencedDocumentDoesNotExistsResponse <Method> onAuthenticationDoesNotExist) { authorization.accountIdMaybe = default; authorization.authorized = false; return(await await Auth.Method.ById(method, application, async (method) => { //var authorizationIdSecure = authentication.authenticationId; authorization.LocationAuthentication = await method.GetLoginUrlAsync( application, urlHelper, authorizationRef.id); //throw new ArgumentNullException(); return await authorization.StorageCreateAsync( createdId => onCreated(authorization), () => onAlreadyExists()); }, () => onAuthenticationDoesNotExist().AsTask())); }
public async static Task <HttpResponseMessage> CreateAsync( [Property(Name = AuthorizationIdPropertyName)] Guid authorizationId, [Property(Name = MethodPropertyName)] IRef <Method> method, [Property(Name = LocationAuthorizationReturnPropertyName)] Uri LocationAuthenticationReturn, [Resource] Authorization authorization, Api.Azure.AzureApplication application, UrlHelper urlHelper, CreatedBodyResponse <Authorization> onCreated, AlreadyExistsResponse onAlreadyExists, ReferencedDocumentDoesNotExistsResponse <Method> onAuthenticationDoesNotExist) { return(await await Auth.Method.ById(method, application, async (authentication) => { //var authorizationIdSecure = authentication.authenticationId; authorization.LocationAuthentication = await authentication.GetLoginUrlAsync( application, urlHelper, authorizationId); throw new NotImplementedException(); return await authorization.StorageCreateAsync( createdId => onCreated(authorization), () => onAlreadyExists()); }, () => onAuthenticationDoesNotExist().AsTask())); }
private static async Task <TResult> GetSessionAcountAsync <TResult>(IRef <Authorization> authorizationRef, Api.Azure.AzureApplication application, Func <Guid, bool, TResult> onSuccess, Func <string, bool, TResult> onFailure) { return(await await authorizationRef.StorageGetAsync( async (authorization) => { var methodRef = authorization.Method; return await await Method.ById(methodRef, application, async method => { return await await method.GetAuthorizationKeyAsync(application, authorization.parameters, (externalUserKey) => { return Auth.AccountMapping.FindByMethodAndKeyAsync(method.authenticationId, externalUserKey, authorization, accountId => onSuccess(accountId, authorization.authorized), () => onFailure("No mapping to that account.", authorization.authorized)); }, (why) => onFailure(why, authorization.authorized).AsTask(), () => onFailure("This login method is no longer supported.", false).AsTask()); }, () => { return CheckSuperAdminBeforeFailure(authorizationRef, "Authorization method is no longer valid on this system.", authorization.authorized, onSuccess, onFailure).AsTask(); }); }, () => { return CheckSuperAdminBeforeFailure(authorizationRef, "Authorization not found.", false, onSuccess, onFailure).AsTask(); })); }
/// <summary> /// Ensures that this node draw operations have been created and are mutable (in case we are using cloned operations). /// </summary> private void EnsureDrawOperationsCreated() { if (_drawOperations == null) { _drawOperations = new List <IRef <IDrawOperation> >(); _drawOperationsRefCounter = RefCountable.Create(CreateDisposeDrawOperations(_drawOperations)); _drawOperationsCloned = false; } else if (_drawOperationsCloned) { var oldDrawOperations = _drawOperations; _drawOperations = new List <IRef <IDrawOperation> >(oldDrawOperations.Count); foreach (var drawOperation in oldDrawOperations) { _drawOperations.Add(drawOperation.Clone()); } _drawOperationsRefCounter.Dispose(); _drawOperationsRefCounter = RefCountable.Create(CreateDisposeDrawOperations(_drawOperations)); _drawOperationsCloned = false; } }
public static Task <IHttpResponse> CreateAsync( [EastFive.Api.Meta.Flows.WorkflowNewId] [WorkflowVariable(Workflows.MonitoringFlow.Variables.CreatedNotification, IdPropertyName)] [UpdateId] IRef <TeamsNotification> teamsNotificationRef, [PropertyOptional(Name = RouteFiltersPropertyName)] [WorkflowArrayObjectParameter(Value0 = "/api/*")] string routeFilters, [PropertyOptional(Name = CollectionPropertyName)] [WorkflowParameter(Value = "Collection1", Disabled = true)] string collection, [Resource] TeamsNotification storyBoard, CreatedResponse onCreated, AlreadyExistsResponse onAlreadyExists, UnauthorizedResponse onUnauthorized) { return(storyBoard.HttpPostAsync( onCreated, onAlreadyExists)); }
public static object refSet(IRef rf, object value, Context cx) { return rf.Set (cx, value); }
public static object refDel(IRef rf, Context cx) { return rf.Delete (cx); }
public void Visit(IRef r) { }
public static object refGet(IRef rf, Context cx) { return rf.Get (cx); }
/// Construct a multifunction. /// </summary> /// <param name="name">The name</param> /// <param name="dispatchFn">The dispatch function.</param> /// <param name="defaultDispatchVal">The default dispatch value.</param> /// <param name="hierarchy">The hierarchy for this multifunction</param> public MultiFn(string name, IFn dispatchFn, object defaultDispatchVal, IRef hierarchy) { _name = name; _dispatchFn = dispatchFn; _defaultDispatchVal = defaultDispatchVal; _methodTable = PersistentHashMap.EMPTY; _methodCache = MethodTable; _preferTable = PersistentHashMap.EMPTY; _hierarchy = hierarchy; _cachedHierarchy = null; _rw = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion); }
public static object refIncrDecr(IRef rf, Context cx, int incrDecrMask) { object value = rf.Get (cx); bool post = ((incrDecrMask & Node.POST_FLAG) != 0); double number; if (CliHelper.IsNumber (value)) { number = Convert.ToDouble (value); } else { number = ScriptConvert.ToNumber (value); if (post) { // convert result to number value = number; } } if ((incrDecrMask & Node.DECR_FLAG) == 0) { ++number; } else { --number; } rf.Set (cx, number); if (post) { return value; } else { return number; } }
public DirectStreamableObjectChannel(ServerConnector connector, IRef obj) { this.obj = obj; this.connector = connector; }
public void register(IRef aref) { aref.addWatch(parent.sully, parent.sully); }