single.ts
2.95 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import { Observable } from '../Observable';
import { Operator } from '../Operator';
import { Subscriber } from '../Subscriber';
import { Observer } from '../Observer';
import { EmptyError } from '../util/EmptyError';
import { TeardownLogic } from '../Subscription';
/**
* Returns an Observable that emits the single item emitted by the source Observable that matches a specified
* predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no
* such items, notify of an IllegalArgumentException or NoSuchElementException respectively.
*
* <img src="./img/single.png" width="100%">
*
* @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
* callback if the Observable completes before any `next` notification was sent.
* @param {Function} a predicate function to evaluate items emitted by the source Observable.
* @return {Observable<T>} an Observable that emits the single item emitted by the source Observable that matches
* the predicate.
.
* @method single
* @owner Observable
*/
export function single<T>(this: Observable<T>, predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<T> {
return this.lift(new SingleOperator(predicate, this));
}
class SingleOperator<T> implements Operator<T, T> {
constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
private source?: Observable<T>) {
}
call(subscriber: Subscriber<T>, source: any): TeardownLogic {
return source.subscribe(new SingleSubscriber(subscriber, this.predicate, this.source));
}
}
/**
* We need this JSDoc comment for affecting ESDoc.
* @ignore
* @extends {Ignored}
*/
class SingleSubscriber<T> extends Subscriber<T> {
private seenValue: boolean = false;
private singleValue: T;
private index: number = 0;
constructor(destination: Observer<T>,
private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
private source?: Observable<T>) {
super(destination);
}
private applySingleValue(value: T): void {
if (this.seenValue) {
this.destination.error('Sequence contains more than one element');
} else {
this.seenValue = true;
this.singleValue = value;
}
}
protected _next(value: T): void {
const predicate = this.predicate;
this.index++;
if (predicate) {
this.tryNext(value);
} else {
this.applySingleValue(value);
}
}
private tryNext(value: T): void {
try {
const result = this.predicate(value, this.index, this.source);
if (result) {
this.applySingleValue(value);
}
} catch (err) {
this.destination.error(err);
}
}
protected _complete(): void {
const destination = this.destination;
if (this.index > 0) {
destination.next(this.seenValue ? this.singleValue : undefined);
destination.complete();
} else {
destination.error(new EmptyError);
}
}
}