bulk import organize and code formatting

Author: benjchristensen

rxjava-core/src/main/java/rx/Observable.java

@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -15,15 +15,16 @@
  */
 package rx.operators;
 
+import static org.mockito.Mockito.*;
+
 import org.junit.Test;
+
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.util.functions.Func0;
 import rx.util.functions.Func1;
 
-import static org.mockito.Mockito.*;
-
 public final class OperationDefer {
 
     public static <T> Func1<Observer<T>, Subscription> defer(final Func0<Observable<T>> observableFactory) {

rxjava-core/src/main/java/rx/operators/OperationDefer.java

@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import org.junit.Test;
@@ -33,7 +34,7 @@ public final class OperationDematerialize {
 
     /**
      * Dematerializes the explicit notification values of an observable sequence as implicit notifications.
-     *
+     * 
      * @param sequence
      *            An observable sequence containing explicit notification values which have to be turned into implicit notifications.
      * @return An observable sequence exhibiting the behavior corresponding to the source sequence's notification values.
@@ -65,15 +66,15 @@ public void onError(Exception e) {
                 @Override
                 public void onNext(Notification<T> value) {
                     switch (value.getKind()) {
-                        case OnNext:
-                            observer.onNext(value.getValue());
-                            break;
-                        case OnError:
-                            observer.onError(value.getException());
-                            break;
-                        case OnCompleted:
-                            observer.onCompleted();
-                            break;
+                    case OnNext:
+                        observer.onNext(value.getValue());
+                        break;
+                    case OnError:
+                        observer.onError(value.getException());
+                        break;
+                    case OnCompleted:
+                        observer.onCompleted();
+                        break;
                     }
                 }
             });

rxjava-core/src/main/java/rx/operators/OperationDematerialize.java

@@ -15,18 +15,19 @@
  */
 package rx.operators;
 
-import org.junit.Test;
-import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
-import rx.util.Exceptions;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 import java.util.Iterator;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.mock;
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Subscription;
+import rx.util.Exceptions;
 
 /**
  * Samples the most recent value in an observable sequence.
@@ -85,7 +86,6 @@ private MostRecentObserver(T value) {
             this.value = new AtomicReference<T>(value);
         }
 
-
         @Override
         public void onCompleted() {
             completed.set(true);

rxjava-core/src/main/java/rx/operators/OperationMostRecent.java

@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -37,31 +37,33 @@ public final class OperationTake {
 
     /**
      * Returns a specified number of contiguous values from the start of an observable sequence.
-     *
+     * 
      * @param items
      * @param num
      * @return
      */
     public static <T> Func1<Observer<T>, Subscription> take(final Observable<T> items, final int num) {
-        return takeWhileWithIndex(items, OperationTake.<T>numPredicate(num));
+        return takeWhileWithIndex(items, OperationTake.<T> numPredicate(num));
     }
 
     /**
      * Returns a specified number of contiguous values from the start of an observable sequence.
-     *
+     * 
      * @param items
-     * @param predicate a function to test each source element for a condition
+     * @param predicate
+     *            a function to test each source element for a condition
      * @return
      */
     public static <T> Func1<Observer<T>, Subscription> takeWhile(final Observable<T> items, final Func1<T, Boolean> predicate) {
-        return takeWhileWithIndex(items, OperationTake.<T>skipIndex(predicate));
+        return takeWhileWithIndex(items, OperationTake.<T> skipIndex(predicate));
     }
 
     /**
      * Returns values from an observable sequence as long as a specified condition is true, and then skips the remaining values.
-     *
+     * 
      * @param items
-     * @param predicate a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
+     * @param predicate
+     *            a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
      * @return
      */
     public static <T> Func1<Observer<T>, Subscription> takeWhileWithIndex(final Observable<T> items, final Func2<T, Integer, Boolean> predicate) {
@@ -96,7 +98,6 @@ public Boolean call(T input, Integer index) {
         };
     }
 
-
     /**
      * This class is NOT thread-safe if invoked and referenced multiple times. In other words, don't subscribe to it multiple times from different threads.
      * <p>
@@ -105,7 +106,7 @@ public Boolean call(T input, Integer index) {
      * This should all be fine as long as it's kept as a private class and a new instance created from static factory method above.
      * <p>
      * Note how the take() factory method above protects us from a single instance being exposed with the Observable wrapper handling the subscribe flow.
-     *
+     * 
      * @param <T>
      */
     private static class TakeWhile<T> implements Func1<Observer<T>, Subscription> {
@@ -119,7 +120,6 @@ private TakeWhile(Observable<T> items, Func2<T, Integer, Boolean> predicate) {
             this.predicate = predicate;
         }
 
-
         @Override
         public Subscription call(Observer<T> observer) {
             return subscription.wrap(items.subscribe(new ItemObserver(observer)));
@@ -158,8 +158,6 @@ public void onNext(T args) {
 
     public static class UnitTest {
 
-
-
         @Test
         public void testTakeWhile1() {
             Observable<Integer> w = Observable.toObservable(1, 2, 3);

rxjava-core/src/main/java/rx/operators/OperationTake.java

@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -15,21 +15,21 @@
  */
 package rx.operators;
 
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Iterator;
+import java.util.concurrent.LinkedBlockingDeque;
+
 import org.junit.Test;
 import org.mockito.InOrder;
+
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.util.AtomicObservableSubscription;
 import rx.util.functions.Func1;
 
-import java.util.Iterator;
-import java.util.concurrent.LinkedBlockingDeque;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.*;
-
 /**
  * Returns a specified number of contiguous elements from the end of an observable sequence.
  */

rxjava-core/src/main/java/rx/operators/OperationTakeLast.java

@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -15,19 +15,24 @@
  */
 package rx.operators;
 
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
 import org.junit.Test;
+
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.observables.GroupedObservable;
 import rx.util.functions.Func1;
 import rx.util.functions.Functions;
 
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-
-import static org.junit.Assert.*;
-
 public final class OperatorGroupBy {
 
     public static <K, T, R> Func1<Observer<GroupedObservable<K, R>>, Subscription> groupBy(Observable<T> source, final Func1<T, K> keySelector, final Func1<T, R> elementSelector) {
@@ -46,7 +51,7 @@ public KeyValue<K, R> call(T t) {
     }
 
     public static <K, T> Func1<Observer<GroupedObservable<K, T>>, Subscription> groupBy(Observable<T> source, final Func1<T, K> keySelector) {
-        return groupBy(source, keySelector, Functions.<T>identity());
+        return groupBy(source, keySelector, Functions.<T> identity());
     }
 
     private static class GroupBy<K, V> implements Func1<Observer<GroupedObservable<K, V>>, Subscription> {
@@ -57,7 +62,6 @@ private GroupBy(Observable<KeyValue<K, V>> source) {
             this.source = source;
         }
 
-
         @Override
         public Subscription call(final Observer<GroupedObservable<K, V>> observer) {
 

rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java

@@ -1,12 +1,12 @@
 /**
  * Copyright 2013 Netflix, Inc.
- *
+ * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * 
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -15,23 +15,28 @@
  */
 package rx.operators;
 
+import static org.mockito.Mockito.*;
+
 import org.junit.Test;
+
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.util.functions.Func1;
 
-import static org.mockito.Mockito.*;
-
 public class OperatorTakeUntil {
 
     /**
      * Returns the values from the source observable sequence until the other observable sequence produces a value.
-     *
-     * @param source the source sequence to propagate elements for.
-     * @param other  the observable sequence that terminates propagation of elements of the source sequence.
-     * @param <T>    the type of source.
-     * @param <E>    the other type.
+     * 
+     * @param source
+     *            the source sequence to propagate elements for.
+     * @param other
+     *            the observable sequence that terminates propagation of elements of the source sequence.
+     * @param <T>
+     *            the type of source.
+     * @param <E>
+     *            the other type.
      * @return An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.
      */
     public static <T, E> Observable<T> takeUntil(final Observable<T> source, final Observable<E> other) {
@@ -83,7 +88,7 @@ public Subscription call(final Observer<Notification<T>> notificationObserver) {
             return sequence.subscribe(new Observer<T>() {
                 @Override
                 public void onCompleted() {
-                    notificationObserver.onNext(Notification.<T>halt());
+                    notificationObserver.onNext(Notification.<T> halt());
                 }
 
                 @Override
@@ -121,7 +126,7 @@ public void onError(Exception e) {
 
                 @Override
                 public void onNext(E args) {
-                    notificationObserver.onNext(Notification.<T>halt());
+                    notificationObserver.onNext(Notification.<T> halt());
                 }
             });
         }