TestPipeline.java

TestPipeline.java

package com.krakenrs.spade.pipeline;

public class TestPipeline {

    public interface PipelineBuilder<I> {
        <O> PipelineBuilder<O> then(PipelineStep<I, O> step);
        
        void run();
    }
    
    public interface PipelineStep<I, O> {
        O execute(I input);
    }

    
    static class BasicPipelineBuilder<I, OB> implements PipelineBuilder<I> {
        BasicPipelineBuilder<?, OB> parent;
        PipelineStep<I, ?> step;
        OB result;
        
        BasicPipelineBuilder() {
        }
        
        BasicPipelineBuilder(BasicPipelineBuilder<?, OB> parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            I prevOut = null;
            if(parent != null) {
                parent.run();
                prevOut = (I) parent.result;
            }
            if(step != null) {
                result = (OB) step.execute(prevOut);
            }
        }

        @Override
        public <O> BasicPipelineBuilder<O, ?> then(PipelineStep<I, O> step) {
          this.step = step;
          return new BasicPipelineBuilder<>(this);
        }
    }
    
    static class PipelineInputValue<I> implements PipelineStep<I, I> {
        I value;
        
        public PipelineInputValue(I value) {
            this.value = value;
        }

        @Override
        public I execute(I input) {
            // if(input != sentinel) throw NO();
            return value;
        }
    }
    
    static <I> PipelineBuilder<I> from(I input) {
        return new BasicPipelineBuilder<I, I>().then(new PipelineInputValue<>(input));
    }
    
    static PipelineStep<String, Integer> addCharsStep() {
        return (str) -> {
            int total = 0;
            for(char c : str.toCharArray()) {
                total += (int) c;
            }
            return total;
        };
    }
    
    static PipelineStep<Integer, String> intToHexStep() {
        return (val) -> {
            return Integer.toHexString(val);
        };
    }
    
    static <T> PipelineStep<T, Void> printStep() {
        return (obj) -> {
            System.out.println(obj);
            return null;
        };
    }
    
    public static void main(String[] args) {
        var pipeline = from("Hello").then(addCharsStep()).then(intToHexStep()).then(printStep());
        pipeline.run();
    }
}