private Stream<Case<T,R,X>> sequentialStream(){ return cases.stream(); }
/** * Iterate over each case * * @param consumer accept each case in turn */ public void forEach(Consumer<Case<T,R,X>> consumer){ cases.stream().forEach(consumer); }
private Function composeFirstRecovery() { return firstRecover.stream().reduce( (fn1,fn2)->{ Function except = t-> { try{ return fn1.apply(t); }catch(Throwable e){ return fn2.apply(e); } }; return except; }).get(); } int functionListSize(){
private Function composeFirstRecovery() { return firstRecover.stream() .reduce((fn1, fn2) -> { final Function except = t -> { try { return fn1.apply(t); } catch (final Throwable e) { return fn2.apply(e); } }; return except; }) .get(); }
@SuppressWarnings({ "unchecked", "rawtypes" }) public Comprehender selectComprehender(Object structure) { return cache.computeIfAbsent(structure.getClass(), st-> comprehenders.getRegisteredComprehenders().stream() .filter(e -> e.getKey().isAssignableFrom(structure.getClass())) .map(e->e.getValue()) .findFirst() .orElse(new InvokeDynamicComprehender(Optional.ofNullable(structure) .map(Object::getClass)))); }
@SuppressWarnings({ "unchecked", "rawtypes" }) public Comprehender selectComprehender(Object structure) { return cache.computeIfAbsent(structure.getClass(), st-> comprehenders.getRegisteredComprehenders().stream() .filter(e -> e.getKey().isAssignableFrom(structure.getClass())) .map(e->e.getValue()) .findFirst() .orElse(new InvokeDynamicComprehender(Optional.ofNullable(structure) .map(Object::getClass)))); }
@SuppressWarnings({ "unchecked", "rawtypes" }) public Comprehender selectComprehender(Class structure) { return cache.computeIfAbsent(structure, st->comprehenders.getRegisteredComprehenders().stream() .filter(e -> e.getKey().isAssignableFrom(structure)) .map(e->e.getValue()) .findFirst() .orElse(new InvokeDynamicComprehender(Optional.of(structure)))); } @SuppressWarnings({ "unchecked", "rawtypes" })
@SuppressWarnings({ "unchecked", "rawtypes" }) public Comprehender selectComprehender(Object structure) { return cache.computeIfAbsent(structure.getClass(), st-> comprehenders.getRegisteredComprehenders().stream() .filter(e -> e.getKey().isAssignableFrom(structure.getClass())) .map(e->e.getValue()) .findFirst() .orElse(new InvokeDynamicComprehender(Optional.ofNullable(structure) .map(Object::getClass)))); }
@SuppressWarnings({ "unchecked", "rawtypes" }) public Comprehender selectComprehender(Class structure) { return cache.computeIfAbsent(structure, st->comprehenders.getRegisteredComprehenders().stream() .filter(e -> e.getKey().isAssignableFrom(structure)) .map(e->e.getValue()) .findFirst() .orElse(new InvokeDynamicComprehender(Optional.of(structure)))); } @SuppressWarnings({ "unchecked", "rawtypes" })
@SuppressWarnings({ "unchecked", "rawtypes" }) public Comprehender selectComprehender(Class structure) { return cache.computeIfAbsent(structure, st->comprehenders.getRegisteredComprehenders().stream() .filter(e -> e.getKey().isAssignableFrom(structure)) .map(e->e.getValue()) .findFirst() .orElse(new InvokeDynamicComprehender(Optional.of(structure)))); } @SuppressWarnings({ "unchecked", "rawtypes" })
@SuppressWarnings({ "unchecked", "rawtypes" }) private Optional<Tuple2<Comprehender,Object>> selectComprehender(Object structure) { if(structure==null) return Optional.empty(); return new Comprehenders().getRegisteredComprehenders().stream() .filter(e -> e.getKey().isAssignableFrom(structure.getClass())) .map(e->e.getValue()) .map(v->new Tuple2<Comprehender,Object>(v,structure)) .findFirst(); }
/** * <pre>{@code * val cases = Cases.of(Case.of(input->true,input->"hello")); * val unzipped = cases.unzip(); * assertTrue(unzipped.v1.map(p->p.test(10)).allMatch(v->v)); * assertTrue(unzipped.v2.map(fn->fn.apply(10)).allMatch(v->"hello".equals(v))); * }</pre> * * * @return unzipped Cases, with Predicates in one Stream and Functions in the other. */ public Two<Stream<Predicate<T>>,Stream<X>> unzip(){ return Two.<Stream<Predicate<T>>,Stream<X>>tuple(cases.stream().map(c-> c.getPredicate()),cases.stream().map(c->c.getAction())); }
public Object convertToMonadicForm(Object o){ return upscaler.upscaleIfStream(converters.stream() .filter(t-> t.accept(o)) .map(m -> m.convertToMonadicForm(o)).findFirst().orElse(o)); }
public Object convertToMonadicForm(Object o){ return upscaler.upscaleIfStream(converters.stream().filter(t-> t.accept(o)).map(m -> m.convertToMonadicForm(o)).findFirst().orElse(o)); }
public Object convertToMonadicForm(Object o){ return upscaler.upscaleIfStream(converters.stream().filter(t-> t.accept(o)).map(m -> m.convertToMonadicForm(o)).findFirst().orElse(o)); }
/** * Filter the Cases with the supplied predicate * * <pre> * cases = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second")) .filter(p-> p.getPredicate().test(10)); assertThat(cases.size(),is(1)); * * </pre> * * * @param predicate to filter out cases * @return New Filtered Cases */ public Cases<T,R,X> filter(Predicate<Case<T,R,X>> predicate) { return withCases(cases.stream().filter(data -> predicate.test(data)).map(ConsPStack::singleton) .reduce(ConsPStack.empty(),(acc, next)-> acc.plus(acc.size(),next.get(0)))); }
/** * Filter the Cases with the supplied predicate * * <pre> * Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second")) .filterPredicate(p-> p.test(10)); assertThat(cases.size(),is(1)); * * </pre> * * * @param predicate to filter out cases * @return New Filtered Cases */ public Cases<T,R,X> filterPredicate(Predicate<Predicate<T>> predicate) { return withCases(cases.stream() .filter(data -> predicate.test(data.getPredicate())).map(ConsPStack::singleton) .reduce(ConsPStack.empty(),(acc, next)-> acc.plus(acc.size(),next.get(0)))); }
/** * Filter the Cases with the supplied predicate * * <pre> * * cases = Cases.of(Case.of(input->true,input->"hello"),Case.of(input->false,input->"second")) * .filterFunction(fn-> fn.apply(10).equals("second")); * assertThat(cases.size(),is(1)); * * </pre> * * * @param predicate to filter out cases * @return New Filtered Cases */ public Cases<T,R,X> filterFunction(Predicate<Function<T,R>> predicate) { return withCases(cases.stream() .filter(data -> predicate.test(data.getAction())).map(ConsPStack::singleton) .reduce(ConsPStack.empty(),(acc, next)-> acc.plus(acc.size(),next.get(0)))); }
private Object build( ComprehensionData c, Function f) { Mutable<List<String>> vars = new Mutable<>(new ArrayList()); assigned.stream().forEach(e-> addToVar(e,vars,handleNext(e,c,vars.get()))); Mutable<Object> var = new Mutable<>(f); return c.yield(()-> { return unwrapNestedFunction(c, f, vars.get()); } ); } private Object unwrapNestedFunction(ComprehensionData c, Function f,
private Object build( ComprehensionData c, Function f) { Mutable<PVector<String>> vars = new Mutable<>(TreePVector.empty()); getAssigned().stream().forEach(e-> addToVar(e,vars,handleNext(e,c,vars.get()))); Mutable<Object> var = new Mutable<>(f); return c.yield(()-> { return unwrapNestedFunction(c, f, vars.get()); } ); } private Object unwrapNestedFunction(ComprehensionData c, Function f,