fun.mike.flapjack.pipeline.lab.PipelineResult Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of flapjack-lab Show documentation
There is a newer version: 0.0.15
package fun.mike.flapjack.pipeline.lab;

import java.util.LinkedList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

import fun.mike.flapjack.alpha.Result;

public class PipelineResult implements Result {
    private final T value;
    private final InputContext inputContext;
    private final OutputContext outputContext;
    private final int inputCount;
    private final int outputCount;
    private final List errors;

    protected PipelineResult(T value, InputContext inputContext, OutputContext outputContext, int inputCount, int outputCount, List errors) {
        this.value = value;
        this.inputContext = inputContext;
        this.outputContext = outputContext;
        this.inputCount = inputCount;
        this.outputCount = outputCount;
        this.errors = errors;
    }

    public static  PipelineResult of(T value, InputContext inputContext, OutputContext outputContext, int inputCount, int outputCount, List errors) {
        return new PipelineResult<>(value, inputContext, outputContext, inputCount, outputCount, errors);
    }

    public  PipelineResult withValue(U value) {
        return new PipelineResult<>(value, inputContext, outputContext, inputCount, outputCount, errors);
    }

    public PipelineResult withMoreErrors(List errors) {
        List allErrors = new LinkedList<>();
        allErrors.addAll(this.errors);
        allErrors.addAll(errors);
        return new PipelineResult<>(value, inputContext, outputContext, inputCount, outputCount, allErrors);
    }

    public PipelineResult withErrors(List errors) {
        return new PipelineResult<>(value, inputContext, outputContext, inputCount, outputCount, errors);
    }

    public boolean isOk() {
        return errors.isEmpty();
    }

    public boolean isNotOk() {
        return !errors.isEmpty();
    }

    public T getValue() {
        return value;
    }

    public T orElse(T other) {
        if (isOk()) {
            return value;
        }
        return other;
    }

    public T orElseThrow() {
        if (isOk()) {
            return value;
        }
        throw new RuntimeException("TODO");
    }

    public int getInputCount() {
        return inputCount;
    }

    public int getOutputCount() {
        return outputCount;
    }

    public int getErrorCount() {
        return errors.size();
    }

    public List getErrors() {
        return errors;
    }

    public  PipelineResult withoutException(Class exceptionType) {
        List filteredErrors = errors.stream()
                .filter(error -> !hasException(error, exceptionType))
                .collect(Collectors.toList());
        return withErrors(filteredErrors);
    }

    public  List getErrorsByException(Class exceptionType) {
        return getErrorsByType(TransformPipelineError.class)
                .stream()
                .filter(error -> exceptionType.isInstance(error.getException()))
                .collect(Collectors.toList());
    }

    private  List getErrorsByType(Class errorType) {
        return errors.stream()
                .filter(errorType::isInstance)
                .map(errorType::cast)
                .collect(Collectors.toList());
    }

    private  boolean hasException(PipelineError error, Class exceptionType) {
        if (error instanceof TransformPipelineError) {
            Exception exception = ((TransformPipelineError) error).getException();
            return exceptionType.isInstance(exception);
        }
        return false;
    }

    public  PipelineResult map(Function mapper) {
        U newValue = mapper.apply(this.value);
        return withValue(newValue);
    }

    public InputContext getInputContext() {
        return inputContext;
    }

    public OutputContext getOutputContext() {
        return outputContext;
    }

    @Override
    public String toString() {
        return "PipelineResult{" +
                "value=" + value +
                ", inputContext=" + inputContext +
                ", outputContext=" + outputContext +
                ", inputCount=" + inputCount +
                ", outputCount=" + outputCount +
                ", errors=" + errors +
                '}';
    }
}