hu.akarnokd.reactive4javaflow.FolyamPlugins Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2017 David Karnok
 *
 * 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.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package hu.akarnokd.reactive4javaflow;

import java.util.function.*;

public final class FolyamPlugins {

    static volatile Consumer onError;

    static volatile BiFunction folyamOnSubscribe;

    static volatile BiFunction esetlegOnSubscribe;

    static volatile BiFunction parallelOnSubscribe;

    static volatile Function folyamOnAssembly;

    static volatile Function esetlegOnAssembly;

    static volatile Function parallelOnAssembly;

    static volatile Function connectableOnAssembly;

    static volatile Function, SchedulerService> onInitSingleSchedulerService;

    static volatile Function, SchedulerService> onInitComputationSchedulerService;

    static volatile Function, SchedulerService> onInitIOSchedulerService;

    static volatile Function, SchedulerService> onInitNewThreadSchedulerService;

    static volatile Function onSingleSchedulerService;

    static volatile Function onComputationSchedulerService;

    static volatile Function onIOSchedulerService;

    static volatile Function onNewThreadSchedulerService;

    private FolyamPlugins() {
        throw new IllegalStateException("No instances!");
    }

    public static int defaultBufferSize() {
        return 128; // TODO make customizable
    }

    @SuppressWarnings("unchecked")
    public static  FolyamSubscriber onSubscribe(Folyam parent, FolyamSubscriber s) {
        BiFunction h = folyamOnSubscribe;
        if (h != null) {
            return h.apply(parent, s);
        }
        return s;
    }

    @SuppressWarnings("unchecked")
    public static  FolyamSubscriber onSubscribe(Esetleg parent, FolyamSubscriber s) {
        BiFunction h = esetlegOnSubscribe;
        if (h != null) {
            return h.apply(parent, s);
        }
        return s;
    }

    @SuppressWarnings("unchecked")
    public static  FolyamSubscriber onSubscribe(ParallelFolyam parent, FolyamSubscriber s) {
        BiFunction h = parallelOnSubscribe;
        if (h != null) {
            return h.apply(parent, s);
        }
        return s;
    }

    public static void reset() {
        setOnError(null);

        setConnectableOnAssembly(null);
        setEsetlegOnAssembly(null);
        setFolyamOnAssembly(null);
        setParallelOnAssembly(null);

        setFolyamOnSubscribe(null);
        setEsetlegOnSubscribe(null);
        setParallelOnSubscribe(null);

        setOnComputationSchedulerService(null);
        setOnSingleSchedulerService(null);
        setOnIOSchedulerService(null);
        setOnNewThreadSchedulerService(null);

        setOnInitComputationSchedulerService(null);
        setOnInitSingleSchedulerService(null);
        setOnInitIOSchedulerService(null);
        setOnInitNewThreadSchedulerService(null);
    }

    public static  Folyam onAssembly(Folyam upstream) {
        Function h = folyamOnAssembly;
        if (h != null) {
            return h.apply(upstream);
        }
        return upstream;
    }

    public static  Esetleg onAssembly(Esetleg upstream) {
        Function h = esetlegOnAssembly;
        if (h != null) {
            return h.apply(upstream);
        }
        return upstream;
    }

    public static  ParallelFolyam onAssembly(ParallelFolyam upstream) {
        Function h = parallelOnAssembly;
        if (h != null) {
            return h.apply(upstream);
        }
        return upstream;
    }

    public static  ConnectableFolyam onAssembly(ConnectableFolyam upstream) {
        Function h = connectableOnAssembly;
        if (h != null) {
            return h.apply(upstream);
        }
        return upstream;
    }

    public static void onError(Throwable ex) {
        Consumer h = onError;
        if (h != null) {
            try {
                h.accept(ex);
                return;
            } catch (Throwable exc) {
                exc.printStackTrace();
            }
        }
        ex.printStackTrace();
    }

    public static void setOnError(Consumer handler) {
        FolyamPlugins.onError = handler;
    }

    public static Consumer getOnError() {
        return onError;
    }

    public static void handleFatal(Throwable ex) {
        if (ex instanceof Error) {
            throw (Error)ex;
        }
    }

    public static BiFunction getFolyamOnSubscribe() {
        return folyamOnSubscribe;
    }

