private void SubscribeByInterfaceAndTopic <T>(IConsume <T> consumer, Func <T, bool> topic, Action <Exception> onError) { IDisposable subscription = GetSubscriptionSubject <T>(); IObservableWithOutcomes <T> subject = (IObservableWithOutcomes <T>)subscription; SubscribeWithInterface(consumer, subject, onError, topic); }
private void SubscribeByInterface <T>(IConsume <T> consumer, Action <Exception> onError) { var subscription = GetSubscriptionSubject <T>(); var subject = (IObservableWithOutcomes <T>)subscription; SubscribeWithInterface(consumer, subject, onError); }
public void SetupQueuedConsumer() { _delegatingConsumer = new DelegatingConsumer<TestMessages.TestMessage> ((msg) => { _received.Add(msg); }); _queuedConsumer = new QueuedConsumer<TestMessages.TestMessage> (_delegatingConsumer); }
public void UseItem(int selected) { if (activeFilter == Item.Categories.Misc || activeFilter == Item.Categories.Ammo) { GD.Print("Nothing to do with these."); return; } ItemData dat = itemData[selected]; Actor player = Session.session.player; int playerItemIndex = player.IndexOf(dat.type, dat.name); switch (activeFilter) { case Item.Categories.Weapons: player.EquipItem(playerItemIndex); break; case Item.Categories.Apparel: player.EquipItem(playerItemIndex); break; case Item.Categories.Aid: ItemData retrieved = player.RetrieveItem(playerItemIndex); IConsume consumable = Item.FromData(retrieved) as IConsume; if (consumable != null) { consumable.Consume(player); } break; } RefreshInventory(); RefreshStashItemInfo(); }
private IObservable <T> InitializeConsumer() { _cancel = new CancellationTokenSource(); _collection = new BlockingCollection <T>(); _undeliverableConsumer = new ActionConsumer <T>(@event => { }); return(_collection.AsConsumingObservable(_cancel.Token)); }
public void Subscribe <TMessage>(string topic, IConsume <TMessage> consumer) where TMessage : IMessage { subscriptions.AddOrUpdate(topic, key => new MultiPlexer(new NarrowingConsumer <TMessage>(consumer)), (key, multiPlexer) => { multiPlexer.Add(new NarrowingConsumer <TMessage>(consumer)); return(multiPlexer); }); }
public void OnBeforeConsume <TMessage, TConsumer>(IConsume <TMessage> consumer, TMessage message) where TMessage : class where TConsumer : IConsume <TMessage> { if (!CreateStateHandlerIfConsumerRequiresState <TConsumer, TMessage>()) { return; } handler.LoadState(consumer, message); }
public void RegisterHandler <T>(IConsume <T> handler) where T : class, Event { if (_registry.ContainsKey(typeof(T))) { _registry[typeof(T)] += e => handler.Consume(e as T); } else { _registry.Add(typeof(T), e => handler.Consume(e as T)); } }
public void OnBeforeConsume <TMessage, TConsumer>(IConsume <TMessage> consumer, TMessage message) where TMessage : class where TConsumer : IConsume <TMessage> { var requiresLocking = typeof(TConsumer).IsOfGenericType(typeof(IConsumeLocked <>)); if (!requiresLocking) { return; } _lock = locker.AcquireLock(GetCorrelationIdentifier <TMessage, TConsumer>(message)); }
public void Enter(PlayerMachine.Data playerControll) { result = null; data = playerControll; item = (IConsume)data.character.Equipment.ItemSlots.Items[data.slotIndex].item; data.cost = 1; data.lineRender[0].enabled = false; data.lineRender[1].enabled = false; var gui = Object.FindObjectOfType <GUIControll>(); gui.GUIEnabled.mission.Distance.SetActive(false); }
private void SubscribeWithInterface <T>(IConsume <T> consumer, IObservableWithOutcomes <T> observable, Action <Exception> onError, Func <T, bool> filter = null) { var subscriptionType = typeof(T); var unsubscription = _unsubscriptions.GetOrAdd(subscriptionType, t => new CancellationTokenSource()); if (filter != null) { observable.Subscribe(@event => { try { if (!filter(@event)) { observable.Outcomes.Add(new ObservableOutcome { Result = false }); } else { var result = Handle(consumer, @event); observable.Outcomes.Add(new ObservableOutcome { Result = result }); } } catch (Exception ex) { OnHandlerError(onError, ex, observable); } }, e => OnError(e, observable), () => OnCompleted(observable), unsubscription.Token); } else { observable.Subscribe(@event => { try { var result = Handle(consumer, @event); observable.Outcomes.Add(new ObservableOutcome { Result = result }); } catch (Exception ex) { OnHandlerError(onError, ex, observable); } }, e => OnError(e, observable), () => OnCompleted(observable), unsubscription.Token); } }
public void Consume <T>(string name, IConsume <T> consumer) where T : class { lock (this) { if (!consumers.Any(c => c.Consumer == consumer)) { consumers.Add(new ConsumerAndName { Name = name, Consumer = consumer }); } } }
public ActionConsumer(Action <T> @delegate, IConsume <T> forwardTo) { _delegate = async @event => { try { @delegate(@event); return(await forwardTo.HandleAsync(@event)); } catch (Exception) { return(false); } }; }
private BackgroundThreadProducer(BlockingCollection <T> source, bool @internal = true) { _buffer = source; _internal = @internal; MaxDegreeOfParallelism = 1; _uptime = new Stopwatch(); _cancel = new CancellationTokenSource(); _empty = new SemaphoreSlim(1); var devNull = new ActionConsumer <QueuedMessage <T> >(message => { }); _consumer = devNull; _backlogConsumer = devNull; _undeliverableConsumer = devNull; }
public BackgroundThreadProducer(BlockingCollection <T> source) { Buffer = source; MaxDegreeOfParallelism = 1; _uptime = new Stopwatch(); _cancel = new CancellationTokenSource(); _empty = new SemaphoreSlim(1); RetryPolicy = new RetryPolicy(); RateLimitPolicy = new RateLimitPolicy(); var devNull = new ActionConsumer <T>(@event => { }); _consumer = devNull; _backlogConsumer = devNull; _undeliverableConsumer = devNull; }
public IConsume(IConsume item) { RemoveAllState = item.RemoveAllState; AddState = item.AddState; RemoveState = item.RemoveState; AddTrait = item.AddTrait; RemoveTrait = item.RemoveTrait; Stats = item.Stats; Recover = item.Recover; Name = item.Name; Icon = item.Icon; Category = item.Category; Description = item.Description; Value = item.Value; Stack = item.Stack; }
private static bool Handle <T>(IConsume <T> consumer, T @event) { if (consumer is IConsumeScoped <T> before) { if (!before.Before()) { return(false); } } var result = consumer.HandleAsync(@event).ConfigureAwait(false).GetAwaiter().GetResult(); if (consumer is IConsumeScoped <T> after) { result = after.After(result); } return(result); }
public void ConsumeItem(IConsume item) { Stats.AddStats(item.Stats); Effects.RemoveAll(x => StaticValues.States.States[x.State].TypeState == item.RemoveAllState && item.RemoveAllState != TypeState.None); foreach (var state in item.AddState) { AddEffect(StaticValues.States.States[state]); } foreach (var state in item.RemoveState) { Effects.RemoveAll(x => x.State == state); } foreach (var trait in item.AddTrait) { AddTrait(trait); } foreach (var trait in item.RemoveTrait) { Traits.Remove(trait); } if (item.Recover.hp > 0) { currentStats.lifeStats.RecoverHP(item.Recover.hp); } if (item.Recover.mp > 0) { currentStats.lifeStats.RecoverMP(item.Recover.mp); } if (item.Recover.precent_hp > 0) { currentStats.lifeStats.RecoverHP_Precent(item.Recover.precent_hp); } if (item.Recover.precent_mp > 0) { currentStats.lifeStats.RecoverMP_Precent(item.Recover.precent_mp); } UpdateStats(); }
public void HarvestTarget(Transform target) { if (!isHarvesting) { isHarvesting = true; StartCoroutine(AttackCooldown()); IHaveMass _mass = target.GetComponent <IHaveMass>(); IHaveBiteSize _bite = GetComponent <IHaveBiteSize>(); if (_mass != null) { if (_bite != null) { if (_mass.Mass - _bite.BiteSize > 0) { _mass.Mass -= _bite.BiteSize; IConsume _consumeFood = GetComponent <IConsume>(); if (_consumeFood != null) { _consumeFood.IAddFood(_bite.BiteSize); } } else { IConsume _consumeFood = GetComponent <IConsume>(); if (_consumeFood != null) { _consumeFood.IAddFood(_mass.Mass); EvaluateSurroundings _surroundings = GetComponent <EvaluateSurroundings>(); if (_surroundings != null) { _surroundings.CheckDetectedCreature(target, false); } } _mass.Mass = 0; } } } } }
public ConsumeEnd(IMessage message, IConsume consumer, string queueName) { Message = message; Consumer = consumer; QueueName = queueName; }
public Channel(IConsume<Event> handler) { _handler = handler; }
public void Attach(IConsume <T> consumer) { _handler = consumer.HandleAsync; }
public Channel(IConsume <Event> handler) { _handler = handler; }
public void Attach(IConsume <T> consumer) { _producer.Attach(consumer); }
public void Add(IConsume <IMessage> consumer) { consumers.Enqueue(consumer); }
public void Subscribe <T>(IConsume <T> consumer, Func <T, bool> topic, Action <Exception> onError) { SubscribeByInterfaceAndTopic(consumer, topic, onError ?? NoopErrorHandler); }
public void Subscribe <T>(IConsume <T> consumer, Action <Exception> onError = null) { SubscribeByInterface(consumer, onError ?? NoopErrorHandler); }
private static bool Handle <T>(IConsume <T> consumer, T @event) { return(consumer.HandleAsync(@event).ConfigureAwait(false).GetAwaiter().GetResult()); }
public SimpleConsumerFactory(IConsume consume) { this.consume = consume; }
public void SetUp() { _output = new FakeOutput(); _consumer = new DeploymentProcessOutputConsumer(_output); }
public DetermineNextStateOfDeadCell(IConsume <CellLived> cellLivedChannel, IConsume <CellDied> cellDiedChannel) { _cellLivedChannel = cellLivedChannel; _cellDiedChannel = cellDiedChannel; }
public void Attach(IConsume <T> consumer) { _consumer = consumer; }
public virtual void Attach(IConsume <IEnumerable <ScheduledTask> > consumer) { Background.Attach(consumer); }
public virtual void Attach(IConsume <T> consumer) { Background.Attach(consumer); }
public CellStateAggregator(IConsume <OneGenerationOfCellStatesAggregated> channel) { _channel = channel; _count = 0; }