/// <summary> /// Register an observable against a type within the event aggregator for the lifetime of this mono behaviour. /// /// Note: The stream errors will be ignored and complete will not pass through /// </summary> /// <typeparam name="TEvent">The type of event</typeparam> /// <param name="stream">The observable stream to register</param> /// <returns>A disposable to unregister the stream. This is called for you in OnDestroy.</returns> public IDisposable Register <TEvent>(IObservable <TEvent> stream) { var registration = PubSub.Register(stream); this.disposables.Add(registration); return(registration); }
/// <summary> /// Register an converter against an event type to operate as an additional event mapped from the source for the lifetime of this mono behaviour. /// </summary> /// <typeparam name="TEventIn">The source event type</typeparam> /// <typeparam name="TEventOut">The destination event type</typeparam> /// <param name="converter">The conversion function</param> /// <param name="predicate">The predicate to apply to the source before conversion</param> /// <returns>A disposable to unregister the conversion. This is called for you in OnDestroy.</returns> public IDisposable RegisterConversion <TEventIn, TEventOut>(Func <TEventIn, TEventOut> converter, Func <TEventIn, bool> predicate) { var registration = PubSub.Convert(converter, predicate); this.disposables.Add(registration); return(registration); }
// <summary> /// Subscribe to events of type TEvent (subclasses/implementors) from the event aggregator for the lifetime of this mono behaviour. /// /// Note: The stream will only ever fire onNext, errors and completes are supressed /// </summary> /// <param name="handler">A handler for when the events occur</param> /// <returns>A disposable to unsubscribe from the stream. This is called for you in OnDestroy.</returns> public IDisposable SubscribeToEventsOfType <TEvent>(Action <TEvent> handler) { return(this.Subscribe(PubSub.GetEventsOfType <TEvent>(), handler)); }
/// <summary> /// Subscribe to events of type TEvent (subclasses/implementors) from the event aggregator for the lifetime of this mono behaviour. /// /// Note: The stream will only ever fire onNext, errors and completes are supressed /// </summary> /// <param name="self">The PubSubMonoBehaviour</param> /// <param name="gameObject">A GameObject to filter the subscription with</param> /// <param name="handler">A handler for when the events occur</param> /// <returns>A disposable to unsubscribe from the stream. This is called for you in OnDestroy.</returns> public static IDisposable SubscribeToEventsOfType <TEvent>(this PubSubMonoBehaviour self, GameObject gameObject, Action <TEvent> handler) where TEvent : class, IGameObjectEvent { return(self.Subscribe(PubSub.GetEventsOfType <TEvent>().Where(e => e.GameObject == gameObject), handler)); }