Removing final from method parameters

viktorklang · viktorklang · commit 43fd6d18d454 · 2018-06-01T13:13:41.000+02:00
diff --git a/api/src/main/java9/org/reactivestreams/FlowAdapters.java b/api/src/main/java9/org/reactivestreams/FlowAdapters.java
@@ -158,12 +158,12 @@ public static <T> org.reactivestreams.Subscriber<T> toSubscriber(Flow.Subscriber
     static final class FlowToReactiveSubscription implements Flow.Subscription {
         final org.reactivestreams.Subscription reactiveStreams;
 
-        public FlowToReactiveSubscription(final org.reactivestreams.Subscription reactive) {
+        public FlowToReactiveSubscription(org.reactivestreams.Subscription reactive) {
             this.reactiveStreams = reactive;
         }
 
         @Override
-        public void request(final long n) {
+        public void request(long n) {
             reactiveStreams.request(n);
         }
 
@@ -180,12 +180,12 @@ public void cancel() {
     static final class ReactiveToFlowSubscription implements org.reactivestreams.Subscription {
         final Flow.Subscription flow;
 
-        public ReactiveToFlowSubscription(final Flow.Subscription flow) {
+        public ReactiveToFlowSubscription(Flow.Subscription flow) {
             this.flow = flow;
         }
 
         @Override
-        public void request(final long n) {
+        public void request(long n) {
             flow.request(n);
         }
 
@@ -204,22 +204,22 @@ public void cancel() {
     static final class FlowToReactiveSubscriber<T> implements Flow.Subscriber<T> {
         final org.reactivestreams.Subscriber<? super T> reactiveStreams;
 
-        public FlowToReactiveSubscriber(final org.reactivestreams.Subscriber<? super T> reactive) {
+        public FlowToReactiveSubscriber(org.reactivestreams.Subscriber<? super T> reactive) {
             this.reactiveStreams = reactive;
         }
 
         @Override
-        public void onSubscribe(final Flow.Subscription subscription) {
+        public void onSubscribe(Flow.Subscription subscription) {
             reactiveStreams.onSubscribe((subscription == null) ? null : new ReactiveToFlowSubscription(subscription));
         }
 
         @Override
-        public void onNext(final T item) {
+        public void onNext(T item) {
             reactiveStreams.onNext(item);
         }
 
         @Override
-        public void onError(final Throwable throwable) {
+        public void onError(Throwable throwable) {
             reactiveStreams.onError(throwable);
         }
 
@@ -237,22 +237,22 @@ public void onComplete() {
     static final class ReactiveToFlowSubscriber<T> implements org.reactivestreams.Subscriber<T> {
         final Flow.Subscriber<? super T> flow;
 
-        public ReactiveToFlowSubscriber(final Flow.Subscriber<? super T> flow) {
+        public ReactiveToFlowSubscriber(Flow.Subscriber<? super T> flow) {
             this.flow = flow;
         }
 
         @Override
-        public void onSubscribe(final org.reactivestreams.Subscription subscription) {
+        public void onSubscribe(org.reactivestreams.Subscription subscription) {
             flow.onSubscribe((subscription == null) ? null : new FlowToReactiveSubscription(subscription));
         }
 
         @Override
-        public void onNext(final T item) {
+        public void onNext(T item) {
             flow.onNext(item);
         }
 
         @Override
-        public void onError(final Throwable throwable) {
+        public void onError(Throwable throwable) {
             flow.onError(throwable);
         }
 
@@ -271,22 +271,22 @@ public void onComplete() {
     static final class ReactiveToFlowProcessor<T, U> implements org.reactivestreams.Processor<T, U> {
         final Flow.Processor<? super T, ? extends U> flow;
 
-        public ReactiveToFlowProcessor(final Flow.Processor<? super T, ? extends U> flow) {
+        public ReactiveToFlowProcessor(Flow.Processor<? super T, ? extends U> flow) {
             this.flow = flow;
         }
 
         @Override
-        public void onSubscribe(final org.reactivestreams.Subscription subscription) {
+        public void onSubscribe(org.reactivestreams.Subscription subscription) {
             flow.onSubscribe((subscription == null) ? null : new FlowToReactiveSubscription(subscription));
         }
 
         @Override
-        public void onNext(final T t) {
+        public void onNext(T t) {
             flow.onNext(t);
         }
 
         @Override
-        public void onError(final Throwable t) {
+        public void onError(Throwable t) {
             flow.onError(t);
         }
 
@@ -296,7 +296,7 @@ public void onComplete() {
         }
 
         @Override
-        public void subscribe(final org.reactivestreams.Subscriber<? super U> s) {
+        public void subscribe(org.reactivestreams.Subscriber<? super U> s) {
             flow.subscribe((s == null) ? null : new FlowToReactiveSubscriber<U>(s));
         }
     }
@@ -309,22 +309,22 @@ public void subscribe(final org.reactivestreams.Subscriber<? super U> s) {
     static final class FlowToReactiveProcessor<T, U> implements Flow.Processor<T, U> {
         final org.reactivestreams.Processor<? super T, ? extends U> reactiveStreams;
 
-        public FlowToReactiveProcessor(final org.reactivestreams.Processor<? super T, ? extends U> reactive) {
+        public FlowToReactiveProcessor(org.reactivestreams.Processor<? super T, ? extends U> reactive) {
             this.reactiveStreams = reactive;
         }
 
         @Override
-        public void onSubscribe(final Flow.Subscription subscription) {
+        public void onSubscribe(Flow.Subscription subscription) {
             reactiveStreams.onSubscribe((subscription == null) ? null : new ReactiveToFlowSubscription(subscription));
         }
 
         @Override
-        public void onNext(final T t) {
+        public void onNext(T t) {
             reactiveStreams.onNext(t);
         }
 
         @Override
-        public void onError(final Throwable t) {
+        public void onError(Throwable t) {
             reactiveStreams.onError(t);
         }
 
@@ -334,7 +334,7 @@ public void onComplete() {
         }
 
         @Override
-        public void subscribe(final Flow.Subscriber<? super U> s) {
+        public void subscribe(Flow.Subscriber<? super U> s) {
             reactiveStreams.subscribe((s == null) ? null : new ReactiveToFlowSubscriber<U>(s));
         }
     }
@@ -346,12 +346,12 @@ public void subscribe(final Flow.Subscriber<? super U> s) {
     static final class ReactivePublisherFromFlow<T> implements org.reactivestreams.Publisher<T> {
         final Flow.Publisher<? extends T> flow;
 
-        public ReactivePublisherFromFlow(final Flow.Publisher<? extends T> flowPublisher) {
+        public ReactivePublisherFromFlow(Flow.Publisher<? extends T> flowPublisher) {
             this.flow = flowPublisher;
         }
 
         @Override
-        public void subscribe(final org.reactivestreams.Subscriber<? super T> reactive) {
+        public void subscribe(org.reactivestreams.Subscriber<? super T> reactive) {
             flow.subscribe((reactive == null) ? null : new FlowToReactiveSubscriber<T>(reactive));
         }
     }
@@ -364,12 +364,12 @@ static final class FlowPublisherFromReactive<T> implements Flow.Publisher<T> {
 
         final org.reactivestreams.Publisher<? extends T> reactiveStreams;
 
-        public FlowPublisherFromReactive(final org.reactivestreams.Publisher<? extends T> reactivePublisher) {
+        public FlowPublisherFromReactive(org.reactivestreams.Publisher<? extends T> reactivePublisher) {
             this.reactiveStreams = reactivePublisher;
         }
 
         @Override
-        public void subscribe(final Flow.Subscriber<? super T> flow) {
+        public void subscribe(Flow.Subscriber<? super T> flow) {
             reactiveStreams.subscribe((flow == null) ? null : new ReactiveToFlowSubscriber<T>(flow));
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -158,12 +158,12 @@ public static <T> org.reactivestreams.Subscriber<T> toSubscriber(Flow.Subscriber`
`158`	`158`	`static final class FlowToReactiveSubscription implements Flow.Subscription {`
`159`	`159`	`final org.reactivestreams.Subscription reactiveStreams;`
`160`	`160`
`161`		`- public FlowToReactiveSubscription(final org.reactivestreams.Subscription reactive) {`
	`161`	`+ public FlowToReactiveSubscription(org.reactivestreams.Subscription reactive) {`
`162`	`162`	`this.reactiveStreams = reactive;`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`@Override`
`166`		`- public void request(final long n) {`
	`166`	`+ public void request(long n) {`
`167`	`167`	`reactiveStreams.request(n);`
`168`	`168`	`}`
`169`	`169`
`@@ -180,12 +180,12 @@ public void cancel() {`
`180`	`180`	`static final class ReactiveToFlowSubscription implements org.reactivestreams.Subscription {`
`181`	`181`	`final Flow.Subscription flow;`
`182`	`182`
`183`		`- public ReactiveToFlowSubscription(final Flow.Subscription flow) {`
	`183`	`+ public ReactiveToFlowSubscription(Flow.Subscription flow) {`
`184`	`184`	`this.flow = flow;`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`@Override`
`188`		`- public void request(final long n) {`
	`188`	`+ public void request(long n) {`
`189`	`189`	`flow.request(n);`
`190`	`190`	`}`
`191`	`191`
`@@ -204,22 +204,22 @@ public void cancel() {`
`204`	`204`	`static final class FlowToReactiveSubscriber<T> implements Flow.Subscriber<T> {`
`205`	`205`	`final org.reactivestreams.Subscriber<? super T> reactiveStreams;`
`206`	`206`
`207`		`- public FlowToReactiveSubscriber(final org.reactivestreams.Subscriber<? super T> reactive) {`
	`207`	`+ public FlowToReactiveSubscriber(org.reactivestreams.Subscriber<? super T> reactive) {`
`208`	`208`	`this.reactiveStreams = reactive;`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`@Override`
`212`		`- public void onSubscribe(final Flow.Subscription subscription) {`
	`212`	`+ public void onSubscribe(Flow.Subscription subscription) {`
`213`	`213`	`reactiveStreams.onSubscribe((subscription == null) ? null : new ReactiveToFlowSubscription(subscription));`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`@Override`
`217`		`- public void onNext(final T item) {`
	`217`	`+ public void onNext(T item) {`
`218`	`218`	`reactiveStreams.onNext(item);`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`@Override`
`222`		`- public void onError(final Throwable throwable) {`
	`222`	`+ public void onError(Throwable throwable) {`
`223`	`223`	`reactiveStreams.onError(throwable);`
`224`	`224`	`}`
`225`	`225`
`@@ -237,22 +237,22 @@ public void onComplete() {`
`237`	`237`	`static final class ReactiveToFlowSubscriber<T> implements org.reactivestreams.Subscriber<T> {`
`238`	`238`	`final Flow.Subscriber<? super T> flow;`
`239`	`239`
`240`		`- public ReactiveToFlowSubscriber(final Flow.Subscriber<? super T> flow) {`
	`240`	`+ public ReactiveToFlowSubscriber(Flow.Subscriber<? super T> flow) {`
`241`	`241`	`this.flow = flow;`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`@Override`
`245`		`- public void onSubscribe(final org.reactivestreams.Subscription subscription) {`
	`245`	`+ public void onSubscribe(org.reactivestreams.Subscription subscription) {`
`246`	`246`	`flow.onSubscribe((subscription == null) ? null : new FlowToReactiveSubscription(subscription));`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`@Override`
`250`		`- public void onNext(final T item) {`
	`250`	`+ public void onNext(T item) {`
`251`	`251`	`flow.onNext(item);`
`252`	`252`	`}`
`253`	`253`
`254`	`254`	`@Override`
`255`		`- public void onError(final Throwable throwable) {`
	`255`	`+ public void onError(Throwable throwable) {`
`256`	`256`	`flow.onError(throwable);`
`257`	`257`	`}`
`258`	`258`
`@@ -271,22 +271,22 @@ public void onComplete() {`
`271`	`271`	`static final class ReactiveToFlowProcessor<T, U> implements org.reactivestreams.Processor<T, U> {`
`272`	`272`	`final Flow.Processor<? super T, ? extends U> flow;`
`273`	`273`
`274`		`- public ReactiveToFlowProcessor(final Flow.Processor<? super T, ? extends U> flow) {`
	`274`	`+ public ReactiveToFlowProcessor(Flow.Processor<? super T, ? extends U> flow) {`
`275`	`275`	`this.flow = flow;`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`@Override`
`279`		`- public void onSubscribe(final org.reactivestreams.Subscription subscription) {`
	`279`	`+ public void onSubscribe(org.reactivestreams.Subscription subscription) {`
`280`	`280`	`flow.onSubscribe((subscription == null) ? null : new FlowToReactiveSubscription(subscription));`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`@Override`
`284`		`- public void onNext(final T t) {`
	`284`	`+ public void onNext(T t) {`
`285`	`285`	`flow.onNext(t);`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`@Override`
`289`		`- public void onError(final Throwable t) {`
	`289`	`+ public void onError(Throwable t) {`
`290`	`290`	`flow.onError(t);`
`291`	`291`	`}`
`292`	`292`
`@@ -296,7 +296,7 @@ public void onComplete() {`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`@Override`
`299`		`- public void subscribe(final org.reactivestreams.Subscriber<? super U> s) {`
	`299`	`+ public void subscribe(org.reactivestreams.Subscriber<? super U> s) {`
`300`	`300`	`flow.subscribe((s == null) ? null : new FlowToReactiveSubscriber<U>(s));`
`301`	`301`	`}`
`302`	`302`	`}`
`@@ -309,22 +309,22 @@ public void subscribe(final org.reactivestreams.Subscriber<? super U> s) {`
`309`	`309`	`static final class FlowToReactiveProcessor<T, U> implements Flow.Processor<T, U> {`
`310`	`310`	`final org.reactivestreams.Processor<? super T, ? extends U> reactiveStreams;`
`311`	`311`
`312`		`- public FlowToReactiveProcessor(final org.reactivestreams.Processor<? super T, ? extends U> reactive) {`
	`312`	`+ public FlowToReactiveProcessor(org.reactivestreams.Processor<? super T, ? extends U> reactive) {`
`313`	`313`	`this.reactiveStreams = reactive;`
`314`	`314`	`}`
`315`	`315`
`316`	`316`	`@Override`
`317`		`- public void onSubscribe(final Flow.Subscription subscription) {`
	`317`	`+ public void onSubscribe(Flow.Subscription subscription) {`
`318`	`318`	`reactiveStreams.onSubscribe((subscription == null) ? null : new ReactiveToFlowSubscription(subscription));`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`@Override`
`322`		`- public void onNext(final T t) {`
	`322`	`+ public void onNext(T t) {`
`323`	`323`	`reactiveStreams.onNext(t);`
`324`	`324`	`}`
`325`	`325`
`326`	`326`	`@Override`
`327`		`- public void onError(final Throwable t) {`
	`327`	`+ public void onError(Throwable t) {`
`328`	`328`	`reactiveStreams.onError(t);`
`329`	`329`	`}`
`330`	`330`
`@@ -334,7 +334,7 @@ public void onComplete() {`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`@Override`
`337`		`- public void subscribe(final Flow.Subscriber<? super U> s) {`
	`337`	`+ public void subscribe(Flow.Subscriber<? super U> s) {`
`338`	`338`	`reactiveStreams.subscribe((s == null) ? null : new ReactiveToFlowSubscriber<U>(s));`
`339`	`339`	`}`
`340`	`340`	`}`
`@@ -346,12 +346,12 @@ public void subscribe(final Flow.Subscriber<? super U> s) {`
`346`	`346`	`static final class ReactivePublisherFromFlow<T> implements org.reactivestreams.Publisher<T> {`
`347`	`347`	`final Flow.Publisher<? extends T> flow;`
`348`	`348`
`349`		`- public ReactivePublisherFromFlow(final Flow.Publisher<? extends T> flowPublisher) {`
	`349`	`+ public ReactivePublisherFromFlow(Flow.Publisher<? extends T> flowPublisher) {`
`350`	`350`	`this.flow = flowPublisher;`
`351`	`351`	`}`
`352`	`352`
`353`	`353`	`@Override`
`354`		`- public void subscribe(final org.reactivestreams.Subscriber<? super T> reactive) {`
	`354`	`+ public void subscribe(org.reactivestreams.Subscriber<? super T> reactive) {`
`355`	`355`	`flow.subscribe((reactive == null) ? null : new FlowToReactiveSubscriber<T>(reactive));`
`356`	`356`	`}`
`357`	`357`	`}`
`@@ -364,12 +364,12 @@ static final class FlowPublisherFromReactive<T> implements Flow.Publisher<T> {`
`364`	`364`
`365`	`365`	`final org.reactivestreams.Publisher<? extends T> reactiveStreams;`
`366`	`366`
`367`		`- public FlowPublisherFromReactive(final org.reactivestreams.Publisher<? extends T> reactivePublisher) {`
	`367`	`+ public FlowPublisherFromReactive(org.reactivestreams.Publisher<? extends T> reactivePublisher) {`
`368`	`368`	`this.reactiveStreams = reactivePublisher;`
`369`	`369`	`}`
`370`	`370`
`371`	`371`	`@Override`
`372`		`- public void subscribe(final Flow.Subscriber<? super T> flow) {`
	`372`	`+ public void subscribe(Flow.Subscriber<? super T> flow) {`
`373`	`373`	`reactiveStreams.subscribe((flow == null) ? null : new ReactiveToFlowSubscriber<T>(flow));`
`374`	`374`	`}`
`375`	`375`	`}`