• Home
• com.github.timofeevda
• gwt-rxjs-jsinterop
• 1.1.2
• source code
• Observable.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.github.timofeevda.gwt.rxjs.interop.observable.Observable Maven / Gradle / Ivy

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2017 Denis Timofeev 
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 */
package com.github.timofeevda.gwt.rxjs.interop.observable;

import jsinterop.annotations.JsFunction;
import jsinterop.annotations.JsMethod;
import jsinterop.annotations.JsType;
import com.github.timofeevda.gwt.rxjs.interop.subject.Subject;
import com.github.timofeevda.gwt.rxjs.interop.functions.Action0;
import com.github.timofeevda.gwt.rxjs.interop.functions.Action1;
import com.github.timofeevda.gwt.rxjs.interop.functions.Func1;
import com.github.timofeevda.gwt.rxjs.interop.functions.Func2;
import com.github.timofeevda.gwt.rxjs.interop.functions.Func3;
import com.github.timofeevda.gwt.rxjs.interop.functions.Func4;
import com.github.timofeevda.gwt.rxjs.interop.functions.Func5;
import com.github.timofeevda.gwt.rxjs.interop.functions.Func6;
import com.github.timofeevda.gwt.rxjs.interop.functions.FuncN;
import com.github.timofeevda.gwt.rxjs.interop.functions.Producer;
import com.github.timofeevda.gwt.rxjs.interop.scheduler.Scheduler;
import com.github.timofeevda.gwt.rxjs.interop.subscription.Subscription;
import com.github.timofeevda.gwt.rxjs.interop.functions.ProjectWithArray;
import com.google.gwt.dom.client.Element;

/**
 * @author dtimofeev since 20.12.2016.
 * @param 
 */
@JsType(namespace = "Rx", isNative = true)
@SuppressWarnings("unused")
public class Observable {

    @SafeVarargs
    public native static  Observable of(R... args);

    public native static  Observable from(R[] args);

    public native static  Observable fromEvent(Element target, String eventName);

    public native static  Observable fromEvent(Element target, String eventName, boolean useCapture);

    public native static  Observable create(OnSubscribe onSubscribe);

    public native Observable audit(Observable durationSelector);

    public native Observable auditTime(int duration);

    public native Observable buffer(Observable closingNotifier);

    public native Observable bufferCount(int bufferSize);

    public native Observable bufferCount(int bufferSize, int startBufferEvery);

    public native Observable bufferTime(int bufferTimeSpan);

    public native Observable bufferTime(int bufferTimeSpan, int bufferCreationInterval);

    public native Observable bufferTime(int bufferTimeSpan, int bufferCreationInterval, int maxBufferSize);

    public native Observable bufferToggle(Observable openings, Observable closingsSelector);

    public native Observable bufferWhen(Observable closingSelector);

    @JsMethod(name = "catch")
    public native  Observable _catch(Func2, Observable> catcher);

    public native Observable combineAll();

    public native  Observable combineAll(Func1 mapper);

    public native static  Observable combineLatest(Observable v1, Observable v2,
            Func2 combineFunction);

    public native static  Observable combineLatest(Observable v1,
            Observable v2, Observable v3,
            Func3 combineFunction);

    public native static  Observable combineLatest(Observable v1,
            Observable v2, Observable v3, Observable v4,
            Func4 combineFunction);

    public native static  Observable combineLatest(Iterable> observables, FuncN combineFunction);

    public native static  Observable combineLatest(Observable[] observables);

    public native Observable concat(Observable v1);

    public native Observable concatAll();

    public native static  Observable concat(Observable v1, Observable v2);

    public native static  Observable concat(Observable v1, Observable v2, Observable v3);

    public native static  Observable concat(Observable v1, Observable v2, Observable v3, Observable v4);

    public native static  Observable concat(Iterable> observables);

    public native static  Observable concat(Observable[] observables);

    public native  Observable concatMap(Projector projector);

    public native  Observable concatMap(Projector projector, ResultSelector resultSelector);

    public native  Observable concatMapTo(Observable observable, ResultSelector resultSelector);

    public native Observable count();

    public native Observable count(IndexedSourcePredicate predicate);

    public native Observable debounce(Observable durationSelector);

    public native Observable debounceTime(int time);

    public native  Observable defaultIfEmpty(R defaultValue);

    public native static  Observable defer(Producer> producer);

    public native Observable delay(int initialDelay);

    public native Observable delayWhen(Func1> delayDurationSelector);

    public native Observable delayWhen(Func1> delayDurationSelector, Observable subscriptionDelay);

    public native Observable distinct();

    public native  Observable distinct(KeySelector keySelector);

