code stringlengths 73 34.1k | label stringclasses 1
value |
|---|---|
public final static <T> Optional<Seq<T>> streamToOptional(final Stream<T> stream) {
final List<T> collected = stream.collect(java.util.stream.Collectors.toList());
if (collected.size() == 0)
return Optional.empty();
return Optional.of(Seq.fromIterable(collected));
} | java |
public final static <T> Stream<T> optionalToStream(final Optional<T> optional) {
if (optional.isPresent())
return Stream.of(optional.get());
return Stream.of();
} | java |
public final static <T> CompletableFuture<List<T>> streamToCompletableFuture(final Stream<T> stream) {
return CompletableFuture.completedFuture(stream.collect(Collectors.toList()));
} | java |
public final static <T> Stream<T> completableFutureToStream(final CompletableFuture<T> future) {
return Stream.of(future.join());
} | java |
@SuppressWarnings("unchecked")
public final static <T> Tuple4<Stream<T>, Stream<T>, Stream<T>, Stream<T>> quadruplicate(final Stream<T> stream) {
final Stream<Stream<T>> its = Streams.toBufferingCopier(stream.iterator(), 4)
.stream()
... | java |
public static final <T> Stream<T> appendStream(final Stream<T> stream1, final Stream<T> append) {
return Stream.concat(stream1, append);
} | java |
public static final <T> Stream<T> prependStream(final Stream<T> stream1, final Stream<T> prepend) {
return Stream.concat(prepend, stream1);
} | java |
public static <U> Stream<U> dropWhile(final Stream<U> stream, final Predicate<? super U> predicate) {
return StreamSupport.stream(new SkipWhileSpliterator<U>(stream.spliterator(),predicate), stream.isParallel());
} | java |
public static <U> Stream<U> cycle(final Stream<U> s) {
return cycle(Streamable.fromStream(s));
} | java |
@SuppressWarnings({ "rawtypes", "unchecked" })
public static <R> Seq<R> reduce(final Stream<R> stream, final Iterable<? extends Monoid<R>> reducers) {
return Seq.fromIterable(new MultiReduceOperator<R>(
stream).reduce(reducers));
} | java |
@SuppressWarnings({ "rawtypes", "unchecked" })
public static <R> Seq<R> reduce(final Stream<R> stream, final Stream<? extends Monoid<R>> reducers) {
return reduce(stream, Seq.fromIterable((List) reducers.collect(java.util.stream.Collectors.toList())));
} | java |
public final static <T> Stream<T> cycleUntil(final Stream<T> stream, final Predicate<? super T> predicate) {
return Streams.takeUntil(Streams.cycle(stream), predicate);
} | java |
public final static <T, S, R> Stream<R> zipSequence(final Stream<T> stream, final Stream<? extends S> second,
final BiFunction<? super T, ? super S, ? extends R> zipper) {
final Iterator<T> left = stream.iterator();
final Iterator<? extends S> right = second.iterator();
return Stream... | java |
public final static <T> Stream<Vector<T>> grouped(final Stream<T> stream, final int groupSize) {
return StreamSupport.stream(new GroupingSpliterator<>(stream.spliterator(),()->Vector.empty(),
c->Vector.fromIterable(c),groupSize),stream.isParallel());
} | java |
public final static <T> Stream<T> scanLeft(final Stream<T> stream, final Monoid<T> monoid) {
final Iterator<T> it = stream.iterator();
return Streams.stream(new Iterator<T>() {
boolean init = false;
T next = monoid.zero();
@Override
public boolean hasNex... | java |
public static <T> boolean xMatch(final Stream<T> stream, final int num, final Predicate<? super T> c) {
return stream.filter(t -> c.test(t))
.collect(java.util.stream.Collectors.counting()) == num;
} | java |
public final static <T, R> R foldMap(final Stream<T> stream, final Function<? super T, ? extends R> mapper, final Monoid<R> reducer) {
return reducer.foldLeft(stream.map(mapper));
} | java |
public static <T> Stream<T> intersperse(final Stream<T> stream, final T value) {
return stream.flatMap(t -> Stream.of(value, t))
.skip(1);
} | java |
@SuppressWarnings("unchecked")
public static <T, U> Stream<U> ofType(final Stream<T> stream, final Class<? extends U> type) {
return stream.filter(type::isInstance)
.map(t -> (U) t);
} | java |
public final static <T> Stream<Character> flatMapCharSequence(final Stream<T> stream, final Function<? super T, CharSequence> fn) {
return stream.flatMap(fn.andThen(CharSequence::chars)
.andThen(s->s.mapToObj(i->Character.toChars(i)[0])));
} | java |
public final static <T> Stream<String> flatMapFile(final Stream<T> stream, final Function<? super T, File> fn) {
return stream.flatMap(fn.andThen(f->ExceptionSoftener.softenSupplier(()->Files.lines(Paths.get(f.getAbsolutePath()) ) ).get()));
} | java |
public final static <T> Stream<String> flatMapURL(final Stream<T> stream, final Function<? super T, URL> fn) {
return stream.flatMap(fn.andThen(url -> ExceptionSoftener.softenSupplier(() -> {
final BufferedReader in = new BufferedReader(
new I... | java |
public final static <T> Stream<String> flatMapBufferedReader(final Stream<T> stream, final Function<? super T, BufferedReader> fn) {
return stream.flatMap(fn.andThen(in -> ExceptionSoftener.softenSupplier(() -> {
return in.lines();
})
.get()));
... | java |
public final static <T> Stream<Seq<T>> groupedStatefullyUntil(final Stream<T> stream,
final BiPredicate<Seq<? super T>, ? super T> predicate) {
return StreamSupport.stream(new GroupedStatefullySpliterator<>(stream.spliterator(),()->Seq.of(),Function.identity(),predicate.negate()),stream.isParallel()... | java |
public final static <T> Stream<Seq<T>> groupedUntil(final Stream<T> stream, final Predicate<? super T> predicate) {
return groupedWhile(stream, predicate.negate());
} | java |
public final static <T> Stream<T> debounce(final Stream<T> stream, final long time, final TimeUnit t) {
return new DebounceOperator<>(
stream).debounce(time, t);
} | java |
public final static <T> Stream<T> onePer(final Stream<T> stream, final long time, final TimeUnit t) {
return new OnePerOperator<>(
stream).onePer(time, t);
} | java |
public static MutableLong fromExternal(final LongSupplier s, final LongConsumer c) {
return new MutableLong() {
@Override
public long getAsLong() {
return s.getAsLong();
}
@Override
public Long get() {
return getAsLong(... | java |
public <R> R submit(final Function<RS, R> fn) {
return submit(() -> fn.apply(this.results));
} | java |
public <T> T submit(final Callable<T> callable) {
if (taskExecutor instanceof ForkJoinPool) {
try {
return ((ForkJoinPool) taskExecutor).submit(callable)
.get();
} catch (final ExecutionException e) {
th... | java |
public static <R> Function0<R> memoizeSupplierAsync(final Supplier<R> fn, ScheduledExecutorService ex, long updateRateInMillis){
return ()-> Memoize.memoizeFunctionAsync(a-> fn.get(),ex,updateRateInMillis)
.apply("k");
} | java |
public static <T1, T2, R> Function2<T1, T2, R> memoizeBiFunction(final BiFunction<T1, T2, R> fn) {
Function1<Tuple2<T1, T2>, R> memoise2 = memoizeFunction((final Tuple2<T1, T2> pair) -> fn.apply(pair._1(), pair._2()));
return (t1, t2) -> memoise2.apply(tuple(t1, t2));
} | java |
public static <T1, T2, T3, R> Function3<T1, T2, T3, R> memoizeTriFunction(final Function3<T1, T2, T3, R> fn, final Cacheable<R> cache) {
Function1<Tuple3<T1, T2, T3>, R> memoise2 = memoizeFunction((final Tuple3<T1, T2, T3> triple) -> fn.apply(triple._1(), triple._2(), triple._3()), cache);
return (t1, t2,... | java |
public static <T1, T2, T3, T4, R> Function4<T1, T2, T3, T4, R> memoizeQuadFunction(final Function4<T1, T2, T3, T4, R> fn) {
Function1<Tuple4<T1, T2, T3, T4>, R> memoise2 = memoizeFunction((final Tuple4<T1, T2, T3, T4> quad) -> fn.apply(quad._1(), quad._2(), quad._3(), quad._4()));
return (t1, t2, t3, t4) ... | java |
public static <T> Predicate<T> memoizePredicate(final Predicate<T> p, final Cacheable<Boolean> cache) {
final Function<T, Boolean> memoised = memoizeFunction((Function<T, Boolean>) t -> p.test(t), cache);
LazyImmutable<Boolean> nullR = LazyImmutable.def();
return (t) -> t==null? nullR.computeIfA... | java |
public static <T> Mono<T> anyOf(Mono<T>... fts) {
return Mono.from(Future.anyOf(futures(fts)));
} | java |
public static <T1, T2, R1, R2, R> Mono<R> forEach3(Mono<? extends T1> value1,
Function<? super T1, ? extends Mono<R1>> value2,
BiFunction<? super T1, ? super R1, ? extends Mono<R2>> value3,
Function3<? super T1, ? super R1, ? super R2, ? extends R> yieldingFunction) {
Future... | java |
public static <T, R1, R> Mono<R> forEach(Mono<? extends T> value1,
Function<? super T, Mono<R1>> value2,
BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
Future<R> res = Future.fromPublisher(value1).flat... | java |
public static <T> Mono<T> fromIterable(Iterable<T> t) {
return Mono.from(Flux.fromIterable(t));
} | java |
public static MutableShort fromExternal(final Supplier<Short> s, final Consumer<Short> c) {
return new MutableShort() {
@Override
public short getAsShort() {
return s.get();
}
@Override
public Short get() {
return getAs... | java |
public static <U> Stream<U> cycle(final int times, final Streamable<U> s) {
return Stream.iterate(s.stream(), s1 -> s.stream())
.limit(times)
.flatMap(Function.identity());
} | java |
public static final <A> Collection<A> toConcurrentLazyCollection(final Stream<A> stream) {
return toConcurrentLazyCollection(stream.iterator());
} | java |
@Override
public <B> OptionalT<W,B> map(final Function<? super T, ? extends B> f) {
return new OptionalT<W,B>(
run.map(o -> o.map(f)));
} | java |
public static <W extends WitnessType<W>,A> OptionalT<W,A> of(final AnyM<W,Optional<A>> monads) {
return new OptionalT<>(
monads);
} | java |
public static <T> QueueBasedSubscriber<T> subscriber(final Counter counter, final int maxConcurrency) {
return new QueueBasedSubscriber<>(
counter, maxConcurrency);
} | java |
public static <T> QueueBasedSubscriber<T> subscriber(final Queue<T> q, final Counter counter, final int maxConcurrency) {
return new QueueBasedSubscriber<>(
q, counter, maxConcurrency);
} | java |
public static <T> QueueBasedSubscriber<T> subscriber(final QueueFactory<T> factory, final Counter counter, final int maxConcurrency) {
return new QueueBasedSubscriber<>(
factory, counter, maxConcurrency);
} | java |
public <S,R> Active<W,R> custom(Function<? super Higher<W, T>,? extends S> narrow,Function<? super S,? extends Higher<W,R>> fn){
return Active.of(fn.apply(narrow.apply(single)),def1);
} | java |
public static <T> Mutable<T> fromExternal(final Supplier<T> s, final Consumer<T> c) {
return new Mutable<T>() {
@Override
public T get() {
return s.get();
}
@Override
public Mutable<T> set(final T value) {
c.accept(valu... | java |
public static <T1, T2, T3, T4, T5, R> Supplier<R> partial5(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5,
final Function5<T1, T2, T3, T4, T5, R> quintFunc) {
return () -> quintFunc.apply(t1, t2, t3, t4, t5);
} | java |
public static <T1, T2, T3, T4, T5, T6, R> Supplier<R> partial6(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6,
final Function6<T1, T2, T3, T4, T5, T6, R> hexFunc) {
return () -> hexFunc.apply(t1, t2, t3, t4, t5, t6);
} | java |
public static <T> OptionalKind<T> narrow(final Higher<optional, T> future) {
return (OptionalKind<T>)future;
} | java |
public static <T> Optional<T> narrowK(final Higher<optional, T> Optional) {
//has to be an OptionalKind as only OptionalKind can implement Higher<optional, T>
return ((OptionalKind<T>)Optional).boxed;
} | java |
public static <T1, T2, R1, R2, R> CompletableFuture<R> forEach3(CompletableFuture<? extends T1> value1,
Function<? super T1, ? extends CompletableFuture<R1>> value2,
BiFunction<? super... | java |
public static <T, R1, R> CompletableFuture<R> forEach2(CompletableFuture<? extends T> value1, Function<? super T, CompletableFuture<R1>> value2,
BiFunction<? super T, ? super R1, ? extends R> yieldingFunction) {
return value1.thenCompose(in -> {
... | java |
public static <T> CompletableFuture<ReactiveSeq<T>> sequence(final Stream<? extends CompletableFuture<T>> fts) {
return sequence(ReactiveSeq.fromStream((fts)));
} | java |
static <T> void subscribe(Subscriber<? super T> s, Iterator<? extends T> it) {
if (it == null) {
error(s, new NullPointerException("The iterator is null"));
return;
}
boolean b;
try {
b = it.hasNext();
} catch (Throwable e) {
erro... | java |
public static <K, V> Pipes<K, V> of(final Map<K, Adapter<V>> registered) {
Objects.requireNonNull(registered);
final Pipes<K, V> pipes = new Pipes<>();
pipes.registered.putAll(registered);
return pipes;
} | java |
public void push(final K key, final V value) {
Optional.ofNullable(registered.get(key))
.ifPresent(a -> a.offer(value));
} | java |
@SuppressWarnings({ "unchecked", "rawtypes" })
public Option<Adapter<V>> get(final K key) {
return Option.ofNullable((Adapter) registered.get(key));
} | java |
@SuppressWarnings({ "unchecked", "rawtypes" })
public Option<FutureStream<V>> futureStream(final K key, final LazyReact builder) {
return get(key).map(a -> builder.fromStream(a.stream()));
} | java |
@SuppressWarnings({ "unchecked", "rawtypes" })
public Option<ReactiveSeq<V>> reactiveSeq(final K key) {
return get(key).map(a -> a.stream());
} | java |
public ListX<V> xValues(final K key, final long x) {
return get(key).map(a -> a.stream()
.limit(x)
.to(ReactiveConvertableSequence::converter).listX())
.orElse(ListX.empty());
} | java |
@SuppressWarnings({ "unchecked", "rawtypes" })
public Option<V> oneValue(final K key) {
final ValueSubscriber<V> sub = ValueSubscriber.subscriber();
return get(key).peek(a -> a.stream()
.subscribe(sub))
.flatMap(a -> sub.toMaybe());
} | java |
public void subscribeTo(final K key, final Subscriber<V> subscriber) {
registered.get(key)
.stream()
.subscribe(subscriber);
} | java |
public void subscribeTo(final K key, final Subscriber<V> subscriber, final Executor subscribeOn) {
CompletableFuture.runAsync(() -> subscribeTo(key, subscriber), subscribeOn);
} | java |
public void publishTo(final K key, final Publisher<V> publisher) {
registered.get(key).fromStream(Spouts.from(publisher));
} | java |
public void publishToAsync(final K key, final Publisher<V> publisher) {
SequentialElasticPools.simpleReact.react(er -> er.of(publisher)
.peek(p -> publishTo(key, p)));
} | java |
public void close(final String key) {
Optional.ofNullable(registered.get(key))
.ifPresent(a -> a.close());
} | java |
public <U> FutureStream<U> from(final CompletableFuture<U> cf) {
return this.constructFutures(Stream.of(cf));
} | java |
public <U> FutureStream<U> constructFutures(final Stream<CompletableFuture<U>> s) {
final LazyReact toUse = withStreamOfFutures(true);
return toUse.construct((Stream<U>) s);
} | java |
public <T> FutureStream<T> fromPublisher(final Publisher<? extends T> publisher) {
Objects.requireNonNull(publisher);
Publisher<T> narrowed = (Publisher<T>)publisher;
return fromStream(Spouts.from(narrowed));
} | java |
public static LazyReact parallelBuilder(final int parallelism) {
return LazyReact.builder()
.executor(Executors.newFixedThreadPool(parallelism))
.build();
} | java |
public <U> FutureStream<U> iterate(final U seed, final UnaryOperator<U> f) {
final Subscription sub = new Subscription();
final Supplier<U> supplier = new Supplier<U>() {
@SuppressWarnings("unchecked")
U t = (U) NONE;
@Override
public U get() {
... | java |
public <U> FutureStream<U> generate(final Supplier<U> generate) {
return construct(StreamSupport.<U> stream(new InfiniteClosingSpliteratorFromSupplier<U>(
Long.MAX_VALUE, generate, new Subscription()),
... | java |
public <U> FutureStream<U> generateAsync(final Supplier<U> s) {
return this.constructFutures(ReactiveSeq.generate(() -> 1)
.map(n -> CompletableFuture.supplyAsync(s, getExecutor())));
} | java |
public T set(final T newValue) {
if(continuous!=null)
continuous.offer(newValue);
setDiscreteIfDiff(newValue);
return newValue;
} | java |
public void addMissingRequests(){
int missed=1;
long toRequest=0L;
do {
long localQueued = queued.getAndSet(0l);
Subscription localSub = next.getAndSet(null);
long missedOutput = produced.get();
Subscription localActive = active.get();
... | java |
public ReactiveTask requestAsync(final long n) {
return withSubscriptionAndTask(subscriptionAndTask.map2(c -> CompletableFuture.runAsync(() -> subscriptionAndTask._1().join()
.request(n),
... | java |
@Override
public <B> EitherT<W,ST,B> map(final Function<? super T, ? extends B> f) {
return new EitherT<W,ST,B>(
run.map(o -> o.map(f)));
} | java |
public static <W extends WitnessType<W>,U,ST, R> Function<EitherT<W,ST,U>, EitherT<W,ST,R>> lift(final Function<? super U, ? extends R> fn) {
return optTu -> optTu.map(input -> fn.apply(input));
} | java |
public static <W extends WitnessType<W>,ST,A> EitherT<W,ST,A> of(final AnyM<W,Either<ST,A>> monads) {
return new EitherT<>(
monads);
} | java |
public static <W extends WitnessType<W>,A> EvalT<W,A> of(final AnyM<W,Eval<A>> monads) {
return new EvalT<>(
monads);
} | java |
public boolean add(final T data) {
try {
final boolean result = queue.add((T) nullSafe(data));
if (result) {
if (sizeSignal != null)
this.sizeSignal.set(queue.size());
}
return result;
} catch (final IllegalStateExcep... | java |
@Override
public boolean offer(final T data) {
if (!open) {
throw new ClosedQueueException();
}
try {
final boolean result = producerWait.offer(() -> this.queue.offer((T) nullSafe(data), this.offerTimeout, this.offerTimeUnit));
if (sizeSignal != null)
... | java |
@Override
public boolean close() {
this.open = false;
for (int i = 0; i < listeningStreams.get(); i++) {
try{
this.queue.offer((T) POISON_PILL);
}catch(Exception e){
}
}
return true;
} | java |
@Override
public <R> LazyImmutable<R> map(final Function<? super T, ? extends R> fn) {
final T val = get();
if (val == UNSET)
return (LazyImmutable<R>) this;
else
return LazyImmutable.of(fn.apply(val));
} | java |
public <R> LazyImmutable<? extends R> flatMap(final Function<? super T, ? extends LazyImmutable<? extends R>> fn) {
final T val = get();
if (val == UNSET)
return (LazyImmutable<R>) this;
else
return fn.apply(val);
} | java |
public T computeIfAbsent(final Supplier<T> lazy) {
final T val = get();
if (val == UNSET)
return setOnceFromSupplier(lazy);
return val;
} | java |
public static <REACTOR extends ReactBuilder> ReactPool<REACTOR> elasticPool(final Supplier<REACTOR> supplier) {
return new ReactPool<>(
supplier);
} | java |
public <B> MonoT<W,B> flatMapT(final Function<? super T, MonoT<W,B>> f) {
MonoT<W, B> r = of(run.map(future -> Mono.from(future.flatMap(a -> {
Mono<B> m = f.apply(a).run.stream()
.toList()
.get(0);
return m;
}))));
return r;
} | java |
public static <W extends WitnessType<W>,A> MonoT<W,A> of(final AnyM<W,Mono<A>> monads) {
return new MonoT<>(
monads);
} | java |
public static MutableInt fromExternal(final IntSupplier s, final IntConsumer c) {
return new MutableInt() {
@Override
public int getAsInt() {
return s.getAsInt();
}
@Override
public Integer get() {
return getAsInt();
... | java |
public static MutableByte fromExternal(final Supplier<Byte> s, final Consumer<Byte> c) {
return new MutableByte() {
@Override
public byte getAsByte() {
return s.get();
}
@Override
public Byte get() {
return getAsByte();... | java |
public static final <Y> Predicate<Y> any(final Class<Y> c) {
return a -> a.getClass()
.isAssignableFrom(c);
} | java |
public <R1, R4> State<S,R4> forEach2(Function<? super T, State<S,R1>> value2,
BiFunction<? super T, ? super R1, ? extends R4> yieldingFunction) {
return this.flatMap(in -> {
State<S,R1> a = value2.apply(in);
return a.map(in2 -> {
... | java |
public T join() {
try {
long spin = 1;
while (!done) {
LockSupport.parkNanos(spin++);
}
if (completedExceptionally)
throw new SimpleReactCompletionException(
exception());
... | java |
public static <T> FastFuture<T> fromCompletableFuture(final CompletableFuture<T> cf) {
final FastFuture<T> f = new FastFuture<>();
cf.thenAccept(i -> f.set(i));
cf.exceptionally(t -> {
f.completedExceptionally(t);
return f.join();
});
return f;
} | java |
static void closeOthers(final Queue active, final List<Queue> all) {
all.stream()
.filter(next -> next != active)
.forEach(Queue::closeAndClear);
} | java |
static void closeOthers(final SimpleReactStream active, final List<SimpleReactStream> all) {
all.stream()
.filter(next -> next != active)
.filter(s -> s instanceof BaseSimpleReactStream)
.forEach(SimpleReactStream::cancel);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.