    public static void setFolyamOnSubscribe(BiFunction folyamOnSubscribe) {
        FolyamPlugins.folyamOnSubscribe = folyamOnSubscribe;
    }

    public static BiFunction getEsetlegOnSubscribe() {
        return esetlegOnSubscribe;
    }

    public static void setEsetlegOnSubscribe(BiFunction esetlegOnSubscribe) {
        FolyamPlugins.esetlegOnSubscribe = esetlegOnSubscribe;
    }

    public static BiFunction getParallelOnSubscribe() {
        return parallelOnSubscribe;
    }

    public static void setParallelOnSubscribe(BiFunction parallelOnSubscribe) {
        FolyamPlugins.parallelOnSubscribe = parallelOnSubscribe;
    }

    public static Function getFolyamOnAssembly() {
        return folyamOnAssembly;
    }

    public static void setFolyamOnAssembly(Function folyamOnAssembly) {
        FolyamPlugins.folyamOnAssembly = folyamOnAssembly;
    }

    public static Function getEsetlegOnAssembly() {
        return esetlegOnAssembly;
    }

    public static void setEsetlegOnAssembly(Function esetlegOnAssembly) {
        FolyamPlugins.esetlegOnAssembly = esetlegOnAssembly;
    }

    public static Function getParallelOnAssembly() {
        return parallelOnAssembly;
    }

    public static void setParallelOnAssembly(Function parallelOnAssembly) {
        FolyamPlugins.parallelOnAssembly = parallelOnAssembly;
    }

    public static Function getConnectableOnAssembly() {
        return connectableOnAssembly;
    }

    public static void setConnectableOnAssembly(Function connectableOnAssembly) {
        FolyamPlugins.connectableOnAssembly = connectableOnAssembly;
    }

    public static Function, SchedulerService> getOnInitSingleSchedulerService() {
        return onInitSingleSchedulerService;
    }

    public static void setOnInitSingleSchedulerService(Function, SchedulerService> onInitSingleSchedulerService) {
        FolyamPlugins.onInitSingleSchedulerService = onInitSingleSchedulerService;
    }

    public static Function, SchedulerService> getOnInitComputationSchedulerService() {
        return onInitComputationSchedulerService;
    }

    public static void setOnInitComputationSchedulerService(Function, SchedulerService> onInitComputationSchedulerService) {
        FolyamPlugins.onInitComputationSchedulerService = onInitComputationSchedulerService;
    }

    public static Function, SchedulerService> getOnInitIOSchedulerService() {
        return onInitIOSchedulerService;
    }

    public static void setOnInitIOSchedulerService(Function, SchedulerService> onInitIOSchedulerService) {
        FolyamPlugins.onInitIOSchedulerService = onInitIOSchedulerService;
    }

    public static Function, SchedulerService> getOnInitNewThreadSchedulerService() {
        return onInitNewThreadSchedulerService;
    }

    public static void setOnInitNewThreadSchedulerService(Function, SchedulerService> onInitNewThreadSchedulerService) {
        FolyamPlugins.onInitNewThreadSchedulerService = onInitNewThreadSchedulerService;
    }

    public static Function getOnSingleSchedulerService() {
        return onSingleSchedulerService;
    }

    public static void setOnSingleSchedulerService(Function onSingleSchedulerService) {
        FolyamPlugins.onSingleSchedulerService = onSingleSchedulerService;
    }

    public static Function getOnComputationSchedulerService() {
        return onComputationSchedulerService;
    }

    public static void setOnComputationSchedulerService(Function onComputationSchedulerService) {
        FolyamPlugins.onComputationSchedulerService = onComputationSchedulerService;
    }

    public static Function getOnIOSchedulerService() {
        return onIOSchedulerService;
    }

    public static void setOnIOSchedulerService(Function onIOSchedulerService) {
        FolyamPlugins.onIOSchedulerService = onIOSchedulerService;
    }

    public static Function getOnNewThreadSchedulerService() {
        return onNewThreadSchedulerService;
    }

    public static void setOnNewThreadSchedulerService(Function onNewThreadSchedulerService) {
        FolyamPlugins.onNewThreadSchedulerService = onNewThreadSchedulerService;
    }
}