afs commented on code in PR #1918: URL: https://github.com/apache/jena/pull/1918#discussion_r1240748203
########## jena-core/src/main/java/org/apache/jena/mem2/iterator/NestedIterator.java: ########## @@ -0,0 +1,89 @@ +/* + * 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.jena.mem2.iterator; + +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.NiceIterator; + +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.function.Consumer; +import java.util.function.Function; + +/** + * Iterator that iterates over the elements of an iterator of iterators. + * The inner iterators are created by a mapper function. + * + * @param <E> the type of the elements + * @param <I> the type of the inner iterators + */ +public class NestedIterator<E, I> extends NiceIterator<E> { + + final Iterator<I> parentIterator; + final Function<I, ExtendedIterator<E>> mapper; + ExtendedIterator<E> currentIterator; + + private boolean hasNext = false; + + public NestedIterator(Iterator<I> parentIterator, Function<I, ExtendedIterator<E>> mapper) { + this.parentIterator = parentIterator; + this.mapper = mapper; + this.currentIterator = parentIterator.hasNext() + ? mapper.apply(parentIterator.next()) + : NiceIterator.emptyIterator(); + } + + @Override + @SuppressWarnings("squid:S1121") + public boolean hasNext() { + if (this.currentIterator.hasNext()) { + return hasNext = true; Review Comment: ```suggestion hasNext = true; return hasNext; ``` Please rewrite to avoid the warning and need to supress it. ########## jena-core/src/test/java/org/apache/jena/mem2/collection/AbstractJenaMapNodeTest.java: ########## @@ -0,0 +1,647 @@ +/* + * 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.jena.mem2.collection; + +import org.apache.jena.graph.Node; +import org.hamcrest.collection.IsEmptyCollection; +import org.hamcrest.collection.IsIterableContainingInAnyOrder; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.ConcurrentModificationException; +import java.util.NoSuchElementException; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; + +import static org.apache.jena.testing_framework.GraphHelper.node; +import static org.junit.Assert.*; Review Comment: ```suggestion import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.Assert.*; ``` `Assert.assertThat` has a deprecation warning. ########## jena-core/src/main/java/org/apache/jena/mem2/spliterator/SparseArraySpliterator.java: ########## @@ -0,0 +1,114 @@ +/* + * 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.jena.mem2.spliterator; + +import java.util.Spliterator; +import java.util.function.Consumer; + +/** + * A spliterator for sparse arrays. This spliterator will iterate over the array + * skipping null entries. + * <p> + * This spliterator supports splitting into sub-spliterators. + * <p> + * The spliterator will check for concurrent modifications by invoking a {@link Runnable} + * before each action. + * + * @param <E> + */ +public class SparseArraySpliterator<E> implements Spliterator<E> { + + private final E[] entries; + private final int fromIndex; + private final Runnable checkForConcurrentModification; + private int pos; + + /** + * Create a spliterator for the given array, with the given size. + * + * @param entries the array + * @param fromIndex the index of the first element, inclusive + * @param toIndex the index of the last element, exclusive + * @param checkForConcurrentModification runnable to check for concurrent modifications + */ + public SparseArraySpliterator(final E[] entries, final int fromIndex, final int toIndex, final Runnable checkForConcurrentModification) { + this.entries = entries; + this.fromIndex = fromIndex; + this.pos = toIndex; + this.checkForConcurrentModification = checkForConcurrentModification; + } + + /** + * Create a spliterator for the given array, with the given size. + * + * @param entries the array + * @param checkForConcurrentModification runnable to check for concurrent modifications + */ + public SparseArraySpliterator(final E[] entries, final Runnable checkForConcurrentModification) { + this(entries, 0, entries.length, checkForConcurrentModification); + } + + @Override + public boolean tryAdvance(Consumer<? super E> action) { + this.checkForConcurrentModification.run(); + while (fromIndex <= --pos) { + if (null != entries[pos]) { + action.accept(entries[pos]); + return true; + } + } + return false; + } + + @Override + public void forEachRemaining(Consumer<? super E> action) { + pos--; + while (fromIndex <= pos) { + if (null != entries[pos]) { + action.accept(entries[pos]); + } + pos--; + } + this.checkForConcurrentModification.run(); + } + + @Override + public Spliterator<E> trySplit() { + final int entriesCount = pos - fromIndex; + if (entriesCount < 2) { + return null; + } + final int toIndexOfSubIterator = this.pos; + this.pos = fromIndex + (entriesCount >>> 1); + return new SparseArraySpliterator<>(entries, this.pos, toIndexOfSubIterator, checkForConcurrentModification); + } + + + @Override + @SuppressWarnings("squid:S2184") + public long estimateSize() { + return pos - fromIndex; Review Comment: ```suggestion return (long)(pos - fromIndex); ``` ########## jena-core/src/main/java/org/apache/jena/mem2/store/fast/FastArrayBunch.java: ########## @@ -0,0 +1,190 @@ +/* + * 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.jena.mem2.store.fast; + +import org.apache.jena.graph.Triple; +import org.apache.jena.mem2.spliterator.ArraySpliterator; +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.NiceIterator; + +import java.util.ConcurrentModificationException; +import java.util.NoSuchElementException; +import java.util.Spliterator; +import java.util.function.Consumer; +import java.util.function.Predicate; + +/** + * An ArrayBunch implements TripleBunch with a linear search of a short-ish + * array of Triples. The array grows by factor 2. + */ +public abstract class FastArrayBunch implements FastTripleBunch { + + private static final int INITIAL_SIZE = 4; + + protected int size = 0; + protected Triple[] elements; + + protected FastArrayBunch() { + elements = new Triple[INITIAL_SIZE]; + } + + public abstract boolean areEqual(final Triple a, final Triple b); + + public boolean containsKey(Triple t) { Review Comment: ```suggestion @Override public boolean containsKey(Triple t) { ``` ########## jena-core/src/main/java/org/apache/jena/mem2/iterator/NestedIterator.java: ########## @@ -0,0 +1,89 @@ +/* + * 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.jena.mem2.iterator; + +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.NiceIterator; + +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.function.Consumer; +import java.util.function.Function; + +/** + * Iterator that iterates over the elements of an iterator of iterators. + * The inner iterators are created by a mapper function. + * + * @param <E> the type of the elements + * @param <I> the type of the inner iterators + */ +public class NestedIterator<E, I> extends NiceIterator<E> { + + final Iterator<I> parentIterator; + final Function<I, ExtendedIterator<E>> mapper; + ExtendedIterator<E> currentIterator; + + private boolean hasNext = false; + + public NestedIterator(Iterator<I> parentIterator, Function<I, ExtendedIterator<E>> mapper) { + this.parentIterator = parentIterator; + this.mapper = mapper; + this.currentIterator = parentIterator.hasNext() + ? mapper.apply(parentIterator.next()) + : NiceIterator.emptyIterator(); + } + + @Override + @SuppressWarnings("squid:S1121") + public boolean hasNext() { + if (this.currentIterator.hasNext()) { + return hasNext = true; + } + while (this.parentIterator.hasNext()) { + this.currentIterator = this.mapper.apply(this.parentIterator.next()); + if (this.currentIterator.hasNext()) { + return hasNext = true; Review Comment: ```suggestion hasNext = true; return hasNext; ``` ########## jena-core/src/main/java/org/apache/jena/mem2/spliterator/ArraySpliterator.java: ########## @@ -0,0 +1,106 @@ +/* + * 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.jena.mem2.spliterator; + +import java.util.Spliterator; +import java.util.function.Consumer; + +/** + * A spliterator for arrays. This spliterator will iterate over the array + * entries within the given boundaries. + * <p> + * This spliterator supports splitting into sub-spliterators. + * <p> + * The spliterator will check for concurrent modifications by invoking a {@link Runnable} + * before each action. + * + * @param <E> + */ +public class ArraySpliterator<E> implements Spliterator<E> { + + private final E[] entries; + private final int fromIndex; + private final Runnable checkForConcurrentModification; + private int pos; + + /** + * Create a spliterator for the given array, with the given size. + * + * @param entries the array + * @param fromIndex the index of the first element, inclusive + * @param toIndex the index of the last element, exclusive + * @param checkForConcurrentModification runnable to check for concurrent modifications + */ + public ArraySpliterator(final E[] entries, final int fromIndex, final int toIndex, final Runnable checkForConcurrentModification) { + this.entries = entries; + this.fromIndex = fromIndex; + this.pos = toIndex; + this.checkForConcurrentModification = checkForConcurrentModification; + } + + /** + * Create a spliterator for the given array, with the given size. + * + * @param entries the array + * @param checkForConcurrentModification runnable to check for concurrent modifications + */ + public ArraySpliterator(final E[] entries, final Runnable checkForConcurrentModification) { + this(entries, 0, entries.length, checkForConcurrentModification); + } + + @Override + public boolean tryAdvance(Consumer<? super E> action) { + this.checkForConcurrentModification.run(); + if (fromIndex <= --pos) { + action.accept(entries[pos]); + return true; + } + return false; + } + + @Override + public void forEachRemaining(Consumer<? super E> action) { + while (fromIndex <= --pos) { + action.accept(entries[pos]); + } + this.checkForConcurrentModification.run(); + } + + @Override + public Spliterator<E> trySplit() { + final int entriesCount = pos - fromIndex; + if (entriesCount < 2) { + return null; + } + final int toIndexOfSubIterator = this.pos; + this.pos = fromIndex + (entriesCount >>> 1); + return new ArraySpliterator<>(entries, this.pos, toIndexOfSubIterator, checkForConcurrentModification); + } + + @Override + @SuppressWarnings("squid:S2184") + public long estimateSize() { + return pos - fromIndex; Review Comment: ```suggestion return (long)(pos - fromIndex); ``` or just remove the SuppressWarnings ########## jena-core/src/main/java/org/apache/jena/mem2/iterator/SparseArrayIterator.java: ########## @@ -0,0 +1,96 @@ +/* + * 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.jena.mem2.iterator; + +import org.apache.jena.util.iterator.NiceIterator; + +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.function.Consumer; + +/** + * An iterator over a sparse array, that skips null entries. + * + * @param <E> the type of the array elements + */ +public class SparseArrayIterator<E> extends NiceIterator<E> implements Iterator<E> { + + private final E[] entries; + private final Runnable checkForConcurrentModification; + private int pos; + private boolean hasNext = false; + + public SparseArrayIterator(final E[] entries, final Runnable checkForConcurrentModification) { + this.entries = entries; + this.pos = entries.length - 1; + this.checkForConcurrentModification = checkForConcurrentModification; + } + + public SparseArrayIterator(final E[] entries, int toIndexExclusive, final Runnable checkForConcurrentModification) { + this.entries = entries; + this.pos = toIndexExclusive - 1; + this.checkForConcurrentModification = checkForConcurrentModification; + } + + /** + * Returns {@code true} if the iteration has more elements. + * (In other words, returns {@code true} if {@link #next} would + * return an element rather than throwing an exception.) + * + * @return {@code true} if the iteration has more elements + */ + @Override + @SuppressWarnings("squid:S1121") + public boolean hasNext() { + while (-1 < pos) { + if (null != entries[pos]) { + return hasNext = true; Review Comment: ```suggestion hasNext = true; return hasNext; ``` ########## jena-core/src/main/java/org/apache/jena/mem2/iterator/NestedIterator.java: ########## @@ -0,0 +1,89 @@ +/* + * 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.jena.mem2.iterator; + +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.NiceIterator; + +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.function.Consumer; +import java.util.function.Function; + +/** + * Iterator that iterates over the elements of an iterator of iterators. + * The inner iterators are created by a mapper function. + * + * @param <E> the type of the elements + * @param <I> the type of the inner iterators + */ +public class NestedIterator<E, I> extends NiceIterator<E> { + + final Iterator<I> parentIterator; + final Function<I, ExtendedIterator<E>> mapper; + ExtendedIterator<E> currentIterator; + + private boolean hasNext = false; + + public NestedIterator(Iterator<I> parentIterator, Function<I, ExtendedIterator<E>> mapper) { + this.parentIterator = parentIterator; + this.mapper = mapper; + this.currentIterator = parentIterator.hasNext() + ? mapper.apply(parentIterator.next()) + : NiceIterator.emptyIterator(); + } + + @Override + @SuppressWarnings("squid:S1121") + public boolean hasNext() { + if (this.currentIterator.hasNext()) { + return hasNext = true; + } + while (this.parentIterator.hasNext()) { + this.currentIterator = this.mapper.apply(this.parentIterator.next()); + if (this.currentIterator.hasNext()) { + return hasNext = true; + } + } + return hasNext = false; Review Comment: ```suggestion hasNext = false; return hasNext; ``` ########## jena-core/src/main/java/org/apache/jena/mem2/collection/FastHashSet.java: ########## @@ -0,0 +1,111 @@ +/* + * 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.jena.mem2.collection; + +/** + * Set which grows, if needed but never shrinks. + * This set does not guarantee any order. Although due to the way it is implemented the elements have a certain order. + * This set does not allow null values. + * This set is not thread safe. + * It´s purpose is to support fast add, remove, contains and stream / iterate operations. + * Only remove operations are not as fast as in {@link java.util.HashSet} + * Iterating over this set not get much faster again after removing elements because the set is not compacted. + */ +public abstract class FastHashSet<K> extends FastHashBase<K> implements JenaSetHashOptimized<K> { + + protected FastHashSet(int initialSize) { + super(initialSize); + } + + protected FastHashSet() { + super(); + } + + @Override + public boolean tryAdd(K key) { + return tryAdd(key, key.hashCode()); + } + + public boolean tryAdd(K value, int hashCode) { Review Comment: ```suggestion @Override public boolean tryAdd(K value, int hashCode) { ``` ########## jena-core/src/main/java/org/apache/jena/mem2/store/legacy/LegacyTripleStore.java: ########## @@ -0,0 +1,152 @@ +/* + * 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.jena.mem2.store.legacy; + +import org.apache.jena.graph.Node; +import org.apache.jena.graph.Triple; +import org.apache.jena.mem2.collection.HashCommonMap; +import org.apache.jena.mem2.collection.JenaSet; +import org.apache.jena.mem2.store.TripleStore; +import org.apache.jena.util.iterator.ExtendedIterator; +import org.apache.jena.util.iterator.NiceIterator; +import org.apache.jena.util.iterator.SingletonIterator; + +import java.util.stream.Stream; + +/** + * Successor of {@link org.apache.jena.mem.GraphTripleStoreMem} that uses term-equality + * instead of literal value equality. + * This implementation also does not support {@link java.util.Iterator#remove()}. + * <p> + * Inner structure: + * - three {@link NodeToTriplesMapMem} instances for each of the three triple fields (subject, predicate, object) + * - each of these maps is a {@link HashCommonMap} with {@link Node} keys and {@link JenaSet<Triple>} values. + * - for up to 9 triples with the same subject, predicate or object, the {@link JenaSet<Triple>} is Review Comment: ```suggestion * - each of these maps is a {@link HashCommonMap} with {@link Node} keys and {@link JenaSet} values. * - for up to 9 triples with the same subject, predicate or object, the {@link JenaSet} is ``` I get warnings for generics in the javadoc and the javadoc does not display properly (no link) (in Eclispe). -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