    public native  Observable distinct(KeySelector keySelector, Observable flushes);

    public native Observable distinctUntilChanged();

    public native  Observable distinctUntilChanged(KeyComparator keyComparator);

    public native  Observable distinctUntilChanged(KeyComparator keyComparator, KeySelector keySelector);

    @JsMethod(name = "do")
    public native Observable _do(Action1 onNext);

    @JsMethod(name = "do")
    public native Observable _do(Action1 onNext, Action1 onError, Action0 onCompleted);

    @JsMethod(name = "do")
    public native Observable _do(Observer observer);

    public native static  Observable empty();

    public native Observable elementAt(int index);

    public native  Observable elementAt(int index, R defaultValue);

    public native Observable every(IndexedSourcePredicate predicate);

    @JsMethod(name = "throw")
    public native static Observable _throw(Object error);

    @JsMethod(name = "throw")
    public native static Observable _throw(Object error, Scheduler scheduler);

    public native Observable exhaust();

    public native  Observable exhaustMap(Projector projector);

    public native  Observable exhaustMap(Projector projector, ResultSelector resultSelector);

    public native  Observable expand(Projector projector);

    public native  Observable expand(Projector projector, int concurrent);

    public native  Observable expand(Projector projector, int concurrent, Scheduler scheduler);

    public native Observable filter(Predicate predicate);

    public native Observable filter(IndexedPredicate indexedPredicate);

    @JsMethod(name = "finally")
    public native Observable _finally(Action0 action);

    public native Observable find(Predicate predicate);

    public native Observable find(IndexedPredicate indexedPredicate);

    public native Observable findIndex(IndexedSourcePredicate predicate);

    public native Observable first(Predicate predicate);

    public native Observable first(IndexedPredicate indexedPredicate);

    public native  Observable first(Predicate predicate, IndexedResultSelector resultSelector);

    public native  Observable first(IndexedPredicate indexedPredicate, IndexedResultSelector resultSelector);

    public native  Observable first(Predicate predicate, IndexedResultSelector resultSelector, R defaultValue);

    public native  Observable first(IndexedPredicate indexedPredicate, IndexedResultSelector resultSelector, R defaultValue);

    public native  Observable> groupBy(KeySelector keySelector);

    public native  Observable> groupBy(KeySelector keySelector, ElementSelector elementSelector);

    public native Observable ignoreElements();

    public native Observable isEmpty();

    @JsMethod(name = "if")
    public native static Observable _if(Producer condition);

    @JsMethod(name = "if")
    public native static  Observable _if(Producer condition, Observable thenSource);

    @JsMethod(name = "if")
    public native static  Observable _if(Producer condition, Observable thenSource, Observable elseSource);

    public native static Observable interval(int period);

    public native static Observable interval(int period, Scheduler scheduler);

    public native Observable last(Predicate predicate);

    public native Observable last(IndexedPredicate indexedPredicate);

    public native  Observable last(Predicate predicate, IndexedResultSelector resultSelector);

    public native  Observable last(IndexedPredicate indexedPredicate, IndexedResultSelector resultSelector);

    public native  Observable last(Predicate predicate, IndexedResultSelector resultSelector, R defaultValue);

    public native  Observable last(IndexedPredicate indexedPredicate, IndexedResultSelector resultSelector, R defaultValue);

    public native  Observable let(Func1, Observable> selector);

    public native  Observable map(Func1 mapper);

    public native  Observable mapTo(R value);

    public native Observable max();

    public native Observable max(Comparator comparator);

    public native static  Observable merge(Observable first, Observable second);

    public native Observable mergeAll();

    public native Observable mergeAll(int concurrent);

    public native  Observable mergeMap(Projector projector);

    public native  Observable mergeMap(Projector projector, int concurrent);

    public native  Observable mergeMap(Projector projector, ResultSelector resultSelector);

    public native  Observable mergeMap(Projector projector, ResultSelector resultSelector, int concurrent);

    public native  Observable mergeMapTo(Observable innerObservable);

    public native  Observable mergeMapTo(Observable innerObservable, int concurrent);

    public native  Observable mergeMapTo(Observable innerObservable, ResultSelector resultSelector);

    public native  Observable mergeMapTo(Observable innerObservable, ResultSelector resultSelector, int concurrent);

    public native  Observable mergeScan(Scanner scanner, R seed);

    public native  Observable mergeScan(Scanner scanner, R seed, int concurrent);

    public native Observable min();

    public native Observable min(Comparator comparator);

    public native ConnectableObservable multicast(Subject subject);

    public native ConnectableObservable multicast(Factory> subjectFactory);

    public native ConnectableObservable multicast(Subject subject, Selector selector);

