java.util.function.LongToIntFunction Java Examples

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

NamedList<Object> manageTransactionsToBeFixed(
        IOpenBitSet transactions,
        LongToIntFunction nodesCounter,
        Consumer<Long> scheduler,
        AtomicInteger limit)
{
    final NamedList<Object> transactionsList = new SimpleOrderedMap<>();

    long txid = -1;
    while ((txid = transactions.nextSetBit(txid + 1)) != -1 && limit.decrementAndGet() >= 0)
    {
        transactionsList.add(String.valueOf(txid), nodesCounter.applyAsInt(txid));
        scheduler.accept(txid);
    }

    return transactionsList;
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        public Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public final IntStream mapToInt(LongToIntFunction mapper) {
    Objects.requireNonNull(mapper);
    return new IntPipeline.StatelessOp<Long>(this, StreamShape.LONG_VALUE,
                                             StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<Long> opWrapSink(int flags, Sink<Integer> sink) {
            return new Sink.ChainedLong<Integer>(sink) {
                @Override
                public void accept(long t) {
                    downstream.accept(mapper.applyAsInt(t));
                }
            };
        }
    };
}
 

@Override
public IntStreamEx mapToInt(LongToIntFunction mapper) {
    return new IntStreamEx(stream().mapToInt(mapper), context);
}
 

@Override
public IntStream mapToInt(LongToIntFunction mapper) {
    return s.mapToInt(mapper);
}
 

public LongToIntFunction libraryLookup()
{
    return libraryLookup;
}
 

/**
 * Returns the maximum element of this stream according to the provided key
 * extractor function.
 *
 * <p>
 * This is a terminal operation.
 *
 * @param keyExtractor a non-interfering, stateless function
 * @return an {@code OptionalLong} describing the first element of this
 *         stream for which the highest value was returned by key extractor,
 *         or an empty {@code OptionalLong} if the stream is empty
 * @since 0.1.2
 */
public OptionalLong maxByInt(LongToIntFunction keyExtractor) {
    return collect(PrimitiveBox::new, (box, l) -> {
        int key = keyExtractor.applyAsInt(l);
        if (!box.b || box.i < key) {
            box.b = true;
            box.i = key;
            box.l = l;
        }
    }, PrimitiveBox.MAX_INT).asLong();
}
 

/**
 * Returns the minimum element of this stream according to the provided key
 * extractor function.
 *
 * <p>
 * This is a terminal operation.
 *
 * @param keyExtractor a non-interfering, stateless function
 * @return an {@code OptionalLong} describing the first element of this
 *         stream for which the lowest value was returned by key extractor,
 *         or an empty {@code OptionalLong} if the stream is empty
 * @since 0.1.2
 */
public OptionalLong minByInt(LongToIntFunction keyExtractor) {
    return collect(PrimitiveBox::new, (box, l) -> {
        int key = keyExtractor.applyAsInt(l);
        if (!box.b || box.i > key) {
            box.b = true;
            box.i = key;
            box.l = l;
        }
    }, PrimitiveBox.MIN_INT).asLong();
}
 

/**
 * Returns an {@code IntStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
IntStream mapToInt(LongToIntFunction mapper);
 

/**
 * Returns an {@code IntStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
IntStream mapToInt(LongToIntFunction mapper);
 

/**
 * Returns a stream consisting of the elements of this stream, sorted
 * according to the int values extracted by provided function.
 *
 * <p>
 * For ordered streams, the sort is stable. For unordered streams, no
 * stability guarantees are made.
 *
 * <p>
 * This is a <a href="package-summary.html#StreamOps">stateful intermediate
 * operation</a>.
 *
 * @param keyExtractor a
 *        <a href="package-summary.html#NonInterference">non-interfering
 *        </a>, <a href="package-summary.html#Statelessness">stateless</a>
 *        function to be used to extract sorting keys
 * @return the new stream
 */
public LongStreamEx sortedByInt(LongToIntFunction keyExtractor) {
    return sorted(Comparator.comparingInt(keyExtractor::applyAsInt));
}
 

/**
 * Returns an {@code IntStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
IntStream mapToInt(LongToIntFunction mapper);
 

/**
 * Returns an {@code IntStream} consisting of the results of applying the
 * given function to the elements of this stream.
 *
 * <p>This is an <a href="package-summary.html#StreamOps">intermediate
 * operation</a>.
 *
 * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
 *               <a href="package-summary.html#Statelessness">stateless</a>
 *               function to apply to each element
 * @return the new stream
 */
IntStream mapToInt(LongToIntFunction mapper);