public void Waiting(IActiveState state) { if (ShouldNotifyDistributor()) { bus.Send(new WorkerThreadAvailableCommand { Identifier = identifier, InboxWorkQueueUri = bus.Configuration.Inbox.WorkQueue.Uri.ToString(), DateSent = DateTime.Now }, bus.Configuration.Worker.DistributorControlInboxWorkQueue); if (log.IsVerboseEnabled) { log.Verbose(string.Format(ESBResources.DebugWorkerAvailable, identifier, bus.Configuration.Inbox.WorkQueue.Uri, bus.Configuration.Worker.DistributorControlInboxWorkQueue.Uri)); } nextNotificationDate = DateTime.Now.AddSeconds(bus.Configuration.Worker.ThreadAvailableNotificationIntervalSeconds); } threadActivity.Waiting(state); }
public virtual void Execute(IActiveState state) { var messagePipeline = bus.Configuration.PipelineFactory.GetPipeline <TMessagePipeline>(bus); try { messagePipeline.State.Replace(StateKeys.Working, false); messagePipeline.State.Replace(StateKeys.ActiveState, state); messagePipeline.Execute(); if (messagePipeline.State.Get <bool>(StateKeys.Working)) { bus.Events.OnThreadWorking(this, new ThreadStateEventArgs(typeof(TMessagePipeline))); threadActivity.Working(); } else { bus.Events.OnThreadWaiting(this, new ThreadStateEventArgs(typeof(TMessagePipeline))); threadActivity.Waiting(state); } } finally { bus.Configuration.PipelineFactory.ReleasePipeline(messagePipeline); } }
protected virtual void Awake() { _identifier = UniqueIdentifier.Generate(); ActiveState = _activeState as IActiveState; InteractableFilters = _interactableFilters.ConvertAll(mono => mono as IMonoBehaviourFilter); }
public BaseMenu(SpriteBatch spriteBatch, IActiveState parent, string defaultFont, Size screenSize, Vector2 choiceOffset) { SpriteBatch = spriteBatch; Parentmenu = parent; SelectedChoiceFont = DefaultFont = Common.str2Font(defaultFont); TextureDrawRect = new Rectangle(0, 0, screenSize.Width, screenSize.Height); ChoiceOffset = choiceOffset; }
public void Start() { if (ActiveState == null) { ActiveState = _activeState as IActiveState; } Assert.IsNotNull(ActiveState); }
protected virtual void Awake() { ActiveState = _activeState as IActiveState; Assert.IsNotNull(ActiveState); Assert.IsNotNull(_target); _material = _target.material; SetMaterialColor(_lastActiveValue ? _activeColor : _normalColor); }
protected ResultState(IState parentState, IResultBuilder <T> resultBuilder, IActiveState activeState, Creator <IResultAttributeBuilder> createAttributeBuilder, Creator <IAttributeState, IState, IResultAttributeBuilder> createAttributeState) { _parentState = parentState; _resultBuilder = resultBuilder; _activeState = activeState; _createAttributeBuilder = createAttributeBuilder; _createAttributeState = createAttributeState; Valid = true; }
private void ExecuteActions(IActiveState <TExec> state) { while (HasActions) { if (state.HasOutcome && state.HasFailed) { state.ExecuteFailureAction(); return; } else if (state.HasException) { state.HandleException(); return; } if (!actions.TryDequeue(out var action)) { continue; } state.BackUp(action); if (action.hasDefaultValue && state.OutcomeMustDefault) { state.Outcome(action.defaultValue); } else { try { if (action.IsConsumer) { action.AsConsumer().Invoke(state.Outcome <TExec>()); } else if (action.IsFunction) { if (action.HasNestedCompletes) { ((ICompletes <TExec>)action.AsFunction().Invoke(state.Outcome <TExec>())) .AndThenConsume(value => action.NestedCompletes.With(value)); } else { state.Outcome(action.AsFunction().Invoke(state.Outcome <TExec>())); } } } catch (Exception ex) { state.HandleException(ex); break; } } } }
public HandlerContext(IServiceBus bus, TransportMessage transportMessage, T message, IActiveState activeState) { Guard.AgainstNull(bus, "bus"); Guard.AgainstNull(transportMessage, "transportMessage"); Guard.AgainstNull(message, "message"); Guard.AgainstNull(activeState, "activeState"); Bus = bus; TransportMessage = transportMessage; Message = message; ActiveState = activeState; }
public CreditsMenu(IActiveState parent, IEngine engine, string background, string creditFont, string creditTitleFont) { Parent = parent; Engine = engine; Font = Common.str2Font(creditFont); FontTitle = Common.str2Font(creditTitleFont); if (background != null) { BGTexture = Common.str2Tex(background); } }
public CreditsMenu2(IActiveState parent, SpriteBatch spriteBatch, Rectangle screenArea, string background, string creditFont, string creditTitleFont) { Parent = parent; Font = Common.str2Font(creditFont); FontTitle = Common.str2Font(creditTitleFont); ScreenArea = screenArea; SpriteBatch = spriteBatch; if (background != null) { BGTexture = Common.str2Tex(background); } }
internal void Execute(IActiveState <TExec> state) { while (true) { if (accessible.CompareAndSet(false, true)) { readyToExecute.Set(true); ExecuteActions(state); accessible.Set(false); break; } } }
protected internal BasicCompletes(IActiveState <T> state, T outcome, bool succeeded) { this.state = state; if (succeeded) { this.state.CompletedWith(outcome); } else { this.state.FailedValue(Optional.Of(outcome)); this.state.Failed(); } }
public ReaderState(IActiveState activeState, IResultNodeCallback resultNodeCallback, IResultNode rootResultNode, IResultMetadata resultMetadata, IScanContext scanContext, Creator <IResultNodeBuilder> createResultNodeBuilder, Creator <IResultNodeState, IState, IResultNodeBuilder> createResultNodeReaderState) { _activeState = activeState; _resultNodeCallback = resultNodeCallback; _rootResultNode = rootResultNode; _resultMetadata = resultMetadata; _scanContext = scanContext; _createResultNodeBuilder = createResultNodeBuilder; _createResultNodeReaderState = createResultNodeReaderState; _scanContext.Results = rootResultNode; Valid = true; _activeState.ChangeState(this); }
public virtual void Execute(IActiveState state) { var availableWorker = _bus.Configuration.WorkerAvailabilityManager.GetAvailableWorker(); if (_bus.Configuration.Inbox.Distribute && availableWorker == null) { _threadActivity.Waiting(state); return; } var messagePipeline = availableWorker == null ? _bus.Configuration.PipelineFactory.GetPipeline<InboxMessagePipeline>(_bus) : _bus.Configuration.PipelineFactory.GetPipeline<DistributorPipeline>(_bus); try { messagePipeline.State.SetAvailableWorker(availableWorker); messagePipeline.State.ResetWorking(); messagePipeline.State.SetActiveState(state); if (!state.Active) { return; } messagePipeline.Execute(); if (messagePipeline.State.Get<bool>(StateKeys.Working)) { _bus.Events.OnThreadWorking(this, new ThreadStateEventArgs(typeof(InboxMessagePipeline))); _threadActivity.Working(); } else { _bus.Events.OnThreadWaiting(this, new ThreadStateEventArgs(typeof(InboxMessagePipeline))); _threadActivity.Waiting(state); } } finally { _bus.Configuration.PipelineFactory.ReleasePipeline(messagePipeline); } }
public void Execute(IActiveState state) { if (!ShouldProcessDeferred()) { ThreadSleep.While(1000, state); return; } lock (_messageDeferredLock) { _messageDeferred = false; } var pipeline = (DeferredMessagePipeline)_bus.Configuration.PipelineFactory.GetPipeline<DeferredMessagePipeline>(_bus); pipeline.State.SetCheckpointMessageId(_checkpointMessageId); pipeline.State.SetNextDeferredProcessDate(_nextDeferredProcessDate); pipeline.State.SetDeferredMessageReturned(false); pipeline.Execute(); var nextDeferredProcessDate = pipeline.State.Get<DateTime>(StateKeys.NextDeferredProcessDate); if (_messageDeferred) { if (nextDeferredProcessDate < _nextDeferredProcessDate) { _nextDeferredProcessDate = nextDeferredProcessDate; } } else { _nextDeferredProcessDate = nextDeferredProcessDate; } if (_checkpointMessageId != pipeline.State.Get<Guid>(StateKeys.CheckpointMessageId)) { _checkpointMessageId = pipeline.State.Get<Guid>(StateKeys.CheckpointMessageId); return; } _checkpointMessageId = Guid.Empty; }
public Credits(IActiveState parent) { Parent = parent; Font = Common.str2Font("Credit"); FontTitle = Common.str2Font("CreditTitle"); AllCredits.Add(new Credit(true, "Invaders XNA")); AllCredits.Add(new Credit(true, "Created on August 11th 2011 (single sit-through)")); AllCredits.Add(new Credit(true, "")); AllCredits.Add(new Credit(true, "")); AllCredits.Add(new Credit(true, "Programming & Design")); AllCredits.Add(new Credit(false, "[email protected]*l*o v@o@n R@nz0vv")); AllCredits.Add(new Credit(true, "")); AllCredits.Add(new Credit(true, "Audio")); AllCredits.Add(new Credit(false, "sandyrb (www.freesoundproject.org) - Impact sound.")); AllCredits.Add(new Credit(false, "grunz (www.freesound.org) - level up sound")); AllCredits.Add(new Credit(true, "")); AllCredits.Add(new Credit(true, "Graphics")); AllCredits.Add(new Credit(false, "ac3raven (www.opengameart.org) - Space Backgrounds")); AllCredits.Add(new Credit(false, "Lamoot (www.opengameart.org) - Player sprite")); AllCredits.Add(new Credit(false, "CruzR (www.opengameart.org) - Laser sprites")); AllCredits.Add(new Credit(false, "[email protected]*l*o v@o@n R@nz0vv - Blocks")); AllCredits.Add(new Credit(true, "")); AllCredits.Add(new Credit(true, "Special Thanks & Tools")); AllCredits.Add(new Credit(false, "The Gimp")); int y = Engine.Instance.Height; foreach (Credit credit in AllCredits) { SpriteFont measureFont; if (credit.IsTitle) { measureFont = FontTitle; } else { measureFont = Font; } credit.Location = Common.CenterStringX(measureFont, credit.Person, Engine.Instance.Width, y); y += (int)measureFont.MeasureString(Common.MeasureString).Y; } }
public virtual void Execute(IActiveState state) { var availableWorker = bus.Configuration.WorkerAvailabilityManager.GetAvailableWorker(); if (bus.Configuration.Inbox.Distribute && availableWorker == null) { threadActivity.Waiting(state); return; } var messagePipeline = availableWorker == null ? bus.Configuration.PipelineFactory.GetPipeline <InboxMessagePipeline>(bus) : bus.Configuration.PipelineFactory.GetPipeline <DistributorPipeline>(bus); try { messagePipeline.State.Replace(StateKeys.AvailableWorker, availableWorker); messagePipeline.State.Replace(StateKeys.Working, false); messagePipeline.State.Replace(StateKeys.ActiveState, state); messagePipeline.Execute(); if (messagePipeline.State.Get <bool>(StateKeys.Working)) { bus.Events.OnThreadWorking(this, new ThreadStateEventArgs(typeof(InboxMessagePipeline))); threadActivity.Working(); } else { bus.Events.OnThreadWaiting(this, new ThreadStateEventArgs(typeof(InboxMessagePipeline))); threadActivity.Waiting(state); } } finally { bus.Configuration.PipelineFactory.ReleasePipeline(messagePipeline); } }
public void InjectActiveState(IActiveState activeState) { _activeState = activeState as MonoBehaviour; ActiveState = activeState; }
public void RegisterWithExecution(Action <TBActSt> action, TimeSpan timeout, IActiveState <TBActSt> state) => executables.RegisterWithExecution(action, timeout, state);
protected internal BasicCompletes(IActiveState <T> state, T outcome) { this.state = state; this.state.Outcome(outcome); }
void IProcessor.Execute(IActiveState state) { Execute(state); }
public void InjectAllActiveStateUnityEventWrapper(IActiveState activeState) { InjectActiveState(activeState); }
internal void RegisterWithExecution(Action <TExec> action, TimeSpan timeout, IActiveState <TExec> state) { while (true) { if (accessible.CompareAndSet(false, true)) { actions.Enqueue(action); if (IsReadyToExecute) { ExecuteActions(state); } else { state.StartTimer(timeout); } accessible.Set(false); break; } } }
public void InjectAllActiveStateSelector(IActiveState activeState) { InjectActiveState(activeState); }
protected internal BasicCompletes(IActiveState <T> state) { this.state = state; }
public static void SetActiveState(this State<ObservablePipeline> state, IActiveState activeState) { state.Add(StateKeys.ActiveState, activeState); }
public BaseMenuBarred(IEngine engine, IActiveState parent) { IEngine = engine; Parentmenu = parent; }
public ActiveTimeRangeObserver(IActiveState state) { Guard.AgainstNull(state, "state"); this.state = state; }
protected virtual void Awake() { ActiveState = _activeState as IActiveState; }
public void InjectAllActiveStateTracker(IActiveState activeState) { InjectActiveState(activeState); }
public ResultNodeState(IState parentState, IResultNodeBuilder resultNodeBuilder, IActiveState activeState, Creator <IResultAttributeBuilder> createAttributeBuilder, Creator <IAttributeState, IState, IResultAttributeBuilder> createAttributeState) : base(parentState, resultNodeBuilder, activeState, createAttributeBuilder, createAttributeState) { }
public AttributeState(IState parentState, IResultAttributeBuilder attributeBuilder, IActiveState activeState, Creator <IResultAttributeBuilder> createAttributeBuilder, Creator <IAttributeState, IState, IResultAttributeBuilder> createChildAttributeState) : base(parentState, attributeBuilder, activeState, createAttributeBuilder, createChildAttributeState) { _attributeBuilder = attributeBuilder; }