Move counting long predicate (#314) master
authorClaude Warren <claude@apache.org>
Sat, 25 Jun 2022 15:25:44 +0000 (16:25 +0100)
committerGitHub <noreply@github.com>
Sat, 25 Jun 2022 15:25:44 +0000 (11:25 -0400)
* Moved CounitngLongPredicate

* Moved CounitngLongPredicate

* fixed checkstyle issues

* made instance vars private

src/main/java/org/apache/commons/collections4/bloomfilter/BitMapProducer.java
src/main/java/org/apache/commons/collections4/bloomfilter/CountingLongPredicate.java [new file with mode: 0644]

index 84561eba550394b4912a1ca33371f27ca53e434f..542447e60dbbaff10d8c8fad15538d59998b8184 100644 (file)
@@ -152,34 +152,4 @@ public interface BitMapProducer {
         });
         return fromBitMapArray(result);
     }
-
-    /**
-     * A long predicate that applies the test func to each member of the @{code ary} in sequence for each call to @{code test()}.
-     * if the @{code ary} is exhausted, the subsequent calls to to @{code test} are executed with a zero value.
-     * If the calls to @{code test} do not exhaust the @{code ary} the @{code forEachRemaining} method can be called to
-     * execute the @code{text} with a zero value for each remaining @{code idx} value.
-     *
-     */
-    class CountingLongPredicate implements LongPredicate {
-        int idx = 0;
-        final long[] ary;
-        final LongBiPredicate func;
-
-        CountingLongPredicate(long[] ary, LongBiPredicate func) {
-            this.ary = ary;
-            this.func = func;
-        }
-
-        @Override
-        public boolean test(long other) {
-            return func.test(idx == ary.length ? 0 : ary[idx++], other);
-        }
-
-        boolean forEachRemaining() {
-            while (idx != ary.length && func.test(ary[idx], 0)) {
-                idx++;
-            }
-            return idx == ary.length;
-        }
-    }
 }
diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/CountingLongPredicate.java b/src/main/java/org/apache/commons/collections4/bloomfilter/CountingLongPredicate.java
new file mode 100644 (file)
index 0000000..2611ae4
--- /dev/null
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+package org.apache.commons.collections4.bloomfilter;
+
+import java.util.function.LongPredicate;
+
+/**
+ * A long predicate that applies the test func to each member of the @{code ary} in sequence for each call to @{code test()}.
+ * if the @{code ary} is exhausted, the subsequent calls to to @{code test} are executed with a zero value.
+ * If the calls to @{code test} do not exhaust the @{code ary} the @{code forEachRemaining} method can be called to
+ * execute the @code{text} with a zero value for each remaining @{code idx} value.
+ *
+ */
+class CountingLongPredicate implements LongPredicate {
+    private int idx = 0;
+    private final long[] ary;
+    private final LongBiPredicate func;
+
+    /**
+     * Constructs an instance that will compare the elements in @{code ary} with the elements returned by @{code func}.
+     * function is called as @{code func.test( idxValue, otherValue )}.  if there are more @{code otherValue} values than
+     * @{code idxValues} then @{code func} is called as @{code func.test( 0, otherValue )}.
+     * @param ary The array of long values to compare.
+     * @param func The function to apply to the pairs of long values.
+     */
+    CountingLongPredicate(long[] ary, LongBiPredicate func) {
+        this.ary = ary;
+        this.func = func;
+    }
+
+    @Override
+    public boolean test(long other) {
+        return func.test(idx == ary.length ? 0 : ary[idx++], other);
+    }
+
+    /**
+     * Call the long-long consuming bi-predicate for each remaining unpaired long in
+     * the input array. This method should be invoked after the predicate has been
+     * passed to {@link BitMapProducer#forEachBitMap(LongPredicate)} to consume any
+     * unpaired bitmaps. The second argument to the bi-predicate will be zero.
+     *
+     * @return true if all calls the predicate were successful
+     */
+    boolean forEachRemaining() {
+        // uses local references for optimization benefit.
+        int i = idx;
+        final long[] a = ary;
+        final int limit = a.length;
+        while (i != limit && func.test(a[i], 0)) {
+            i++;
+        }
+        return i == limit;
+    }
+}