[commons-collections] branch master updated: Move counting long predicate (#314)

[gg...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-collections.git


The following commit(s) were added to refs/heads/master by this push:
     new a79ea005b Move counting long predicate (#314)
a79ea005b is described below

commit a79ea005b1ec4ad228067a9c5f2e10dcfb324c5e
Author: Claude Warren <cl...@apache.org>
AuthorDate: Sat Jun 25 16:25:44 2022 +0100

    Move counting long predicate (#314)
    
    * Moved CounitngLongPredicate
    
    * Moved CounitngLongPredicate
    
    * fixed checkstyle issues
    
    * made instance vars private
---
 .../collections4/bloomfilter/BitMapProducer.java   | 30 ----------
 .../bloomfilter/CountingLongPredicate.java         | 68 ++++++++++++++++++++++
 2 files changed, 68 insertions(+), 30 deletions(-)

diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/BitMapProducer.java b/src/main/java/org/apache/commons/collections4/bloomfilter/BitMapProducer.java
index 84561eba5..542447e60 100644
--- a/src/main/java/org/apache/commons/collections4/bloomfilter/BitMapProducer.java
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/BitMapProducer.java
@@ -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
index 000000000..2611ae444
--- /dev/null
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/CountingLongPredicate.java
@@ -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;
+    }
+}