Skip to content

Commit 79f8e6d

Browse files
akarnokdakarnokd
authored
3.x: Fix diamonds, spelling, unnecessary code (#6804)
1 parent e6eb21b commit 79f8e6d

467 files changed

Lines changed: 1513 additions & 1600 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎docs/Backpressure.md‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -34,25 +34,25 @@ The following diagrams show how you could use each of these operators on the bur
3434
The `sample` operator periodically "dips" into the sequence and emits only the most recently emitted item during each dip:
3535

3636
<img src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/bp.sample.png" width="640" height="260" />​
37-
````groovy
37+
```java
3838
Observable<Integer> burstySampled = bursty.sample(500, TimeUnit.MILLISECONDS);
39-
````
39+
```
4040

4141
### throttleFirst
4242
The `throttleFirst` operator is similar, but emits not the most recently emitted item, but the first item that was emitted after the previous "dip":
4343

4444
<img src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/bp.throttleFirst.png" width="640" height="260" />​
45-
````groovy
45+
```java
4646
Observable<Integer> burstyThrottled = bursty.throttleFirst(500, TimeUnit.MILLISECONDS);
47-
````
47+
```
4848

4949
### debounce (or throttleWithTimeout)
5050
The `debounce` operator emits only those items from the source Observable that are not followed by another item within a specified duration:
5151

5252
<img src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/bp.debounce.png" width="640" height="240" />​
53-
````groovy
53+
```java
5454
Observable<Integer> burstyDebounced = bursty.debounce(10, TimeUnit.MILLISECONDS);
55-
````
55+
```
5656

5757
## Buffers and windows
5858

@@ -65,14 +65,14 @@ The following diagrams show how you could use each of these operators on the bur
6565
You could, for example, close and emit a buffer of items from the bursty Observable periodically, at a regular interval of time:
6666

6767
<img src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/bp.buffer2.png" width="640" height="270" />​
68-
````groovy
68+
```java
6969
Observable<List<Integer>> burstyBuffered = bursty.buffer(500, TimeUnit.MILLISECONDS);
70-
````
70+
```
7171

7272
Or you could get fancy, and collect items in buffers during the bursty periods and emit them at the end of each burst, by using the `debounce` operator to emit a buffer closing indicator to the `buffer` operator:
7373

7474
<img src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/bp.buffer1.png" width="640" height="500" />​
75-
````groovy
75+
```java
7676
// we have to multicast the original bursty Observable so we can use it
7777
// both as our source and as the source for our buffer closing selector:
7878
Observable<Integer> burstyMulticast = bursty.publish().refCount();
@@ -87,16 +87,16 @@ Observable<List<Integer>> burstyBuffered = burstyMulticast.buffer(burstyDebounce
8787
`window` is similar to `buffer`. One variant of `window` allows you to periodically emit Observable windows of items at a regular interval of time:
8888

8989
<img src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/bp.window1.png" width="640" height="325" />​
90-
````groovy
90+
```java
9191
Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);
9292
````
9393

9494
You could also choose to emit a new window each time you have collected a particular number of items from the source Observable:
9595

9696
<img src="https://github.com/ReactiveX/RxJava/wiki/images/rx-operators/bp.window2.png" width="640" height="325" />​
97-
````groovy
97+
```java
9898
Observable<Observable<Integer>> burstyWindowed = bursty.window(5);
99-
````
99+
```
100100

101101
# Callstack blocking as a flow-control alternative to backpressure
102102

@@ -110,8 +110,8 @@ When you subscribe to an `Observable` with a `Subscriber`, you can request react
110110

111111
Then, after handling this item (or these items) in `onNext()`, you can call `request()` again to instruct the `Observable` to emit another item (or items). Here is an example of a `Subscriber` that requests one item at a time from `someObservable`:
112112