    public native ConnectableObservable multicast(Factory> subjectFactory, Selector selector);

    public native static  Observable multicast(SubjectFactory subjectFactory);

    public native static  Observable multicast(SubjectFactory subjectFactory, Selector selector);

    public native static  Observable never();

    public native Observable observeOn(Scheduler scheduler);

    public native Observable observeOn(Scheduler scheduler, int delay);

    public native Observable onErrorResumeNext(Observable inputObservable);

    public native Observable onErrorResumeNext(Observable v1, Observable v2);

    public native Observable onErrorResumeNext(Observable v1, Observable v2, Observable v3);

    public native Observable onErrorResumeNext(Observable v1, Observable v2, Observable v3, Observable v4);

    public native Observable onErrorResumeNext(Observable v1, Observable v2, Observable v3, Observable v4, Observable v5);

    public native Observable onErrorResumeNext(Observable v1, Observable v2, Observable v3, Observable v4, Observable v5, Observable v6);

    public native static Observable pairs(Object o);

    public native Observable pairwise();

    public native Observable[] partition(Func1 predicate);

    public native ConnectableObservable publish();

    public native ConnectableObservable publish(Selector selector);

    public native  ConnectableObservable publishBehavior(R value);

    public native ConnectableObservable publishLast();

    public native ConnectableObservable publishReplay();

    public native ConnectableObservable publishReplay(int bufferSize);

    public native ConnectableObservable publishReplay(int bufferSize, int windowTime);

    public native ConnectableObservable publishReplay(int bufferSize, int windowTime, Scheduler scheduler);

    public native static  Observable race(Observable v1, Observable v2);

    public native static Observable range(int start, int count);

    public native static Observable range(int start, int count, Scheduler scheduler);

    public native Observable reduce(Accumulator accumulator);

    public native  Observable reduce(TransformingAccumulator accumulator);

    public native  Observable reduce(TransformingAccumulator accumulator, R seed);

    public native Observable reduce(Accumulator accumulator, T seed);

    public native Observable reduceArray(Accumulator accumulator);

    public native Observable reduceArray(Accumulator accumulator, T[] seed);

    public native Observable repeat();

    public native Observable repeat(int count);

    public native Observable repeatWhen(Observable closingNotifier);

    public native Observable retry();

    public native Observable retry(int count);

    public native Observable retryWhen(Observable closingNotifier);

    public native Observable sample(Observable notifier);

    public native Observable sampleTime(int period);

    public native Observable sampleTime(int period, Scheduler scheduler);

    public native Observable scan(Accumulator accumulator);

    public native  Observable scan(TransformingAccumulator accumulator);

    public native  Observable scan(TransformingAccumulator accumulator, R seed);

    public native Observable scan(Accumulator accumulator, T seed);

    public native Observable scanArray(Accumulator accumulator);

    public native Observable scanArray(Accumulator accumulator, T[] seed);

    public native Observable sequenceEqual(Observable compareTo, Func2 comparer);

    public native Observable share();

    public native Observable single(IndexedSourcePredicate predicate);

    public native Observable skip(int count);

    public native Observable skipUntil(Observable notifier);

    public native Observable skipWhile(Predicate predicate);

    public native Observable skipWhile(IndexedPredicate indexedPredicate);

    public native Observable startWith(T v1);

    public native Observable startWith(T v1, Scheduler scheduler);

    public native Observable startWith(T v1, T v2);

    public native Observable startWith(T v1, T v2, Scheduler scheduler);

    public native Subscription subscribe(Action1 onNext);

    public native Subscription subscribe(Action1 onNext, Action1 onError, Action0 onCompleted);

    public native Subscription subscribe(Observer observer);

    public native Observable subscribeOn(Scheduler scheduler);

    public native Observable subscribeOn(Scheduler scheduler, int delay);

    @JsMethod(name = "switch")
    public native Observable _switch();

    public native  Observable switchMap(Projector projection);

    public native  Observable switchMap(Projector projection, ResultSelector resultSelector);

    public native  Observable switchMapTo(Observable observable, ResultSelector resultSelector);

    public native Observable take(int count);

    public native Observable takeLast(int count);

    public native Observable takeUntil(Observable closingNotifier);

    public native Observable takeWhile(Observable notifier);

    public native Observable throttle(Func1> durationSelector);

    public native Observable throttleTime(int duration);

    public native Observable throttleTime(int duration, Scheduler scheduler);

    public native Observable> timeInterval();

    public native Observable> timeInterval(Scheduler scheduler);

    public native Observable timeout(int due);

    public native Observable timeout(int due, Scheduler scheduler);

