raix.reactive.subjects.ConnectableObservable

Public Methods

	Method		Defined By
		ConnectableObservable(source:IObservable, subject:ISubject = null)	ConnectableObservable
		aggregate(accumulator:Function, initialValue:Object = null, useInitialValue:Boolean = false):IObservable	AbsObservable
		all(predicate:Function):IObservable Determines if all values in the source sequence satisfy a condition	AbsObservable
		and(right:IObservable):Pattern Creates a pattern by combining the current source with right.	AbsObservable
		any(predicate:Function = null):IObservable Determines if the source sequence contains a value that satisfies a condition	AbsObservable
		asObservable():IObservable Hides the source sequence so it cannot be cast back to it’s concrete implementation	AbsObservable
		average(valueSelector:Function = null):IObservable Returns the average value of all the elements in the source sequence	AbsObservable
		bufferWithCount(count:uint, skip:uint = 0):IObservable Emits the values from a source sequence in groups of a specific size	AbsObservable
		bufferWithTime(timeMs:uint, timeShiftMs:uint = 0, scheduler:IScheduler = null):IObservable Emits the values from a source sequence in groups of a specific size	AbsObservable
		bufferWithTimeOrCount(timeMs:uint, count:uint, scheduler:IScheduler = null):IObservable Buffers values into an array, with one array for either a maximum period of time or a maximum number of values, whichever occurs first	AbsObservable
		cast(valueClass:Class):IObservable Forces values from a source sequence to be of a specific class	AbsObservable
		catchError(second:IObservable):IObservable Runs a specific sequence when an error occurs	AbsObservable
		catchErrorDefer(errorClass:Class, deferFunc:Function):IObservable Runs a specific sequence, determined at runtime, when an error occurs	AbsObservable
		chain(functions:Array):IObservable Chains together sequences, starting with the current sequence, using selector functions that return a sequence for values of the previous.	AbsObservable
		combineLatest(right:IObservable, selector:Function):IObservable Merges two sequences through a mapping function, using the latest value from either source	AbsObservable
		concat(source:IObservable):IObservable Concatonates multiple sequences by running each sequence as the previous one finishes	AbsObservable
		concatMany(selector:Function):IObservable Evaluates a new sequence for each value using a selector function and waits for the returned sequence to complete before resolving the next sequence	AbsObservable
		connect():ICancelable Makes this observable 'hot', so that values will be emitted whether there is a subscriber connected or not.	ConnectableObservable
		contains(value:Object, comparer:Function = null):IObservable Determines if the source sequence contains a specific value	AbsObservable
		count():IObservable Returns the number of elements in the source sequence	AbsObservable
		delay(delayMs:uint, scheduler:IScheduler = null):IObservable Delays all values in a sequences by a specified time	AbsObservable
		delayUntil(dt:Date, scheduler:IScheduler = null):IObservable	AbsObservable
		dematerialize():IObservable Converts materialized values back into messages	AbsObservable
		distinctUntilChanged(comparer:Function = null):IObservable Filters out consecutive duplicates from a source sequence	AbsObservable
		expand(selector:Function):IObservable Recursively expands the values in the sequence using a selector function	AbsObservable
		filter(predicate:Function):IObservable Filters out values from a source sequence	AbsObservable
		finallyAction(action:Function):IObservable Executes a function when the sequence completes, errors or is unsubscribed from	AbsObservable
		first():IObservable Emits the first value in the sequence, or an error if the sequence completes with no values	AbsObservable
		firstOrDefault():IObservable Emits the first value in the sequence, or a default value if the sequence completes with no values	AbsObservable
		forkJoin(right:IObservable, selector:Function):IObservable Combines the current sequence with another, emitting the last values of both after both have completed	AbsObservable
		groupBy(keySelector:Function, elementSelector:Function = null, keyComparer:Function = null):IObservable Groups values by a key	AbsObservable
		groupByUntil(keySelector:Function, durationSelector:Function, elementSelector:Function = null, keyComparer:Function = null):IObservable Groups values by a key and also provides a lifetime for a grouping	AbsObservable
		groupJoin(right:IObservable, leftWindowSelector:Function, rightWindowSelector:Function, joinSelector:Function):IObservable Combines values from two streams based on the "lifetime" of each value, represented by an IObservable selected for each value.	AbsObservable
		ignoreValues():IObservable Excludes values (calls to IObserver.onNext), emitting only onCompleted and onError	AbsObservable
		join(right:IObservable, leftWindowSelector:Function, rightWindowSelector:Function, joinSelector:Function):IObservable Combines values from two streams based on the "lifetime" of each value, represented by an IObservable selected for each value.	AbsObservable
		last():IObservable Emits the last value in the sequence, or an error if the sequence completes with no values	AbsObservable
		lastOrDefault():IObservable Emits the last value in the sequence, or the default value if the sequence completes with no values	AbsObservable
		let(func:Function):IObservable Pipes a composed sequence to be mapped through a function so it can be used multiple times	AbsObservable
		log(message:String):IObservable	AbsObservable
		map(selector:Function):IObservable Maps the values from a source sequence through a function to change their value	AbsObservable
		mapMany(selector:Function):IObservable Starts a new sequence, returned by selector, for every value in the source sequence and merges their values	AbsObservable
		materialize():IObservable Converts all messages (next, complete, error) into values	AbsObservable
		merge(source:IObservable):IObservable Emits the values from multiple sources in the order that they arrive	AbsObservable
		mergeMany(selector:Function, concurrent:int = 0):IObservable Evaluates a new sequence for each value using a selector function and merges the results of the sequence returned by the returned sequence, optionally constraining the number of concurrent sequencing.	AbsObservable
		multicast(subject:ISubject):IConnectableObservable Creates a connectable sequence that can be shared by multiple observers, using a specific subject implementation.	AbsObservable
		multicastDefer(subjectSelector:Function, selector:Function):IObservable Creates a connectable sequence that can be shared by multiple observers, using a specific subject implementation (determined at subscribe-time.	AbsObservable
		multiWindow(windowOpenings:IObservable, windowClosingSelector:Function):IObservable Emits values into child "window" observable sequences, which are opened and closed by the caller.	AbsObservable
		observeOn(scheduler:IScheduler):IObservable Defers messages to subscribers through a scheduler	AbsObservable
		ofClass(valueClass:Class):IObservable Filters out values from a source sequence that are not of a specific type	AbsObservable
		onErrorResumeNext(second:IObservable, scheduler:IScheduler = null):IObservable Subscribes down a list of sequence as each one errors or complete	AbsObservable
		peek(nextAction:Function, completeAction:Function = null, errorAction:Function = null):IObservable Allows custom code to be run when messages arrive without affecting the observer	AbsObservable
		peekWith(observer:IObserver):IObservable Allows custom code to be run when messages arrive without affecting the observer	AbsObservable
		prune(scheduler:IScheduler = null):IConnectableObservable Creates a shared sequence that emits the last value of the source sequence	AbsObservable
		pruneDefer(selector:Function, scheduler:IScheduler = null):IObservable Creates a shared sequence that emits the last value of the source sequence, the shared sequence will be passed to the selector function when the sequence is subscribed to.	AbsObservable
		publish():IConnectableObservable Creates a connectable sequence that can be shared by multiple observers	AbsObservable
		publishDefer(selector:Function):IObservable Creates a shared sequence that can be used by multiple subscribers, the shared sequence will be passed to the selector function when the sequence is subscribed to.	AbsObservable
		reduce(accumulator:Function, initialValue:Object = null, useInitialValue:Boolean = false):IObservable Runs calculation functions over every value in the source sequence and emits the final result	AbsObservable
		refCount():IObservable Makes this observable 'hot' when an observer subscribes, and will cancel the source subscription when the last observer unsubscribes	ConnectableObservable
		removeTimeInterval():IObservable Removes time interval information added with timeInterval	AbsObservable
		removeTimestamp():IObservable Removes timestamp information added with timestamp	AbsObservable
		repeat(repeatCount:uint = 0):IObservable Repeats the source sequence a specific number of times	AbsObservable
		replay(bufferSize:uint = 0, windowMs:uint = 0, scheduler:IScheduler = null):IConnectableObservable Records the output of the source sequence and replays it to future subscribers	AbsObservable
		replayDefer(selector:Function, bufferSize:uint = 0, windowMs:uint = 0, scheduler:IScheduler = null):IObservable Creates a shared sequence that replays values to future subscrubers, the shared sequence will be passed to the selector function when the sequence is subscribed to	AbsObservable
		retry(retryCount:uint = 0):IObservable Repeats the source sequence when an error occurs	AbsObservable
		sample(intervalMs:uint, scheduler:IScheduler = null):IObservable Emits the latest value on a time interval from a source sequence	AbsObservable
		scan(accumulator:Function, initialValue:Object = null, useInitialValue:Boolean = false):IObservable Runs calculation functions over every value in the source sequence and emits the value as it is calculated	AbsObservable
		select(selector:Function):IObservable Deprecated: Please Use map	AbsObservable
		selectMany(selector:Function):IObservable Deprecated: Please Use mapMany Starts a new sequence, returned by selector, for every value in the source sequence and merges their values	AbsObservable
		sequenceEqual(other:IObservable, valueComparer:Function = null):IObservable Determines whether two observable sequences are equal	AbsObservable
		single():IObservable Emits the only item from a source sequence, or an error if any other number of values are emitted.	AbsObservable
		singleOrDefault():IObservable Emits the only item from a source sequence, the default value if no values are emitted, or an error if more than one value is emitted.	AbsObservable
		skip(count:uint):IObservable Ignores a set number of values from the start of the source sequence	AbsObservable
		skipLast(count:uint):IObservable Ignores a set number of values from the end of the source sequence	AbsObservable
		skipUntil(other:IObservable):IObservable Ignores values from a source sequence until a value is received from a specified sequence	AbsObservable
		skipWhile(predicate:Function):IObservable Ignores values from a source sequence until a condition is no longer met	AbsObservable
		startWith(value:*):IObservable Emits the specified values at the start of a sequence	AbsObservable
		subscribe(onNext:Function, onComplete:Function = null, onError:Function = null):ICancelable Subscribes to this observable using the supplied functions	AbsObservable
		subscribeOn(scheduler:IScheduler):IObservable Defers subscriptions to the source through a scheduler	AbsObservable
		subscribeWith(observer:IObserver):ICancelable [override] Subscribes to this observable using the supplied observer	ConnectableObservable
		sum():IObservable Returns the summed value of all the elements in the source sequence	AbsObservable
		switchMany(selector:Function):IObservable Like selectMany, starts a new sequence for every value in the source sequence but cancels the previous sequence each time.	AbsObservable
		take(count:uint):IObservable Takes only the first set number of values from a source sequenc	AbsObservable
		takeLast(count:uint):IObservable Takes only the last set number of values from a source sequence	AbsObservable
		takeUntil(other:IObservable):IObservable Takes values from a source sequence until a value is received from a specified sequence	AbsObservable
		takeWhile(predicate:Function):IObservable Takes values from a source sequence until a condition is no longer met	AbsObservable
		then(thenFunction:Function):Plan Creates a Plan from this sequence, by supplying a valueClass and a mappingFunction for the values from each sequence in this Pattern	AbsObservable
		throttle(dueTimeMs:uint, scheduler:IScheduler = null):IObservable Limits how often values from a source sequence will be accepted from a source	AbsObservable
		timeInterval(scheduler:IScheduler = null):IObservable Includes, with every value emitted, the amount of time passed since the previous value	AbsObservable
		timeout(timeoutMs:uint, other:IObservable = null, scheduler:IScheduler = null):IObservable Raises an error (or subscribes a specified sequence) after a certain period of inactivity	AbsObservable
		timestamp(scheduler:IScheduler = null):IObservable Includes, with every value emitted, the timestamp of when the value was emitted from the source	AbsObservable
		toArray():IObservable Delivers all the results as a single array when the source completes	AbsObservable
		window(windowClosingSelector:Function):IObservable Splits values into child-observable windows which are closed by the caller	AbsObservable
		windowWithCount(count:uint, skip:uint = 0):IObservable Emits the values from a source sequence in groups of a specific size	AbsObservable
		windowWithTime(timeMs:uint, timeShiftMs:uint = 0, scheduler:IScheduler = null):IObservable Emits the values from a source sequence in groups of a specific size	AbsObservable
		windowWithTimeOrCount(timeMs:uint, count:uint, scheduler:IScheduler = null):IObservable Emits IObservable sequences containing values received in sized batches or within a timespan, whichever occurs first	AbsObservable
		zip(rightSource:IObservable, selector:Function):IObservable Merges two sequences through a mapping function while only ever using each value once	AbsObservable

Constructor Detail

ConnectableObservable

()

Constructor

public function ConnectableObservable(source:IObservable, subject:ISubject = null)

Parameters

	`source:IObservable`

	`subject:ISubject` (default = `null`)

Method Detail

connect

()

method

public function connect():ICancelable

Makes this observable 'hot', so that values will be emitted whether there is a subscriber connected or not.

Returns

ICancelable

refCount

()

method

public function refCount():IObservable

Makes this observable 'hot' when an observer subscribes, and will cancel the source subscription when the last observer unsubscribes

Returns

IObservable

subscribeWith

()

method

override public function subscribeWith(observer:IObserver):ICancelable

Subscribes to this observable using the supplied observer

Parameters

observer:IObserver

Returns

ICancelable — An instance of ICancelable that can be used to unsubscribe at anytime by calling cancel()

Fri May 20 2011, 04:58 PM +01:00

Package	raix.reactive.subjects
Class	public class ConnectableObservable
Inheritance	ConnectableObservable AbsObservable Object
Implements	IConnectableObservable

raix v0.9	All Packages \| All Classes \| Index \| Frames No Frames
ConnectableObservable	Methods