rebase fallout

Author: normen662

fdb-extensions/src/main/java/com/apple/foundationdb/async/MoreAsyncUtil.java

@@ -1144,93 +1144,6 @@ public static <T, U> CompletableFuture<List<U>> forEach(@Nonnull final Iterable<
         }, executor).thenApply(ignored -> Arrays.asList((U[])resultArray));
     }
 
-    /**
-     * Method that provides the functionality of a for loop, however, in an asynchronous way. The result of this method
-     * is a {@link CompletableFuture} that represents the result of the last iteration of the loop body.
-     * @param startI an integer analogous to the starting value of a loop variable in a for loop
-     * @param startU an object of some type {@code U} that represents some initial state that is passed to the loop's
-     *        initial state
-     * @param conditionPredicate a predicate on the loop variable that must be true before the next iteration is
-     *        entered; analogous to the condition in a for loop
-     * @param stepFunction a unary operator used for modifying the loop variable after each iteration
-     * @param body a bi-function to be called for each iteration; this function is initially invoked using
-     *        {@code startI} and {@code startU}; the result of the body is then passed into the next iterator's body
-     *        together with a new value for the loop variable. In this way callers can access state inside an iteration
-     *        that was computed in a previous iteration.
-     * @param executor the executor
-     * @param <U> the type of the result of the body {@link BiFunction}
-     * @return a {@link CompletableFuture} containing the result of the last iteration's body invocation.
-     */
-    @Nonnull
-    public static <U> CompletableFuture<U> forLoop(final int startI, @Nullable final U startU,
-                                                   @Nonnull final IntPredicate conditionPredicate,
-                                                   @Nonnull final IntUnaryOperator stepFunction,
-                                                   @Nonnull final BiFunction<Integer, U, CompletableFuture<U>> body,
-                                                   @Nonnull final Executor executor) {
-        final AtomicInteger loopVariableAtomic = new AtomicInteger(startI);
-        final AtomicReference<U> lastResultAtomic = new AtomicReference<>(startU);
-        return whileTrue(() -> {
-            final int loopVariable = loopVariableAtomic.get();
-            if (!conditionPredicate.test(loopVariable)) {
-                return AsyncUtil.READY_FALSE;
-            }
-            return body.apply(loopVariable, lastResultAtomic.get())
-                    .thenApply(result -> {
-                        loopVariableAtomic.set(stepFunction.applyAsInt(loopVariable));
-                        lastResultAtomic.set(result);
-                        return true;
-                    });
-        }, executor).thenApply(ignored -> lastResultAtomic.get());
-    }
-
-    /**
-     * Method to iterate over some items, for each of which a body is executed asynchronously. The result of each such
-     * executed is then collected in a list and returned as a {@link CompletableFuture} over that list.
-     * @param items the items to iterate over
-     * @param body a function to be called for each item
-     * @param parallelism the maximum degree of parallelism this method should use
-     * @param executor the executor
-     * @param <T> the type of item
-     * @param <U> the type of the result
-     * @return a {@link CompletableFuture} containing a list of results collected from the individual body invocations
-     */
-    @Nonnull
-    @SuppressWarnings("unchecked")
-    public static <T, U> CompletableFuture<List<U>> forEach(@Nonnull final Iterable<T> items,
-                                                            @Nonnull final Function<T, CompletableFuture<U>> body,
-                                                            final int parallelism,
-                                                            @Nonnull final Executor executor) {
-        // this deque is only modified by once upon creation
-        final ArrayDeque<T> toBeProcessed = new ArrayDeque<>();
-        for (final T item : items) {
-            toBeProcessed.addLast(item);
-        }
-
-        final List<CompletableFuture<Void>> working = Lists.newArrayList();
-        final AtomicInteger indexAtomic = new AtomicInteger(0);
-        final Object[] resultArray = new Object[toBeProcessed.size()];
-
-        return whileTrue(() -> {
-            working.removeIf(CompletableFuture::isDone);
-
-            while (working.size() <= parallelism) {
-                final T currentItem = toBeProcessed.pollFirst();
-                if (currentItem == null) {
-                    break;
-                }
-
-                final int index = indexAtomic.getAndIncrement();
-                working.add(body.apply(currentItem)
-                        .thenAccept(result -> resultArray[index] = result));
-            }
-
-            if (working.isEmpty()) {
-                return AsyncUtil.READY_FALSE;
-            }
-            return whenAny(working).thenApply(ignored -> true);
-        }, executor).thenApply(ignored -> Arrays.asList((U[])resultArray));
-    }
-
     /**
      * A {@code Boolean} function that is always true.
      * @param <T> the type of the (ignored) argument to the function

fdb-extensions/src/main/java/com/apple/foundationdb/half/HalfConstants.java

@@ -62,67 +62,3 @@ private HalfConstants() {
         /* Hidden Constructor */
     }
 }
-/*
- * Copyright 2023 Christian Heina
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Modifications Copyright 2015-2025 Apple Inc. and the FoundationDB project authors.
- * This source file is part of the FoundationDB open source project
- */
-
-package com.apple.foundationdb.half;
-
-/**
- * This class contains additional constants documenting limits of {@code Half}.
- * <p>
- * {@code HalfConstants} is implemented to provide, as much as possible, the same interface as
- * {@code jdk.internal.math.FloatConsts}.
- *
- * @author Christian Heina ([email protected])
- */
-public class HalfConstants {
-    /**
-     * The number of logical bits in the significand of a {@code half} number, including the implicit bit.
-     */
-    public static final int SIGNIFICAND_WIDTH = 11;
-
-    /**
-     * The exponent the smallest positive {@code half} subnormal value would have if it could be normalized.
-     */
-    public static final int MIN_SUB_EXPONENT = Half.MIN_EXPONENT - (SIGNIFICAND_WIDTH - 1);
-
-    /**
-     * Bias used in representing a {@code half} exponent.
-     */
-    public static final int EXP_BIAS = 15;
-
-    /**
-     * Bit mask to isolate the sign bit of a {@code half}.
-     */
-    public static final int SIGN_BIT_MASK = 0x8000;
-
-    /**
-     * Bit mask to isolate the exponent field of a {@code half}.
-     */
-    public static final int EXP_BIT_MASK = 0x7C00;
-
-    /**
-     * Bit mask to isolate the significand field of a {@code half}.
-     */
-    public static final int SIGNIF_BIT_MASK = 0x03FF;
-
-    private HalfConstants() {
-        /* Hidden Constructor */
-    }
-}