    public native Observable timeoutWith(int due, Observable withObservable);

    public native Observable timeoutWith(int due, Observable withObservable, Scheduler scheduler);

    public native static Observable timer(int initialDelay);

    public native static Observable timer(int initialDelay, int period);

    public native static Observable timer(int initialDelay, int period, Scheduler scheduler);

    public native Observable> timestamp();

    public native Observable> timestamp(Scheduler scheduler);

    public native Observable toArray();

    public native Observable> window(Observable windowBoundaries);

    public native Observable> windowCount(int windowSize);

    public native Observable> windowCount(int windowSize, int startWindowEvery);

    public native Observable> windowTime(int windowTimeSpan);

    public native Observable> windowTime(int windowTimeSpan, int windowCreationInterval);

    public native Observable> windowTime(int windowTimeSpan, int windowCreationInterval, Scheduler scheduler);

    public native  Observable> windowToggle(Observable openings, Func1 closingSelector);

    public native  Observable> windowWhen(Observable closingSelector);

    public native  Observable withLatestFrom(Observable v1, Observable v2,
            Func2 combineFunction);

    public native  Observable withLatestFrom(Observable v1,
            Observable v2, Observable v3,
            Func3 combineFunction);

    public native  Observable withLatestFrom(Observable v1,
            Observable v2, Observable v3, Observable v4,
            Func4 combineFunction);

    public native  Observable zip(Func1 projectFunction);

    public native  Observable zip(Observable v2,
            Func2 projectFunction);

    public native  Observable zip(Observable v2, Observable v3,
            Func3 projectFunction);

    public native  Observable zip(
            Observable v2, Observable v3, Observable v4,
            Func4 projectFunction);

    public native  Observable zip(
            Observable v2, Observable v3, Observable v4, Observable v5,
            Func5 projectFunction);

    public native  Observable zip(
            Observable v2, Observable v3, Observable v4, Observable v5, Observable v6,
            Func6 projectFunction);

    public native  Observable zip(Observable v2);

    public native  Observable zip(Observable v2, Observable v3);

    public native  Observable zip(Observable v2, Observable v3, Observable v4);

    public native  Observable zip(Observable v2, Observable v3, Observable v4, Observable v5);

    public native  Observable zip(Observable v2, Observable v3, Observable v4, Observable v5, Observable v6);

    public native static  Observable zip(Observable[] values);

    public native static  Observable zip(Observable v1, Observable v2,
            Func2 projectFunction);

    public native static  Observable zip(Observable v1,
            Observable v2, Observable v3,
            Func3 projectFunction);

    public native static  Observable zip(Observable v1,
            Observable v2, Observable v3, Observable v4,
            Func4 projectFunction);

    public native static  Observable zip(Observable v1,
            Observable v2, Observable v3, Observable v4, Observable v5,
            Func5 projectFunction);

    public native static  Observable zip(Observable v1,
            Observable v2, Observable v3, Observable v4, Observable v5, Observable v6,
            Func6 projectFunction);

    public native static  Observable zip(Observable[] values, ProjectWithArray projectFunction);

    public native Observable zipAll();

    public native  Observable zipAll(Func1 mapper);

    @JsFunction
    public interface Accumulator {

        T call(T acc, T value, int index);
    }

    @JsFunction
    public interface TransformingAccumulator {

        R call(R acc, T value, int index);
    }

    @JsFunction
    public interface Selector {

        Observable call(Observable observable);
    }

    @JsFunction
    public interface Factory {

        T call();
    }

    @JsFunction
    public interface SubjectFactory {

        Subject call(Observable observable);
    }

    @JsFunction
    public interface Comparator {

        int compare(T i1, T i2);
    }

    @JsFunction
    public interface Projector {

        Observable project(T item, int index);
    }

    @JsFunction
    public interface Scanner {

        Observable scan(R acc, T item);
    }

    @JsFunction
    public interface ResultSelector {

        R selectResult(T outerValue, I innerValue, int outerIndex, int innerIndex);
    }

    @JsFunction
    public interface IndexedResultSelector {

        R selectResult(T value, int index);
    }

    @JsFunction
    public interface IndexedSourcePredicate {

        boolean test(T value, int index, Observable source);
    }

    @JsFunction
    public interface IndexedPredicate {

        boolean test(T value, int index);
    }

    @JsFunction
    public interface Predicate {

        boolean test(T value);
    }

    @JsFunction
    public interface KeySelector {

        K selectKey(T item);
    }

    @JsFunction
    public interface ElementSelector {

        R selectElement(T element);
    }

    @JsFunction
    public interface KeyComparator {

        boolean compareKey(K k, K1 k1);
    }

}