113-
````java
114-
someObservable.subscribe(new Subscriber<t>() {
113+
```java
114+
someObservable.subscribe(new Subscriber<T>() {
115115
@Override
116116
public void onStart() {
117117
request(1);
@@ -134,7 +134,7 @@ someObservable.subscribe(new Subscriber<t>() {
134134
request(1);
135135
}
136136
});
137-
````
137+
```
138138

139139
You can pass a magic number to `request`, `request(Long.MAX_VALUE)`, to disable reactive pull backpressure and to ask the Observable to emit items at its own pace. `request(0)` is a legal call, but has no effect. Passing values less than zero to `request` will cause an exception to be thrown.
140140

‎docs/Combining-Observables.md‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,13 @@ This section explains operators you can use to combine multiple Observables.
22

33
# Outline
44

5-
- [`combineLatest`](#combineLatest)
5+
- [`combineLatest`](#combinelatest)
66
- [`join` and `groupJoin`](#joins)
77
- [`merge`](#merge)
8-
- [`mergeDelayError`](#mergeDelayError)
8+
- [`mergeDelayError`](#mergedelayerror)
99
- [`rxjava-joins`](#rxjava-joins)
10-
- [`startWith`](#startWith)
11-
- [`switchOnNext`](#switchOnNext)
10+
- [`startWith`](#startwith)
11+
- [`switchOnNext`](#switchonnext)
1212
- [`zip`](#zip)
1313

1414
## startWith

‎docs/How-To-Use-RxJava.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -96,9 +96,9 @@ You use the Observable [`just( )`](http://reactivex.io/documentation/operators
9696
Observable<String> o = Observable.from("a", "b", "c");
9797
9898
def list = [5, 6, 7, 8]
99-
Observable<Integer> o = Observable.from(list);
99+
Observable<Integer> o2 = Observable.from(list);
100100
101-
Observable<String> o = Observable.just("one object");
101+
Observable<String> o3 = Observable.just("one object");
102102
```
103103

104104
These converted Observables will synchronously invoke the [`onNext( )`](Observable#onnext-oncompleted-and-onerror) method of any subscriber that subscribes to them, for each item to be emitted by the Observable, and will then invoke the subscriber’s [`onCompleted( )`](Observable#onnext-oncompleted-and-onerror) method.

‎docs/Writing-operators-for-2.0.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
##### Table of contents
22

33
- [Introduction](#introduction)
4-
- [Warning on internal components](warning-on-internal-components)
4+
- [Warning on internal components](#warning-on-internal-components)
55
- [Atomics, serialization, deferred actions](#atomics-serialization-deferred-actions)
66
- [Field updaters and Android](#field-updaters-and-android)
77
- [Request accounting](#request-accounting)

‎src/jmh/java/io/reactivex/rxjava3/core/BinaryFlatMapPerf.java‎

Lines changed: 12 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -86,48 +86,42 @@ public void setup() {
8686

8787
singleFlatMapPublisher = Single.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
8888
@Override
89-
public Publisher<? extends Integer> apply(Integer v)
90-
throws Exception {
89+
public Publisher<? extends Integer> apply(Integer v) {
9190
return arrayFlowable;
9291
}
9392
});
9493

9594
singleFlatMapHidePublisher = Single.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
9695
@Override
97-
public Publisher<? extends Integer> apply(Integer v)
98-
throws Exception {
96+
public Publisher<? extends Integer> apply(Integer v) {
9997
return arrayFlowableHide;
10098
}
10199
});
102100

103101
singleFlattenAsPublisher = Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<? extends Integer>>() {
104102
@Override
105-
public Iterable<? extends Integer> apply(Integer v)
106-
throws Exception {
103+
public Iterable<? extends Integer> apply(Integer v) {
107104
return list;
108105
}
109106
});
110107

111108
maybeFlatMapPublisher = Maybe.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
112109
@Override
113-
public Publisher<? extends Integer> apply(Integer v)
114-
throws Exception {
110+
public Publisher<? extends Integer> apply(Integer v) {
115111
return arrayFlowable;
116112
}
117113
});
118114

119115
maybeFlatMapHidePublisher = Maybe.just(1).flatMapPublisher(new Function<Integer, Publisher<? extends Integer>>() {
120116
@Override
121-
public Publisher<? extends Integer> apply(Integer v)
122-
throws Exception {
117+
public Publisher<? extends Integer> apply(Integer v) {
123118
return arrayFlowableHide;
124119
}
125120
});
126121

127122
maybeFlattenAsPublisher = Maybe.just(1).flattenAsFlowable(new Function<Integer, Iterable<? extends Integer>>() {
128123
@Override
129-
public Iterable<? extends Integer> apply(Integer v)
130-
throws Exception {
124+
public Iterable<? extends Integer> apply(Integer v) {
131125
return list;
132126
}
133127
});
@@ -140,48 +134,42 @@ public Iterable<? extends Integer> apply(Integer v)
140134

141135
singleFlatMapObservable = Single.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
142136
@Override
143-
public Observable<? extends Integer> apply(Integer v)
144-
throws Exception {
137+
public Observable<? extends Integer> apply(Integer v) {
145138
return arrayObservable;
146139
}
147140
});
148141

149142
singleFlatMapHideObservable = Single.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
150143
@Override
151-
public Observable<? extends Integer> apply(Integer v)
152-
throws Exception {
144+
public Observable<? extends Integer> apply(Integer v) {
153145
return arrayObservableHide;
154146
}
155147
});
156148

157149
singleFlattenAsObservable = Single.just(1).flattenAsObservable(new Function<Integer, Iterable<? extends Integer>>() {
158150
@Override
159-
public Iterable<? extends Integer> apply(Integer v)
160-
throws Exception {
151+
public Iterable<? extends Integer> apply(Integer v) {
161152
return list;
162153
}
163154
});
164155

165156
maybeFlatMapObservable = Maybe.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
166157
@Override
167-
public Observable<? extends Integer> apply(Integer v)
168-
throws Exception {
158+
public Observable<? extends Integer> apply(Integer v) {
169159
return arrayObservable;
170160
}
171161
});
172162

173163
maybeFlatMapHideObservable = Maybe.just(1).flatMapObservable(new Function<Integer, Observable<? extends Integer>>() {
174164
@Override
175-
public Observable<? extends Integer> apply(Integer v)
176-
throws Exception {
165+
public Observable<? extends Integer> apply(Integer v) {
177166
return arrayObservableHide;
178167
}
179168
});
180169

181170
maybeFlattenAsObservable = Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<? extends Integer>>() {
182171
@Override
183-
public Iterable<? extends Integer> apply(Integer v)
184-
throws Exception {
172+
public Iterable<? extends Integer> apply(Integer v) {
185173
return list;
186174
}
187175
});

‎src/jmh/java/io/reactivex/rxjava3/core/CallableAsyncPerf.java‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ public void setup() {
6868

6969
Callable<Integer> c = new Callable<Integer>() {
7070
@Override
71-
public Integer call() throws Exception {
71+
public Integer call() {
7272
return 1;
7373
}
7474
};
@@ -120,71 +120,71 @@ public void subscribeOnFlowable(Blackhole bh) {
120120
@Benchmark
121121
public void observeOnFlowable(Blackhole bh) {
122122
observeOnFlowable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
123-
};
123+
}
124124

125125
@Benchmark
126126
public void pipelineFlowable(Blackhole bh) {
127127
pipelineFlowable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
128-
};
128+
}
129129

130130
@Benchmark
131131
public void subscribeOnObservable(Blackhole bh) {
132132
subscribeOnObservable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
133-
};
133+
}
134134

135135
@Benchmark
136136
public void observeOnObservable(Blackhole bh) {
137137
observeOnObservable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
138-
};
138+
}
139139

140140
@Benchmark
141141
public void pipelineObservable(Blackhole bh) {
142142
pipelineObservable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
143-
};
143+
}
144144

145145
@Benchmark
146146
public void observeOnSingle(Blackhole bh) {
147147
observeOnSingle.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
148-
};
148+
}
149149

150150
@Benchmark
151151
public void subscribeOnSingle(Blackhole bh) {
152152
subscribeOnSingle.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
153-
};
153+
}
154154

155155
@Benchmark
156156
public void pipelineSingle(Blackhole bh) {
157157
pipelineSingle.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
158-
};
158+
}
159159

160160
@Benchmark
161161
public void observeOnCompletable(Blackhole bh) {
162162
observeOnCompletable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
163-
};
163+
}
164164

165165
@Benchmark
166166
public void subscribeOnCompletable(Blackhole bh) {
167167
subscribeOnCompletable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
168-
};
168+
}
169169

170170
@Benchmark
171171
public void pipelineCompletable(Blackhole bh) {
172172
pipelineCompletable.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
173-
};
173+
}
174174

175175
@Benchmark
176176
public void observeOnMaybe(Blackhole bh) {
177177
observeOnMaybe.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
178-
};
178+
}
179179

180180
@Benchmark
181181
public void subscribeOnMaybe(Blackhole bh) {
182182
subscribeOnMaybe.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
183-
};
183+
}
184184

185185
@Benchmark
186186
public void pipelineMaybe(Blackhole bh) {
187187
pipelineMaybe.subscribeWith(new PerfAsyncConsumer(bh)).await(1);
188-
};
188+
}
189189

190190
}

‎src/jmh/java/io/reactivex/rxjava3/core/EachTypeFlatMapPerf.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -114,11 +114,11 @@ public void nbpRangeMapRange(Blackhole bh) {
114114

115115
@Benchmark
116116
public void singleJust(Blackhole bh) {
117-
singleJust.subscribe(new LatchedSingleObserver<Integer>(bh));
117+
singleJust.subscribe(new LatchedSingleObserver<>(bh));
118118
}
119119

120120
@Benchmark
121121
public void singleJustMapJust(Blackhole bh) {
122-
singleJustMapJust.subscribe(new LatchedSingleObserver<Integer>(bh));
122+
singleJustMapJust.subscribe(new LatchedSingleObserver<>(bh));
123123
}
124124
}

‎src/jmh/java/io/reactivex/rxjava3/core/FlatMapJustPerf.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -41,14 +41,14 @@ public void setup() {
4141

4242
flowable = Flowable.fromArray(array).flatMap(new Function<Integer, Publisher<Integer>>() {
4343
@Override
44-
public Publisher<Integer> apply(Integer v) throws Exception {
44+
public Publisher<Integer> apply(Integer v) {
4545
return Flowable.just(v);
4646
}
4747
});
4848

4949
observable = Observable.fromArray(array).flatMap(new Function<Integer, Observable<Integer>>() {
5050
@Override
51-
public Observable<Integer> apply(Integer v) throws Exception {
51+
public Observable<Integer> apply(Integer v) {
5252
return Observable.just(v);
5353
}
5454
});

‎src/jmh/java/io/reactivex/rxjava3/core/FlattenCrossMapPerf.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -47,14 +47,14 @@ public void setup() {
4747

4848
flowable = Flowable.fromArray(array).flatMapIterable(new Function<Integer, Iterable<Integer>>() {
4949
@Override
50-
public Iterable<Integer> apply(Integer v) throws Exception {
50+
public Iterable<Integer> apply(Integer v) {
5151
return list;
5252
}
5353
});
5454

5555
observable = Observable.fromArray(array).flatMapIterable(new Function<Integer, Iterable<Integer>>() {
5656
@Override
57-
public Iterable<Integer> apply(Integer v) throws Exception {
57+
public Iterable<Integer> apply(Integer v) {
5858
return list;
5959
}
6060
});

‎src/jmh/java/io/reactivex/rxjava3/core/FlattenJustPerf.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -44,14 +44,14 @@ public void setup() {
4444

4545
flowable = Flowable.fromArray(array).flatMapIterable(new Function<Integer, Iterable<Integer>>() {
4646
@Override
47-
public Iterable<Integer> apply(Integer v) throws Exception {
47+
public Iterable<Integer> apply(Integer v) {
4848
return singletonList;
4949
}
5050
});
5151

5252
observable = Observable.fromArray(array).flatMapIterable(new Function<Integer, Iterable<Integer>>() {
5353
@Override
54-
public Iterable<Integer> apply(Integer v) throws Exception {
54+
public Iterable<Integer> apply(Integer v) {
5555
return singletonList;
5656
}
5757
});

0 commit comments

Comments
 (0)