Apache Lucene open-source search software
Replace Map<Character> by CharObjectHashMap and Set<Character> by CharHashSet. (#13420)
Bruno Roustant6e2a8fc9b75b
diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/MappingCharFilter.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/MappingCharFilter.javaindex 04b7368637c..0d56ce960fd 100644--- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/MappingCharFilter.java+++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/MappingCharFilter.java@@ -18,13 +18,13 @@ package org.apache.lucene.analysis.charfilter;import java.io.IOException;import java.io.Reader;-import java.util.Map;import org.apache.lucene.analysis.CharFilter; // javadocsimport org.apache.lucene.analysis.util.RollingCharBuffer;import org.apache.lucene.util.CharsRef;import org.apache.lucene.util.fst.CharSequenceOutputs;import org.apache.lucene.util.fst.FST;import org.apache.lucene.util.fst.Outputs;+import org.apache.lucene.util.hppc.CharObjectHashMap;/*** Simplistic {@link CharFilter} that applies the mappings contained in a {@link NormalizeCharMap}@@ -38,7 +38,7 @@ public class MappingCharFilter extends BaseCharFilter {private final FST.BytesReader fstReader;private final RollingCharBuffer buffer = new RollingCharBuffer();private final FST.Arc<CharsRef> scratchArc = new FST.Arc<>();- private final Map<Character, FST.Arc<CharsRef>> cachedRootArcs;+ private final CharObjectHashMap<FST.Arc<CharsRef>> cachedRootArcs;private CharsRef replacement;private int replacementPointer;@@ -96,7 +96,7 @@ public class MappingCharFilter extends BaseCharFilter {final int firstCH = buffer.get(inputOff);if (firstCH != -1) {- FST.Arc<CharsRef> arc = cachedRootArcs.get(Character.valueOf((char) firstCH));+ FST.Arc<CharsRef> arc = cachedRootArcs.get((char) firstCH);if (arc != null) {if (!FST.targetHasArcs(arc)) {// Fast pass for single character match:diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/NormalizeCharMap.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/NormalizeCharMap.javaindex 1ffa071835e..ef0b0141ac8 100644--- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/NormalizeCharMap.java+++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/charfilter/NormalizeCharMap.java@@ -17,7 +17,6 @@package org.apache.lucene.analysis.charfilter;import java.io.IOException;-import java.util.HashMap;import java.util.Map;import java.util.TreeMap;import org.apache.lucene.util.CharsRef;@@ -27,6 +26,7 @@ import org.apache.lucene.util.fst.FST;import org.apache.lucene.util.fst.FSTCompiler;import org.apache.lucene.util.fst.Outputs;import org.apache.lucene.util.fst.Util;+import org.apache.lucene.util.hppc.CharObjectHashMap;// TODO: save/load?@@ -37,7 +37,7 @@ import org.apache.lucene.util.fst.Util;public class NormalizeCharMap {final FST<CharsRef> map;- final Map<Character, FST.Arc<CharsRef>> cachedRootArcs = new HashMap<>();+ final CharObjectHashMap<FST.Arc<CharsRef>> cachedRootArcs = new CharObjectHashMap<>();// Use the builder to create:private NormalizeCharMap(FST<CharsRef> map) {@@ -53,8 +53,7 @@ public class NormalizeCharMap {while (true) {assert scratchArc.label() != FST.END_LABEL;cachedRootArcs.put(- Character.valueOf((char) scratchArc.label()),- new FST.Arc<CharsRef>().copyFrom(scratchArc));+ (char) scratchArc.label(), new FST.Arc<CharsRef>().copyFrom(scratchArc));if (scratchArc.isLast()) {break;}diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/Dictionary.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/Dictionary.javaindex f93d59e9bbd..d8aac0c5066 100644--- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/Dictionary.java+++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/Dictionary.java@@ -41,7 +41,6 @@ import java.util.Collection;import java.util.Collections;import java.util.Comparator;import java.util.HashMap;-import java.util.HashSet;import java.util.LinkedHashMap;import java.util.LinkedHashSet;import java.util.List;@@ -49,7 +48,6 @@ import java.util.Map;import java.util.Set;import java.util.TreeMap;import java.util.stream.Collectors;-import java.util.stream.Stream;import org.apache.lucene.analysis.hunspell.SortingStrategy.EntryAccumulator;import org.apache.lucene.analysis.hunspell.SortingStrategy.EntrySupplier;import org.apache.lucene.store.Directory;@@ -60,6 +58,7 @@ import org.apache.lucene.util.fst.FST;import org.apache.lucene.util.fst.FSTCompiler;import org.apache.lucene.util.fst.IntSequenceOutputs;import org.apache.lucene.util.fst.Util;+import org.apache.lucene.util.hppc.CharHashSet;import org.apache.lucene.util.hppc.IntArrayList;import org.apache.lucene.util.hppc.IntCursor;@@ -334,8 +333,8 @@ public class Dictionary {throws IOException, ParseException {TreeMap<String, IntArrayList> prefixes = new TreeMap<>();TreeMap<String, IntArrayList> suffixes = new TreeMap<>();- Set<Character> prefixContFlags = new HashSet<>();- Set<Character> suffixContFlags = new HashSet<>();+ CharHashSet prefixContFlags = new CharHashSet();+ CharHashSet suffixContFlags = new CharHashSet();Map<String, Integer> seenPatterns = new HashMap<>();// zero condition -> 0 ord@@ -673,7 +672,7 @@ public class Dictionary {*/private void parseAffix(TreeMap<String, IntArrayList> affixes,- Set<Character> secondStageFlags,+ CharHashSet secondStageFlags,String header,LineNumberReader reader,AffixKind kind,@@ -1178,10 +1177,14 @@ public class Dictionary {}char[] allNonSuggestibleFlags() {- return Dictionary.toSortedCharArray(- Stream.of(HIDDEN_FLAG, noSuggest, forbiddenword, onlyincompound, subStandard)- .filter(c -> c != FLAG_UNSET)- .collect(Collectors.toSet()));+ CharHashSet set = new CharHashSet(5);+ set.add(HIDDEN_FLAG);+ for (char c : new char[] {noSuggest, forbiddenword, onlyincompound, subStandard}) {+ if (c != FLAG_UNSET) {+ set.add(c);+ }+ }+ return Dictionary.toSortedCharArray(set);}private List<String> readMorphFields(String word, String unparsed) {@@ -1538,12 +1541,8 @@ public class Dictionary {return reuse;}- static char[] toSortedCharArray(Set<Character> set) {- char[] chars = new char[set.size()];- int i = 0;- for (Character c : set) {- chars[i++] = c;- }+ static char[] toSortedCharArray(CharHashSet set) {+ char[] chars = set.toArray();Arrays.sort(chars);return chars;}diff --git a/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/WordFormGenerator.java b/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/WordFormGenerator.javaindex 2e0799f4caa..c2e9d05ec0d 100644--- a/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/WordFormGenerator.java+++ b/lucene/analysis/common/src/java/org/apache/lucene/analysis/hunspell/WordFormGenerator.java@@ -42,6 +42,8 @@ import org.apache.lucene.analysis.hunspell.AffixedWord.Affix;import org.apache.lucene.util.IntsRef;import org.apache.lucene.util.fst.FST;import org.apache.lucene.util.fst.IntsRefFSTEnum;+import org.apache.lucene.util.hppc.CharHashSet;+import org.apache.lucene.util.hppc.CharObjectHashMap;/*** A utility class used for generating possible word forms by adding affixes to stems ({@link@@ -50,7 +52,7 @@ import org.apache.lucene.util.fst.IntsRefFSTEnum;*/public class WordFormGenerator {private final Dictionary dictionary;- private final Map<Character, List<AffixEntry>> affixes = new HashMap<>();+ private final CharObjectHashMap<List<AffixEntry>> affixes = new CharObjectHashMap<>();private final Stemmer stemmer;public WordFormGenerator(Dictionary dictionary) {@@ -75,7 +77,15 @@ public class WordFormGenerator {char flag = dictionary.affixData(id, AFFIX_FLAG);var entry =new AffixEntry(id, flag, kind, toString(kind, io.input), strip(id), condition(id));- affixes.computeIfAbsent(flag, __ -> new ArrayList<>()).add(entry);+ List<AffixEntry> entries;+ int index = affixes.indexOf(flag);+ if (index < 0) {+ entries = new ArrayList<>();+ affixes.indexInsert(index, flag, entries);+ } else {+ entries = affixes.indexGet(index);+ }+ entries.add(entry);}}} catch (IOException e) {@@ -162,11 +172,7 @@ public class WordFormGenerator {}private static char[] deduplicate(char[] flags) {- Set<Character> set = new HashSet<>();- for (char flag : flags) {- set.add(flag);- }- return toSortedCharArray(set);+ return toSortedCharArray(CharHashSet.from(flags));}/**@@ -408,7 +414,7 @@ public class WordFormGenerator {int innerSuffix) {String candidate = new String(word, offset, length);stemCounts.merge(candidate, 1, Integer::sum);- Set<Character> flags = new LinkedHashSet<>();+ CharHashSet flags = new CharHashSet();if (outerPrefix >= 0) flags.add(dictionary.affixData(outerPrefix, AFFIX_FLAG));if (innerPrefix >= 0) flags.add(dictionary.affixData(innerPrefix, AFFIX_FLAG));if (outerSuffix >= 0) flags.add(dictionary.affixData(outerSuffix, AFFIX_FLAG));@@ -479,7 +485,7 @@ public class WordFormGenerator {if (wordSet.contains(extra)) continue;if (forbidden.contains(extra) && dictionary.forbiddenword != FLAG_UNSET) {- addEntry(toEdit, toAdd, extra, Set.of(dictionary.forbiddenword));+ addEntry(toEdit, toAdd, extra, CharHashSet.from(dictionary.forbiddenword));} else {extraGenerated.add(extra);}@@ -489,7 +495,7 @@ public class WordFormGenerator {}private void addEntry(- List<DictEntry> toEdit, List<DictEntry> toAdd, String stem, Set<Character> flags) {+ List<DictEntry> toEdit, List<DictEntry> toAdd, String stem, CharHashSet flags) {String flagString = toFlagString(flags);(existingStems.contains(stem) ? toEdit : toAdd).add(DictEntry.create(stem, flagString));}@@ -529,18 +535,20 @@ public class WordFormGenerator {.flatMap(swc -> expansionCache.computeIfAbsent(swc, expandToWords).stream());}- private List<AffixedWord> expand(String stem, Set<Character> flagSet) {+ private List<AffixedWord> expand(String stem, CharHashSet flagSet) {return getAllWordForms(stem, toFlagString(flagSet), checkCanceled);}- private String toFlagString(Set<Character> flagSet) {+ private String toFlagString(CharHashSet flagSet) {return dictionary.flagParsingStrategy.printFlags(Dictionary.toSortedCharArray(flagSet));}}- private record FlagSet(Set<Character> flags, Dictionary dictionary) {- static Set<Character> flatten(Set<FlagSet> flagSets) {- return flagSets.stream().flatMap(f -> f.flags.stream()).collect(Collectors.toSet());+ private record FlagSet(CharHashSet flags, Dictionary dictionary) {+ static CharHashSet flatten(Set<FlagSet> flagSets) {+ CharHashSet set = new CharHashSet(flagSets.size() << 1);+ flagSets.forEach(flagSet -> set.addAll(flagSet.flags));+ return set;}@Overridediff --git a/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseFilterUtil.java b/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseFilterUtil.javanew file mode 100644index 00000000000..36410b3ea31--- /dev/null+++ b/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseFilterUtil.java@@ -0,0 +1,35 @@+/*+ * 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.lucene.analysis.ja;++import java.util.Map;+import org.apache.lucene.util.hppc.CharObjectHashMap;++/** Utility methods for Japanese filters. */+class JapaneseFilterUtil {++ /** Creates a primitive char-to-char map from a set of {@link java.util.Map.Entry}. */+ @SafeVarargs+ static CharObjectHashMap<Character> createCharMap(+ Map.Entry<Character, Character>... charMappings) {+ CharObjectHashMap<Character> map = new CharObjectHashMap<>(charMappings.length);+ for (Map.Entry<Character, Character> charMapping : charMappings) {+ map.put(charMapping.getKey(), charMapping.getValue());+ }+ return map;+ }+}diff --git a/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseHiraganaUppercaseFilter.java b/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseHiraganaUppercaseFilter.javaindex b5078b73607..e7c0969aed5 100644--- a/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseHiraganaUppercaseFilter.java+++ b/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseHiraganaUppercaseFilter.java@@ -16,11 +16,14 @@*/package org.apache.lucene.analysis.ja;+import static org.apache.lucene.analysis.ja.JapaneseFilterUtil.createCharMap;+import java.io.IOException;import java.util.Map;import org.apache.lucene.analysis.TokenFilter;import org.apache.lucene.analysis.TokenStream;import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;+import org.apache.lucene.util.hppc.CharObjectHashMap;/*** A {@link TokenFilter} that normalizes small letters (捨て仮名) in hiragana into normal letters. For@@ -30,13 +33,13 @@ import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;* legal, contract policies, etc.*/public final class JapaneseHiraganaUppercaseFilter extends TokenFilter {- private static final Map<Character, Character> LETTER_MAPPINGS;+ private static final CharObjectHashMap<Character> LETTER_MAPPINGS;static {// supported characters are:// ぁ ぃ ぅ ぇ ぉ っ ゃ ゅ ょ ゎ ゕ ゖLETTER_MAPPINGS =- Map.ofEntries(+ createCharMap(Map.entry('ぁ', 'あ'),Map.entry('ぃ', 'い'),Map.entry('ぅ', 'う'),@@ -59,17 +62,16 @@ public final class JapaneseHiraganaUppercaseFilter extends TokenFilter {@Overridepublic boolean incrementToken() throws IOException {- if (input.incrementToken()) {- char[] termBuffer = termAttr.buffer();- for (int i = 0; i < termBuffer.length; i++) {- Character c = LETTER_MAPPINGS.get(termBuffer[i]);- if (c != null) {- termBuffer[i] = c;- }- }- return true;- } else {+ if (!input.incrementToken()) {return false;}+ final char[] termBuffer = termAttr.buffer();+ for (int i = 0, length = termAttr.length(); i < length; i++) {+ Character c = LETTER_MAPPINGS.get(termBuffer[i]);+ if (c != null) {+ termBuffer[i] = c;+ }+ }+ return true;}}diff --git a/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseKatakanaUppercaseFilter.java b/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseKatakanaUppercaseFilter.javaindex 5e05714d1c3..7a96acd4c0c 100644--- a/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseKatakanaUppercaseFilter.java+++ b/lucene/analysis/kuromoji/src/java/org/apache/lucene/analysis/ja/JapaneseKatakanaUppercaseFilter.java@@ -16,11 +16,14 @@*/package org.apache.lucene.analysis.ja;+import static org.apache.lucene.analysis.ja.JapaneseFilterUtil.createCharMap;+import java.io.IOException;import java.util.Map;import org.apache.lucene.analysis.TokenFilter;import org.apache.lucene.analysis.TokenStream;import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;+import org.apache.lucene.util.hppc.CharObjectHashMap;/*** A {@link TokenFilter} that normalizes small letters (捨て仮名) in katakana into normal letters. For@@ -30,13 +33,13 @@ import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;* legal, contract policies, etc.*/public final class JapaneseKatakanaUppercaseFilter extends TokenFilter {- private static final Map<Character, Character> LETTER_MAPPINGS;+ private static final CharObjectHashMap<Character> LETTER_MAPPINGS;static {// supported characters are:// ァ ィ ゥ ェ ォ ヵ ㇰ ヶ ㇱ ㇲ ッ ㇳ ㇴ ㇵ ㇶ ㇷ ㇷ゚ ㇸ ㇹ ㇺ ャ ュ ョ ㇻ ㇼ ㇽ ㇾ ㇿ ヮLETTER_MAPPINGS =- Map.ofEntries(+ createCharMap(Map.entry('ァ', 'ア'),Map.entry('ィ', 'イ'),Map.entry('ゥ', 'ウ'),@@ -75,22 +78,24 @@ public final class JapaneseKatakanaUppercaseFilter extends TokenFilter {@Overridepublic boolean incrementToken() throws IOException {- if (input.incrementToken()) {- String term = termAttr.toString();- if (term.contains("ㇷ゚")) {- term = term.replace("ㇷ゚", "プ");- termAttr.setEmpty().append(term);- }- char[] termBuffer = termAttr.buffer();- for (int i = 0; i < termBuffer.length; i++) {- Character c = LETTER_MAPPINGS.get(termBuffer[i]);- if (c != null) {- termBuffer[i] = c;- }- }- return true;- } else {+ if (!input.incrementToken()) {return false;}+ final char[] termBuffer = termAttr.buffer();+ int newLength = termAttr.length();+ for (int from = 0, to = 0, length = newLength; from < length; from++, to++) {+ char c = termBuffer[from];+ if (c == 'ㇷ' && from + 1 < length && termBuffer[from + 1] == '゚') {+ // ㇷ゚detected, replace it by プ.+ termBuffer[to] = 'プ';+ from++;+ newLength--;+ } else {+ Character mappedChar = LETTER_MAPPINGS.get(c);+ termBuffer[to] = mappedChar == null ? c : mappedChar;+ }+ }+ termAttr.setLength(newLength);+ return true;}}diff --git a/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseKatakanaUppercaseFilter.java b/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseKatakanaUppercaseFilter.javaindex 30039305797..fffe62f0ebf 100644--- a/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseKatakanaUppercaseFilter.java+++ b/lucene/analysis/kuromoji/src/test/org/apache/lucene/analysis/ja/TestJapaneseKatakanaUppercaseFilter.java@@ -65,6 +65,7 @@ public class TestJapaneseKatakanaUppercaseFilter extends BaseTokenStreamTestCasenew String[] {"アイウエオカクケシスツトヌハヒフプヘホムヤユヨラリルレロワ"});assertAnalyzesTo(keywordAnalyzer, "ストップウォッチ", new String[] {"ストツプウオツチ"});assertAnalyzesTo(keywordAnalyzer, "サラニㇷ゚ カムイチェㇷ゚ ㇷ゚ㇷ゚", new String[] {"サラニプ", "カムイチエプ", "ププ"});+ assertAnalyzesTo(keywordAnalyzer, "カムイチェㇷ゚カムイチェ", new String[] {"カムイチエプカムイチエ"});}public void testKanaUppercaseWithSurrogatePair() throws IOException {diff --git a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Gener.java b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Gener.javaindex 8b2144d56f1..b66f6f79656 100644--- a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Gener.java+++ b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Gener.java@@ -58,6 +58,7 @@ import java.util.ArrayList;import java.util.Arrays;import java.util.Iterator;import java.util.List;+import org.apache.lucene.util.hppc.ObjectCursor;/*** The Gener object helps in the discarding of nodes which break the reduction effort and defend the@@ -103,8 +104,8 @@ public class Gener extends Reduce {*/public boolean eat(Row in, int[] remap) {int sum = 0;- for (Iterator<Cell> i = in.cells.values().iterator(); i.hasNext(); ) {- Cell c = i.next();+ for (Iterator<ObjectCursor<Cell>> i = in.cells.values().iterator(); i.hasNext(); ) {+ Cell c = i.next().value;sum += c.cnt;if (c.ref >= 0) {if (remap[c.ref] == 0) {@@ -114,8 +115,8 @@ public class Gener extends Reduce {}int frame = sum / 10;boolean live = false;- for (Iterator<Cell> i = in.cells.values().iterator(); i.hasNext(); ) {- Cell c = i.next();+ for (Iterator<ObjectCursor<Cell>> i = in.cells.values().iterator(); i.hasNext(); ) {+ Cell c = i.next().value;if (c.cnt < frame && c.cmd >= 0) {c.cnt = 0;c.cmd = -1;diff --git a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Lift.java b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Lift.javaindex 3e7ee057734..62b2cea821e 100644--- a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Lift.java+++ b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Lift.java@@ -58,6 +58,7 @@ import java.util.ArrayList;import java.util.Arrays;import java.util.Iterator;import java.util.List;+import org.apache.lucene.util.hppc.ObjectCursor;/*** The Lift class is a data structure that is a variation of a Patricia trie.@@ -111,9 +112,9 @@ public class Lift extends Reduce {* @param nodes contains the patch commands*/public void liftUp(Row in, List<Row> nodes) {- Iterator<Cell> i = in.cells.values().iterator();+ Iterator<ObjectCursor<Cell>> i = in.cells.values().iterator();for (; i.hasNext(); ) {- Cell c = i.next();+ Cell c = i.next().value;if (c.ref >= 0) {Row to = nodes.get(c.ref);int sum = to.uniformCmd(changeSkip);diff --git a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Optimizer.java b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Optimizer.javaindex f22d658039d..778e863b01c 100644--- a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Optimizer.java+++ b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Optimizer.java@@ -58,6 +58,7 @@ import java.util.ArrayList;import java.util.Arrays;import java.util.Iterator;import java.util.List;+import org.apache.lucene.util.hppc.CharCursor;/*** The Optimizer class is a Trie that will be reduced (have empty rows removed).@@ -116,10 +117,10 @@ public class Optimizer extends Reduce {* @return the resulting Row, or <code>null</code> if the operation cannot be realized*/public Row merge(Row master, Row existing) {- Iterator<Character> i = master.cells.keySet().iterator();+ Iterator<CharCursor> i = master.cells.keys().iterator();Row n = new Row();for (; i.hasNext(); ) {- Character ch = i.next();+ char ch = i.next().value;// XXX also must handle Cnt and Skip !!Cell a = master.cells.get(ch);Cell b = existing.cells.get(ch);@@ -130,9 +131,9 @@ public class Optimizer extends Reduce {}n.cells.put(ch, s);}- i = existing.cells.keySet().iterator();+ i = existing.cells.keys().iterator();for (; i.hasNext(); ) {- Character ch = i.next();+ char ch = i.next().value;if (master.at(ch) != null) {continue;}diff --git a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Reduce.java b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Reduce.javaindex da6a3c09f7a..ae89e1b81ab 100644--- a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Reduce.java+++ b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Reduce.java@@ -58,6 +58,8 @@ import java.util.ArrayList;import java.util.Arrays;import java.util.Iterator;import java.util.List;+import org.apache.lucene.util.hppc.CharCursor;+import org.apache.lucene.util.hppc.ObjectCursor;/** The Reduce object is used to remove gaps in a Trie which stores a dictionary. */public class Reduce {@@ -88,9 +90,9 @@ public class Reduce {Row now = old.get(ind);to.add(now);- Iterator<Cell> i = now.cells.values().iterator();+ Iterator<ObjectCursor<Cell>> i = now.cells.values().iterator();for (; i.hasNext(); ) {- Cell c = i.next();+ Cell c = i.next().value;if (c.ref >= 0 && remap[c.ref] < 0) {removeGaps(c.ref, old, to, remap);}@@ -109,9 +111,9 @@ public class Reduce {*/public Remap(Row old, int[] remap) {super();- Iterator<Character> i = old.cells.keySet().iterator();+ Iterator<CharCursor> i = old.cells.keys().iterator();for (; i.hasNext(); ) {- Character ch = i.next();+ char ch = i.next().value;Cell c = old.at(ch);Cell nc;if (c.ref >= 0) {diff --git a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Row.java b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Row.javaindex b3615fb6ad3..3c8db8fdbb8 100644--- a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Row.java+++ b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Row.java@@ -59,11 +59,13 @@ import java.io.DataOutput;import java.io.IOException;import java.io.PrintStream;import java.util.Iterator;-import java.util.TreeMap;+import org.apache.lucene.util.hppc.CharCursor;+import org.apache.lucene.util.hppc.CharObjectHashMap;+import org.apache.lucene.util.hppc.ObjectCursor;/** The Row class represents a row in a matrix representation of a trie. */public class Row {- TreeMap<Character, Cell> cells = new TreeMap<>();+ CharObjectHashMap<Cell> cells = new CharObjectHashMap<>();int uniformCnt = 0;int uniformSkip = 0;@@ -98,12 +100,12 @@ public class Row {}/**- * Set the command in the Cell of the given Character to the given integer.+ * Set the command in the Cell of the given character to the given integer.*- * @param way the Character defining the Cell+ * @param way the character defining the Cell* @param cmd the new command*/- public void setCmd(Character way, int cmd) {+ public void setCmd(char way, int cmd) {Cell c = at(way);if (c == null) {c = new Cell();@@ -116,12 +118,12 @@ public class Row {}/**- * Set the reference to the next row in the Cell of the given Character to the given integer.+ * Set the reference to the next row in the Cell of the given character to the given integer.*- * @param way the Character defining the Cell+ * @param way the character defining the Cell* @param ref The new ref value*/- public void setRef(Character way, int ref) {+ public void setRef(char way, int ref) {Cell c = at(way);if (c == null) {c = new Cell();@@ -138,10 +140,10 @@ public class Row {* @return the number of cells in use*/public int getCells() {- Iterator<Character> i = cells.keySet().iterator();+ Iterator<CharCursor> i = cells.keys().iterator();int size = 0;for (; i.hasNext(); ) {- Character c = i.next();+ char c = i.next().value;Cell e = at(c);if (e.cmd >= 0 || e.ref >= 0) {size++;@@ -156,10 +158,10 @@ public class Row {* @return the number of references*/public int getCellsPnt() {- Iterator<Character> i = cells.keySet().iterator();+ Iterator<CharCursor> i = cells.keys().iterator();int size = 0;for (; i.hasNext(); ) {- Character c = i.next();+ char c = i.next().value;Cell e = at(c);if (e.ref >= 0) {size++;@@ -174,10 +176,10 @@ public class Row {* @return the number of patch commands*/public int getCellsVal() {- Iterator<Character> i = cells.keySet().iterator();+ Iterator<CharCursor> i = cells.keys().iterator();int size = 0;for (; i.hasNext(); ) {- Character c = i.next();+ char c = i.next().value;Cell e = at(c);if (e.cmd >= 0) {size++;@@ -187,35 +189,35 @@ public class Row {}/**- * Return the command in the Cell associated with the given Character.+ * Return the command in the Cell associated with the given character.*- * @param way the Character associated with the Cell holding the desired command+ * @param way the character associated with the Cell holding the desired command* @return the command*/- public int getCmd(Character way) {+ public int getCmd(char way) {Cell c = at(way);return (c == null) ? -1 : c.cmd;}/**- * Return the number of patch commands were in the Cell associated with the given Character before+ * Return the number of patch commands were in the Cell associated with the given character before* the Trie containing this Row was reduced.*- * @param way the Character associated with the desired Cell+ * @param way the character associated with the desired Cell* @return the number of patch commands before reduction*/- public int getCnt(Character way) {+ public int getCnt(char way) {Cell c = at(way);return (c == null) ? -1 : c.cnt;}/**- * Return the reference to the next Row in the Cell associated with the given Character.+ * Return the reference to the next Row in the Cell associated with the given character.*- * @param way the Character associated with the desired Cell+ * @param way the character associated with the desired Cell* @return the reference, or -1 if the Cell is <code>null</code>*/- public int getRef(Character way) {+ public int getRef(char way) {Cell c = at(way);return (c == null) ? -1 : c.ref;}@@ -228,15 +230,15 @@ public class Row {*/public void store(DataOutput os) throws IOException {os.writeInt(cells.size());- Iterator<Character> i = cells.keySet().iterator();+ Iterator<CharCursor> i = cells.keys().iterator();for (; i.hasNext(); ) {- Character c = i.next();+ char c = i.next().value;Cell e = at(c);if (e.cmd < 0 && e.ref < 0) {continue;}- os.writeChar(c.charValue());+ os.writeChar(c);os.writeInt(e.cmd);os.writeInt(e.cnt);os.writeInt(e.ref);@@ -251,12 +253,12 @@ public class Row {* @return the number of identical Cells, or -1 if there are (at least) two different cells*/public int uniformCmd(boolean eqSkip) {- Iterator<Cell> i = cells.values().iterator();+ Iterator<ObjectCursor<Cell>> i = cells.values().iterator();int ret = -1;uniformCnt = 1;uniformSkip = 0;for (; i.hasNext(); ) {- Cell c = i.next();+ Cell c = i.next().value;if (c.ref >= 0) {return -1;}@@ -284,15 +286,15 @@ public class Row {/** Write the contents of this Row to the printstream. */public void print(PrintStream out) {- for (Iterator<Character> i = cells.keySet().iterator(); i.hasNext(); ) {- Character ch = i.next();+ for (Iterator<CharCursor> i = cells.keys().iterator(); i.hasNext(); ) {+ char ch = i.next().value;Cell c = at(ch);out.print("[" + ch + ":" + c + "]");}out.println();}- Cell at(Character index) {+ Cell at(char index) {return cells.get(index);}}diff --git a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Trie.java b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Trie.javaindex aef5d189747..b350c64a750 100644--- a/lucene/analysis/stempel/src/java/org/egothor/stemmer/Trie.java+++ b/lucene/analysis/stempel/src/java/org/egothor/stemmer/Trie.java@@ -134,7 +134,7 @@ public class Trie {boolean br = false;for (int i = 0; i < key.length() - 1; i++) {- Character ch = e.next();+ char ch = e.next();w = now.getCmd(ch);if (w >= 0) {int n = w;@@ -227,7 +227,7 @@ public class Trie {Cell c;int cmd = -1;StrEnum e = new StrEnum(key, forward);- Character ch = null;+ char ch;for (int i = 0; i < key.length(); ) {ch = e.next();@@ -272,7 +272,7 @@ public class Trie {StrEnum e = new StrEnum(key, forward);for (int i = 0; i < key.length() - 1; i++) {- Character ch = e.next();+ char ch = e.next();w = now.getCmd(ch);if (w >= 0) {last = cmds.get(w);@@ -343,7 +343,7 @@ public class Trie {StrEnum e = new StrEnum(key, forward);for (int i = 0; i < e.length() - 1; i++) {- Character ch = e.next();+ char ch = e.next();node = r.getRef(ch);if (node >= 0) {r = getRow(node);diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsReader.javaindex 190046e2a3f..1fc1fb3a7fa 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsReader.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsReader.java@@ -281,8 +281,8 @@ public final class Lucene90BlockTreeTermsReader extends FieldsProducer {private static List<String> sortFieldNames(IntObjectHashMap<FieldReader> fieldMap, FieldInfos fieldInfos) {List<String> fieldNames = new ArrayList<>(fieldMap.size());- for (IntCursor fieldNumberCursor : fieldMap.keys()) {- fieldNames.add(fieldInfos.fieldInfo(fieldNumberCursor.value).name);+ for (IntCursor fieldNumber : fieldMap.keys()) {+ fieldNames.add(fieldInfos.fieldInfo(fieldNumber.value).name);}fieldNames.sort(null);return Collections.unmodifiableList(fieldNames);diff --git a/lucene/core/src/java/org/apache/lucene/util/automaton/StateSet.java b/lucene/core/src/java/org/apache/lucene/util/automaton/StateSet.javaindex 5bcf133433f..f21ed0a1d1e 100644--- a/lucene/core/src/java/org/apache/lucene/util/automaton/StateSet.java+++ b/lucene/core/src/java/org/apache/lucene/util/automaton/StateSet.java@@ -95,8 +95,8 @@ final class StateSet extends IntSet {}arrayCache = new int[inner.size()];int i = 0;- for (IntCursor cursor : inner.keys()) {- arrayCache[i++] = cursor.value;+ for (IntCursor key : inner.keys()) {+ arrayCache[i++] = key.value;}// we need to sort this array since "equals" method depend on thisArrays.sort(arrayCache);@@ -115,8 +115,8 @@ final class StateSet extends IntSet {return hashCode;}hashCode = inner.size();- for (IntCursor cursor : inner.keys()) {- hashCode += BitMixer.mix(cursor.value);+ for (IntCursor key : inner.keys()) {+ hashCode += BitMixer.mix(key.value);}hashUpdated = true;return hashCode;diff --git a/lucene/core/src/java/org/apache/lucene/util/hppc/CharCursor.java b/lucene/core/src/java/org/apache/lucene/util/hppc/CharCursor.javanew file mode 100644index 00000000000..6f18a87b0a1--- /dev/null+++ b/lucene/core/src/java/org/apache/lucene/util/hppc/CharCursor.java@@ -0,0 +1,35 @@+/*+ * 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.lucene.util.hppc;++/** Forked from HPPC, holding int index and char value */+public final class CharCursor {+ /**+ * The current value's index in the container this cursor belongs to. The meaning of this index is+ * defined by the container (usually it will be an index in the underlying storage buffer).+ */+ public int index;++ /** The current value. */+ public char value;++ @Override+ public String toString() {+ return "[cursor, index: " + index + ", value: " + value + "]";+ }+}diff --git a/lucene/core/src/java/org/apache/lucene/util/hppc/CharHashSet.java b/lucene/core/src/java/org/apache/lucene/util/hppc/CharHashSet.javanew file mode 100644index 00000000000..c35f87afd8a--- /dev/null+++ b/lucene/core/src/java/org/apache/lucene/util/hppc/CharHashSet.java@@ -0,0 +1,693 @@+/*+ * 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.lucene.util.hppc;++import static org.apache.lucene.util.hppc.HashContainers.DEFAULT_EXPECTED_ELEMENTS;+import static org.apache.lucene.util.hppc.HashContainers.DEFAULT_LOAD_FACTOR;+import static org.apache.lucene.util.hppc.HashContainers.ITERATION_SEED;+import static org.apache.lucene.util.hppc.HashContainers.MAX_LOAD_FACTOR;+import static org.apache.lucene.util.hppc.HashContainers.MIN_LOAD_FACTOR;+import static org.apache.lucene.util.hppc.HashContainers.checkLoadFactor;+import static org.apache.lucene.util.hppc.HashContainers.expandAtCount;+import static org.apache.lucene.util.hppc.HashContainers.iterationIncrement;+import static org.apache.lucene.util.hppc.HashContainers.minBufferSize;+import static org.apache.lucene.util.hppc.HashContainers.nextBufferSize;++import java.util.Arrays;+import java.util.Iterator;+import org.apache.lucene.util.Accountable;+import org.apache.lucene.util.RamUsageEstimator;++/**+ * A hash set of <code>char</code>s, implemented using open addressing with linear probing for+ * collision resolution.+ *+ * <p>Mostly forked and trimmed from com.carrotsearch.hppc.CharHashSet+ *+ * <p>github: https://github.com/carrotsearch/hppc release 0.9.0+ */+public class CharHashSet implements Iterable<CharCursor>, Accountable, Cloneable {++ private static final long BASE_RAM_BYTES_USED =+ RamUsageEstimator.shallowSizeOfInstance(CharHashSet.class);++ private static final char EMPTY_KEY = (char) 0;++ /** The hash array holding keys. */+ public char[] keys;++ /**+ * The number of stored keys (assigned key slots), excluding the special "empty" key, if any.+ *+ * @see #size()+ * @see #hasEmptyKey+ */+ protected int assigned;++ /** Mask for slot scans in {@link #keys}. */+ protected int mask;++ /** Expand (rehash) {@link #keys} when {@link #assigned} hits this value. */+ protected int resizeAt;++ /** Special treatment for the "empty slot" key marker. */+ protected boolean hasEmptyKey;++ /** The load factor for {@link #keys}. */+ protected double loadFactor;++ /** Seed used to ensure the hash iteration order is different from an iteration to another. */+ protected int iterationSeed;++ /** New instance with sane defaults. */+ public CharHashSet() {+ this(DEFAULT_EXPECTED_ELEMENTS);+ }++ /**+ * New instance with sane defaults.+ *+ * @param expectedElements The expected number of elements guaranteed not to cause a rehash+ * (inclusive).+ */+ public CharHashSet(int expectedElements) {+ this(expectedElements, DEFAULT_LOAD_FACTOR);+ }++ /**+ * New instance with the provided defaults.+ *+ * @param expectedElements The expected number of elements guaranteed not to cause a rehash+ * (inclusive).+ * @param loadFactor The load factor for internal buffers. Insane load factors (zero, full+ * capacity) are rejected by {@link #verifyLoadFactor(double)}.+ */+ public CharHashSet(int expectedElements, double loadFactor) {+ this.loadFactor = verifyLoadFactor(loadFactor);+ iterationSeed = ITERATION_SEED.incrementAndGet();+ ensureCapacity(expectedElements);+ }++ /** New instance copying elements from another set. */+ public CharHashSet(CharHashSet set) {+ this(set.size());+ addAll(set);+ }++ public boolean add(char key) {+ if (((key) == 0)) {+ assert ((keys[mask + 1]) == 0);+ boolean added = !hasEmptyKey;+ hasEmptyKey = true;+ return added;+ } else {+ final char[] keys = this.keys;+ final int mask = this.mask;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((key) == (existing))) {+ return false;+ }+ slot = (slot + 1) & mask;+ }++ if (assigned == resizeAt) {+ allocateThenInsertThenRehash(slot, key);+ } else {+ keys[slot] = key;+ }++ assigned++;+ return true;+ }+ }++ /**+ * Adds all elements from the given list (vararg) to this set.+ *+ * @return Returns the number of elements actually added as a result of this call (not previously+ * present in the set).+ */+ public final int addAll(char... elements) {+ ensureCapacity(elements.length);+ int count = 0;+ for (char e : elements) {+ if (add(e)) {+ count++;+ }+ }+ return count;+ }++ /**+ * Adds all elements from the given set to this set.+ *+ * @return Returns the number of elements actually added as a result of this call (not previously+ * present in the set).+ */+ public int addAll(CharHashSet set) {+ ensureCapacity(set.size());+ return addAll((Iterable<? extends CharCursor>) set);+ }++ /**+ * Adds all elements from the given iterable to this set.+ *+ * @return Returns the number of elements actually added as a result of this call (not previously+ * present in the set).+ */+ public int addAll(Iterable<? extends CharCursor> iterable) {+ int count = 0;+ for (CharCursor cursor : iterable) {+ if (add(cursor.value)) {+ count++;+ }+ }+ return count;+ }++ public char[] toArray() {++ final char[] cloned = (new char[size()]);+ int j = 0;+ if (hasEmptyKey) {+ cloned[j++] = EMPTY_KEY;+ }++ final char[] keys = this.keys;+ int seed = nextIterationSeed();+ int inc = iterationIncrement(seed);+ for (int i = 0, mask = this.mask, slot = seed & mask;+ i <= mask;+ i++, slot = (slot + inc) & mask) {+ char existing;+ if (!((existing = keys[slot]) == 0)) {+ cloned[j++] = existing;+ }+ }++ return cloned;+ }++ /** An alias for the (preferred) {@link #removeAll}. */+ public boolean remove(char key) {+ if (((key) == 0)) {+ boolean hadEmptyKey = hasEmptyKey;+ hasEmptyKey = false;+ return hadEmptyKey;+ } else {+ final char[] keys = this.keys;+ final int mask = this.mask;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((key) == (existing))) {+ shiftConflictingKeys(slot);+ return true;+ }+ slot = (slot + 1) & mask;+ }+ return false;+ }+ }++ /**+ * Removes all keys present in a given container.+ *+ * @return Returns the number of elements actually removed as a result of this call.+ */+ public int removeAll(CharHashSet other) {+ final int before = size();++ // Try to iterate over the smaller set or over the container that isn't implementing+ // efficient contains() lookup.++ if (other.size() >= size()) {+ if (hasEmptyKey && other.contains(EMPTY_KEY)) {+ hasEmptyKey = false;+ }++ final char[] keys = this.keys;+ for (int slot = 0, max = this.mask; slot <= max; ) {+ char existing;+ if (!((existing = keys[slot]) == 0) && other.contains(existing)) {+ // Shift, do not increment slot.+ shiftConflictingKeys(slot);+ } else {+ slot++;+ }+ }+ } else {+ for (CharCursor c : other) {+ remove(c.value);+ }+ }++ return before - size();+ }++ public boolean contains(char key) {+ if (((key) == 0)) {+ return hasEmptyKey;+ } else {+ final char[] keys = this.keys;+ final int mask = this.mask;+ int slot = hashKey(key) & mask;+ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((key) == (existing))) {+ return true;+ }+ slot = (slot + 1) & mask;+ }+ return false;+ }+ }++ public void clear() {+ assigned = 0;+ hasEmptyKey = false;+ Arrays.fill(keys, EMPTY_KEY);+ }++ public void release() {+ assigned = 0;+ hasEmptyKey = false;+ keys = null;+ ensureCapacity(DEFAULT_EXPECTED_ELEMENTS);+ }++ public boolean isEmpty() {+ return size() == 0;+ }++ /**+ * Ensure this container can hold at least the given number of elements without resizing its+ * buffers.+ *+ * @param expectedElements The total number of elements, inclusive.+ */+ public void ensureCapacity(int expectedElements) {+ if (expectedElements > resizeAt || keys == null) {+ final char[] prevKeys = this.keys;+ allocateBuffers(minBufferSize(expectedElements, loadFactor));+ if (prevKeys != null && !isEmpty()) {+ rehash(prevKeys);+ }+ }+ }++ public int size() {+ return assigned + (hasEmptyKey ? 1 : 0);+ }++ @Override+ public int hashCode() {+ int h = hasEmptyKey ? 0xDEADBEEF : 0;+ final char[] keys = this.keys;+ for (int slot = mask; slot >= 0; slot--) {+ char existing;+ if (!((existing = keys[slot]) == 0)) {+ h += BitMixer.mix(existing);+ }+ }+ return h;+ }++ @Override+ public boolean equals(Object obj) {+ return (this == obj)+ || (obj != null && getClass() == obj.getClass() && sameKeys(getClass().cast(obj)));+ }++ /** Return true if all keys of some other container exist in this container. */+ private boolean sameKeys(CharHashSet other) {+ if (other.size() != size()) {+ return false;+ }++ for (CharCursor c : other) {+ if (!contains(c.value)) {+ return false;+ }+ }++ return true;+ }++ @Override+ public CharHashSet clone() {+ try {+ /* */+ CharHashSet cloned = (CharHashSet) super.clone();+ cloned.keys = keys.clone();+ cloned.hasEmptyKey = hasEmptyKey;+ cloned.iterationSeed = ITERATION_SEED.incrementAndGet();+ return cloned;+ } catch (CloneNotSupportedException e) {+ throw new RuntimeException(e);+ }+ }++ @Override+ public Iterator<CharCursor> iterator() {+ return new EntryIterator();+ }++ @Override+ public long ramBytesUsed() {+ return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(keys);+ }++ /**+ * Provides the next iteration seed used to build the iteration starting slot and offset+ * increment. This method does not need to be synchronized, what matters is that each thread gets+ * a sequence of varying seeds.+ */+ protected int nextIterationSeed() {+ return iterationSeed = BitMixer.mixPhi(iterationSeed);+ }++ /** An iterator implementation for {@link #iterator}. */+ protected final class EntryIterator extends AbstractIterator<CharCursor> {+ private final CharCursor cursor;+ private final int increment;+ private int index;+ private int slot;++ public EntryIterator() {+ cursor = new CharCursor();+ int seed = nextIterationSeed();+ increment = iterationIncrement(seed);+ slot = seed & mask;+ }++ @Override+ protected CharCursor fetch() {+ final int mask = CharHashSet.this.mask;+ while (index <= mask) {+ char existing;+ index++;+ slot = (slot + increment) & mask;+ if (!((existing = keys[slot]) == 0)) {+ cursor.index = slot;+ cursor.value = existing;+ return cursor;+ }+ }++ if (index == mask + 1 && hasEmptyKey) {+ cursor.index = index++;+ cursor.value = EMPTY_KEY;+ return cursor;+ }++ return done();+ }+ }++ /**+ * Create a set from a variable number of arguments or an array of <code>char</code>. The elements+ * are copied from the argument to the internal buffer.+ */+ /* */+ public static CharHashSet from(char... elements) {+ final CharHashSet set = new CharHashSet(elements.length);+ set.addAll(elements);+ return set;+ }++ /**+ * Returns a hash code for the given key.+ *+ * <p>The output from this function should evenly distribute keys across the entire integer range.+ */+ protected int hashKey(char key) {+ assert !((key) == 0); // Handled as a special case (empty slot marker).+ return BitMixer.mixPhi(key);+ }++ /**+ * Returns a logical "index" of a given key that can be used to speed up follow-up logic in+ * certain scenarios (conditional logic).+ *+ * <p>The semantics of "indexes" are not strictly defined. Indexes may (and typically won't be)+ * contiguous.+ *+ * <p>The index is valid only between modifications (it will not be affected by read-only+ * operations).+ *+ * @see #indexExists+ * @see #indexGet+ * @see #indexInsert+ * @see #indexReplace+ * @param key The key to locate in the set.+ * @return A non-negative value of the logical "index" of the key in the set or a negative value+ * if the key did not exist.+ */+ public int indexOf(char key) {+ final int mask = this.mask;+ if (((key) == 0)) {+ return hasEmptyKey ? mask + 1 : ~(mask + 1);+ } else {+ final char[] keys = this.keys;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((key) == (existing))) {+ return slot;+ }+ slot = (slot + 1) & mask;+ }++ return ~slot;+ }+ }++ /**+ * @see #indexOf+ * @param index The index of a given key, as returned from {@link #indexOf}.+ * @return Returns <code>true</code> if the index corresponds to an existing key or false+ * otherwise. This is equivalent to checking whether the index is a positive value (existing+ * keys) or a negative value (non-existing keys).+ */+ public boolean indexExists(int index) {+ assert index < 0 || index <= mask || (index == mask + 1 && hasEmptyKey);++ return index >= 0;+ }++ /**+ * Returns the exact value of the existing key. This method makes sense for sets of objects which+ * define custom key-equality relationship.+ *+ * @see #indexOf+ * @param index The index of an existing key.+ * @return Returns the equivalent key currently stored in the set.+ * @throws AssertionError If assertions are enabled and the index does not correspond to an+ * existing key.+ */+ public char indexGet(int index) {+ assert index >= 0 : "The index must point at an existing key.";+ assert index <= mask || (index == mask + 1 && hasEmptyKey);++ return keys[index];+ }++ /**+ * Replaces the existing equivalent key with the given one and returns any previous value stored+ * for that key.+ *+ * @see #indexOf+ * @param index The index of an existing key.+ * @param equivalentKey The key to put in the set as a replacement. Must be equivalent to the key+ * currently stored at the provided index.+ * @return Returns the previous key stored in the set.+ * @throws AssertionError If assertions are enabled and the index does not correspond to an+ * existing key.+ */+ public char indexReplace(int index, char equivalentKey) {+ assert index >= 0 : "The index must point at an existing key.";+ assert index <= mask || (index == mask + 1 && hasEmptyKey);+ assert ((keys[index]) == (equivalentKey));++ char previousValue = keys[index];+ keys[index] = equivalentKey;+ return previousValue;+ }++ /**+ * Inserts a key for an index that is not present in the set. This method may help in avoiding+ * double recalculation of the key's hash.+ *+ * @see #indexOf+ * @param index The index of a previously non-existing key, as returned from {@link #indexOf}.+ * @throws AssertionError If assertions are enabled and the index does not correspond to an+ * existing key.+ */+ public void indexInsert(int index, char key) {+ assert index < 0 : "The index must not point at an existing key.";++ index = ~index;+ if (((key) == 0)) {+ assert index == mask + 1;+ assert ((keys[index]) == 0);+ hasEmptyKey = true;+ } else {+ assert ((keys[index]) == 0);++ if (assigned == resizeAt) {+ allocateThenInsertThenRehash(index, key);+ } else {+ keys[index] = key;+ }++ assigned++;+ }+ }++ /**+ * Removes a key at an index previously acquired from {@link #indexOf}.+ *+ * @see #indexOf+ * @param index The index of the key to remove, as returned from {@link #indexOf}.+ * @throws AssertionError If assertions are enabled and the index does not correspond to an+ * existing key.+ */+ public void indexRemove(int index) {+ assert index >= 0 : "The index must point at an existing key.";+ assert index <= mask || (index == mask + 1 && hasEmptyKey);++ if (index > mask) {+ hasEmptyKey = false;+ } else {+ shiftConflictingKeys(index);+ }+ }++ /**+ * Validate load factor range and return it. Override and suppress if you need insane load+ * factors.+ */+ protected double verifyLoadFactor(double loadFactor) {+ checkLoadFactor(loadFactor, MIN_LOAD_FACTOR, MAX_LOAD_FACTOR);+ return loadFactor;+ }++ /** Rehash from old buffers to new buffers. */+ protected void rehash(char[] fromKeys) {+ assert HashContainers.checkPowerOfTwo(fromKeys.length - 1);++ // Rehash all stored keys into the new buffers.+ final char[] keys = this.keys;+ final int mask = this.mask;+ char existing;+ for (int i = fromKeys.length - 1; --i >= 0; ) {+ if (!((existing = fromKeys[i]) == 0)) {+ int slot = hashKey(existing) & mask;+ while (!((keys[slot]) == 0)) {+ slot = (slot + 1) & mask;+ }+ keys[slot] = existing;+ }+ }+ }++ /**+ * Allocate new internal buffers. This method attempts to allocate and assign internal buffers+ * atomically (either allocations succeed or not).+ */+ protected void allocateBuffers(int arraySize) {+ assert Integer.bitCount(arraySize) == 1;++ // Ensure no change is done if we hit an OOM.+ char[] prevKeys = this.keys;+ try {+ int emptyElementSlot = 1;+ this.keys = (new char[arraySize + emptyElementSlot]);+ } catch (OutOfMemoryError e) {+ this.keys = prevKeys;+ throw new BufferAllocationException(+ "Not enough memory to allocate buffers for rehashing: %,d -> %,d",+ e, this.keys == null ? 0 : size(), arraySize);+ }++ this.resizeAt = expandAtCount(arraySize, loadFactor);+ this.mask = arraySize - 1;+ }++ /**+ * This method is invoked when there is a new key to be inserted into the buffer but there is not+ * enough empty slots to do so.+ *+ * <p>New buffers are allocated. If this succeeds, we know we can proceed with rehashing so we+ * assign the pending element to the previous buffer (possibly violating the invariant of having+ * at least one empty slot) and rehash all keys, substituting new buffers at the end.+ */+ protected void allocateThenInsertThenRehash(int slot, char pendingKey) {+ assert assigned == resizeAt && ((keys[slot]) == 0) && !((pendingKey) == 0);++ // Try to allocate new buffers first. If we OOM, we leave in a consistent state.+ final char[] prevKeys = this.keys;+ allocateBuffers(nextBufferSize(mask + 1, size(), loadFactor));+ assert this.keys.length > prevKeys.length;++ // We have succeeded at allocating new data so insert the pending key/value at+ // the free slot in the old arrays before rehashing.+ prevKeys[slot] = pendingKey;++ // Rehash old keys, including the pending key.+ rehash(prevKeys);+ }++ /** Shift all the slot-conflicting keys allocated to (and including) <code>slot</code>. */+ protected void shiftConflictingKeys(int gapSlot) {+ final char[] keys = this.keys;+ final int mask = this.mask;++ // Perform shifts of conflicting keys to fill in the gap.+ int distance = 0;+ while (true) {+ final int slot = (gapSlot + (++distance)) & mask;+ final char existing = keys[slot];+ if (((existing) == 0)) {+ break;+ }++ final int idealSlot = hashKey(existing);+ final int shift = (slot - idealSlot) & mask;+ if (shift >= distance) {+ // Entry at this position was originally at or before the gap slot.+ // Move the conflict-shifted entry to the gap's position and repeat the procedure+ // for any entries to the right of the current position, treating it+ // as the new gap.+ keys[gapSlot] = existing;+ gapSlot = slot;+ distance = 0;+ }+ }++ // Mark the last found gap slot without a conflict as empty.+ keys[gapSlot] = EMPTY_KEY;+ assigned--;+ }+}diff --git a/lucene/core/src/java/org/apache/lucene/util/hppc/CharObjectHashMap.java b/lucene/core/src/java/org/apache/lucene/util/hppc/CharObjectHashMap.javanew file mode 100644index 00000000000..6db9e4affb1--- /dev/null+++ b/lucene/core/src/java/org/apache/lucene/util/hppc/CharObjectHashMap.java@@ -0,0 +1,827 @@+/*+ * 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.lucene.util.hppc;++import static org.apache.lucene.util.hppc.HashContainers.DEFAULT_EXPECTED_ELEMENTS;+import static org.apache.lucene.util.hppc.HashContainers.DEFAULT_LOAD_FACTOR;+import static org.apache.lucene.util.hppc.HashContainers.ITERATION_SEED;+import static org.apache.lucene.util.hppc.HashContainers.MAX_LOAD_FACTOR;+import static org.apache.lucene.util.hppc.HashContainers.MIN_LOAD_FACTOR;+import static org.apache.lucene.util.hppc.HashContainers.checkLoadFactor;+import static org.apache.lucene.util.hppc.HashContainers.checkPowerOfTwo;+import static org.apache.lucene.util.hppc.HashContainers.expandAtCount;+import static org.apache.lucene.util.hppc.HashContainers.iterationIncrement;+import static org.apache.lucene.util.hppc.HashContainers.minBufferSize;+import static org.apache.lucene.util.hppc.HashContainers.nextBufferSize;++import java.util.Arrays;+import java.util.Iterator;+import org.apache.lucene.util.Accountable;+import org.apache.lucene.util.RamUsageEstimator;++/**+ * A hash map of <code>char</code> to <code>Object</code>, implemented using open addressing with+ * linear probing for collision resolution. Supports null values.+ *+ * <p>Mostly forked and trimmed from com.carrotsearch.hppc.CharObjectHashMap+ *+ * <p>github: https://github.com/carrotsearch/hppc release 0.9.0+ */+@SuppressWarnings("unchecked")+public class CharObjectHashMap<VType>+ implements Iterable<CharObjectHashMap.CharObjectCursor<VType>>, Accountable, Cloneable {++ private static final long BASE_RAM_BYTES_USED =+ RamUsageEstimator.shallowSizeOfInstance(CharObjectHashMap.class);++ private static final char EMPTY_KEY = (char) 0;++ /** The array holding keys. */+ public char[] keys;++ /** The array holding values. */+ public Object[] values;++ /**+ * The number of stored keys (assigned key slots), excluding the special "empty" key, if any (use+ * {@link #size()} instead).+ *+ * @see #size()+ */+ protected int assigned;++ /** Mask for slot scans in {@link #keys}. */+ protected int mask;++ /** Expand (rehash) {@link #keys} when {@link #assigned} hits this value. */+ protected int resizeAt;++ /** Special treatment for the "empty slot" key marker. */+ protected boolean hasEmptyKey;++ /** The load factor for {@link #keys}. */+ protected double loadFactor;++ /** Seed used to ensure the hash iteration order is different from an iteration to another. */+ protected int iterationSeed;++ /** New instance with sane defaults. */+ public CharObjectHashMap() {+ this(DEFAULT_EXPECTED_ELEMENTS);+ }++ /**+ * New instance with sane defaults.+ *+ * @param expectedElements The expected number of elements guaranteed not to cause buffer+ * expansion (inclusive).+ */+ public CharObjectHashMap(int expectedElements) {+ this(expectedElements, DEFAULT_LOAD_FACTOR);+ }++ /**+ * New instance with the provided defaults.+ *+ * @param expectedElements The expected number of elements guaranteed not to cause a rehash+ * (inclusive).+ * @param loadFactor The load factor for internal buffers. Insane load factors (zero, full+ * capacity) are rejected by {@link #verifyLoadFactor(double)}.+ */+ public CharObjectHashMap(int expectedElements, double loadFactor) {+ this.loadFactor = verifyLoadFactor(loadFactor);+ iterationSeed = ITERATION_SEED.incrementAndGet();+ ensureCapacity(expectedElements);+ }++ /** Create a hash map from all key-value pairs of another map. */+ public CharObjectHashMap(CharObjectHashMap<VType> map) {+ this(map.size());+ putAll(map);+ }++ public VType put(char key, VType value) {+ assert assigned < mask + 1;++ final int mask = this.mask;+ if (((key) == 0)) {+ VType previousValue = hasEmptyKey ? (VType) values[mask + 1] : null;+ hasEmptyKey = true;+ values[mask + 1] = value;+ return previousValue;+ } else {+ final char[] keys = this.keys;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((existing) == (key))) {+ final VType previousValue = (VType) values[slot];+ values[slot] = value;+ return previousValue;+ }+ slot = (slot + 1) & mask;+ }++ if (assigned == resizeAt) {+ allocateThenInsertThenRehash(slot, key, value);+ } else {+ keys[slot] = key;+ values[slot] = value;+ }++ assigned++;+ return null;+ }+ }++ public int putAll(Iterable<? extends CharObjectCursor<? extends VType>> iterable) {+ final int count = size();+ for (CharObjectCursor<? extends VType> c : iterable) {+ put(c.key, c.value);+ }+ return size() - count;+ }++ /**+ * <a href="http://trove4j.sourceforge.net">Trove</a>-inspired API method. An equivalent of the+ * following code:+ *+ * <pre>+ * if (!map.containsKey(key)) map.put(value);+ * </pre>+ *+ * @param key The key of the value to check.+ * @param value The value to put if <code>key</code> does not exist.+ * @return <code>true</code> if <code>key</code> did not exist and <code>value</code> was placed+ * in the map.+ */+ public boolean putIfAbsent(char key, VType value) {+ int keyIndex = indexOf(key);+ if (!indexExists(keyIndex)) {+ indexInsert(keyIndex, key, value);+ return true;+ } else {+ return false;+ }+ }++ public VType remove(char key) {+ final int mask = this.mask;+ if (((key) == 0)) {+ if (!hasEmptyKey) {+ return null;+ }+ hasEmptyKey = false;+ VType previousValue = (VType) values[mask + 1];+ values[mask + 1] = 0;+ return previousValue;+ } else {+ final char[] keys = this.keys;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((existing) == (key))) {+ final VType previousValue = (VType) values[slot];+ shiftConflictingKeys(slot);+ return previousValue;+ }+ slot = (slot + 1) & mask;+ }++ return null;+ }+ }++ public VType get(char key) {+ if (((key) == 0)) {+ return hasEmptyKey ? (VType) values[mask + 1] : null;+ } else {+ final char[] keys = this.keys;+ final int mask = this.mask;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((existing) == (key))) {+ return (VType) values[slot];+ }+ slot = (slot + 1) & mask;+ }++ return null;+ }+ }++ public VType getOrDefault(char key, VType defaultValue) {+ if (((key) == 0)) {+ return hasEmptyKey ? (VType) values[mask + 1] : defaultValue;+ } else {+ final char[] keys = this.keys;+ final int mask = this.mask;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((existing) == (key))) {+ return (VType) values[slot];+ }+ slot = (slot + 1) & mask;+ }++ return defaultValue;+ }+ }++ public boolean containsKey(char key) {+ if (((key) == 0)) {+ return hasEmptyKey;+ } else {+ final char[] keys = this.keys;+ final int mask = this.mask;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((existing) == (key))) {+ return true;+ }+ slot = (slot + 1) & mask;+ }++ return false;+ }+ }++ public int indexOf(char key) {+ final int mask = this.mask;+ if (((key) == 0)) {+ return hasEmptyKey ? mask + 1 : ~(mask + 1);+ } else {+ final char[] keys = this.keys;+ int slot = hashKey(key) & mask;++ char existing;+ while (!((existing = keys[slot]) == 0)) {+ if (((existing) == (key))) {+ return slot;+ }+ slot = (slot + 1) & mask;+ }++ return ~slot;+ }+ }++ public boolean indexExists(int index) {+ assert index < 0 || (index >= 0 && index <= mask) || (index == mask + 1 && hasEmptyKey);++ return index >= 0;+ }++ public VType indexGet(int index) {+ assert index >= 0 : "The index must point at an existing key.";+ assert index <= mask || (index == mask + 1 && hasEmptyKey);++ return (VType) values[index];+ }++ public VType indexReplace(int index, VType newValue) {+ assert index >= 0 : "The index must point at an existing key.";+ assert index <= mask || (index == mask + 1 && hasEmptyKey);++ VType previousValue = (VType) values[index];+ values[index] = newValue;+ return previousValue;+ }++ public void indexInsert(int index, char key, VType value) {+ assert index < 0 : "The index must not point at an existing key.";++ index = ~index;+ if (((key) == 0)) {+ assert index == mask + 1;+ values[index] = value;+ hasEmptyKey = true;+ } else {+ assert ((keys[index]) == 0);++ if (assigned == resizeAt) {+ allocateThenInsertThenRehash(index, key, value);+ } else {+ keys[index] = key;+ values[index] = value;+ }++ assigned++;+ }+ }++ public VType indexRemove(int index) {+ assert index >= 0 : "The index must point at an existing key.";+ assert index <= mask || (index == mask + 1 && hasEmptyKey);++ VType previousValue = (VType) values[index];+ if (index > mask) {+ assert index == mask + 1;+ hasEmptyKey = false;+ values[index] = 0;+ } else {+ shiftConflictingKeys(index);+ }+ return previousValue;+ }++ public void clear() {+ assigned = 0;+ hasEmptyKey = false;++ Arrays.fill(keys, EMPTY_KEY);++ /* */+ }++ public void release() {+ assigned = 0;+ hasEmptyKey = false;++ keys = null;+ values = null;+ ensureCapacity(DEFAULT_EXPECTED_ELEMENTS);+ }++ public int size() {+ return assigned + (hasEmptyKey ? 1 : 0);+ }++ public boolean isEmpty() {+ return size() == 0;+ }++ @Override+ public int hashCode() {+ int h = hasEmptyKey ? 0xDEADBEEF : 0;+ for (CharObjectCursor<VType> c : this) {+ h += BitMixer.mix(c.key) + BitMixer.mix(c.value);+ }+ return h;+ }++ @Override+ public boolean equals(Object obj) {+ return (this == obj)+ || (obj != null && getClass() == obj.getClass() && equalElements(getClass().cast(obj)));+ }++ /** Return true if all keys of some other container exist in this container. */+ protected boolean equalElements(CharObjectHashMap<?> other) {+ if (other.size() != size()) {+ return false;+ }++ for (CharObjectCursor<?> c : other) {+ char key = c.key;+ if (!containsKey(key) || !java.util.Objects.equals(c.value, get(key))) {+ return false;+ }+ }++ return true;+ }++ /**+ * Ensure this container can hold at least the given number of keys (entries) without resizing its+ * buffers.+ *+ * @param expectedElements The total number of keys, inclusive.+ */+ public void ensureCapacity(int expectedElements) {+ if (expectedElements > resizeAt || keys == null) {+ final char[] prevKeys = this.keys;+ final VType[] prevValues = (VType[]) this.values;+ allocateBuffers(minBufferSize(expectedElements, loadFactor));+ if (prevKeys != null && !isEmpty()) {+ rehash(prevKeys, prevValues);+ }+ }+ }++ /**+ * Provides the next iteration seed used to build the iteration starting slot and offset+ * increment. This method does not need to be synchronized, what matters is that each thread gets+ * a sequence of varying seeds.+ */+ protected int nextIterationSeed() {+ return iterationSeed = BitMixer.mixPhi(iterationSeed);+ }++ @Override+ public Iterator<CharObjectCursor<VType>> iterator() {+ return new EntryIterator();+ }++ @Override+ public long ramBytesUsed() {+ return BASE_RAM_BYTES_USED + RamUsageEstimator.sizeOf(keys) + sizeOfValues();+ }++ private long sizeOfValues() {+ long size = RamUsageEstimator.shallowSizeOf(values);+ for (ObjectCursor<VType> value : values()) {+ size += RamUsageEstimator.sizeOfObject(value);+ }+ return size;+ }++ /** An iterator implementation for {@link #iterator}. */+ private final class EntryIterator extends AbstractIterator<CharObjectCursor<VType>> {+ private final CharObjectCursor<VType> cursor;+ private final int increment;+ private int index;+ private int slot;++ public EntryIterator() {+ cursor = new CharObjectCursor<VType>();+ int seed = nextIterationSeed();+ increment = iterationIncrement(seed);+ slot = seed & mask;+ }++ @Override+ protected CharObjectCursor<VType> fetch() {+ final int mask = CharObjectHashMap.this.mask;+ while (index <= mask) {+ char existing;+ index++;+ slot = (slot + increment) & mask;+ if (!((existing = keys[slot]) == 0)) {+ cursor.index = slot;+ cursor.key = existing;+ cursor.value = (VType) values[slot];+ return cursor;+ }+ }++ if (index == mask + 1 && hasEmptyKey) {+ cursor.index = index;+ cursor.key = 0;+ cursor.value = (VType) values[index++];+ return cursor;+ }++ return done();+ }+ }++ /** Returns a specialized view of the keys of this associated container. */+ public KeysContainer keys() {+ return new KeysContainer();+ }++ /** A view of the keys inside this hash map. */+ public final class KeysContainer implements Iterable<CharCursor> {++ @Override+ public Iterator<CharCursor> iterator() {+ return new KeysIterator();+ }++ public int size() {+ return CharObjectHashMap.this.size();+ }++ public char[] toArray() {+ char[] array = new char[size()];+ int i = 0;+ for (CharCursor cursor : this) {+ array[i++] = cursor.value;+ }+ return array;+ }+ }++ /** An iterator over the set of assigned keys. */+ private final class KeysIterator extends AbstractIterator<CharCursor> {+ private final CharCursor cursor;+ private final int increment;+ private int index;+ private int slot;++ public KeysIterator() {+ cursor = new CharCursor();+ int seed = nextIterationSeed();+ increment = iterationIncrement(seed);+ slot = seed & mask;+ }++ @Override+ protected CharCursor fetch() {+ final int mask = CharObjectHashMap.this.mask;+ while (index <= mask) {+ char existing;+ index++;+ slot = (slot + increment) & mask;+ if (!((existing = keys[slot]) == 0)) {+ cursor.index = slot;+ cursor.value = existing;+ return cursor;+ }+ }++ if (index == mask + 1 && hasEmptyKey) {+ cursor.index = index++;+ cursor.value = 0;+ return cursor;+ }++ return done();+ }+ }++ /**+ * @return Returns a container with all values stored in this map.+ */+ public ValuesContainer values() {+ return new ValuesContainer();+ }++ /** A view over the set of values of this map. */+ public final class ValuesContainer implements Iterable<ObjectCursor<VType>> {++ @Override+ public Iterator<ObjectCursor<VType>> iterator() {+ return new ValuesIterator();+ }++ public int size() {+ return CharObjectHashMap.this.size();+ }++ public VType[] toArray() {+ VType[] array = (VType[]) new Object[size()];+ int i = 0;+ for (ObjectCursor<VType> cursor : this) {+ array[i++] = cursor.value;+ }+ return array;+ }+ }++ /** An iterator over the set of assigned values. */+ private final class ValuesIterator extends AbstractIterator<ObjectCursor<VType>> {+ private final ObjectCursor<VType> cursor;+ private final int increment;+ private int index;+ private int slot;++ public ValuesIterator() {+ cursor = new ObjectCursor<>();+ int seed = nextIterationSeed();+ increment = iterationIncrement(seed);+ slot = seed & mask;+ }++ @Override+ protected ObjectCursor<VType> fetch() {+ final int mask = CharObjectHashMap.this.mask;+ while (index <= mask) {+ index++;+ slot = (slot + increment) & mask;+ if (!((keys[slot]) == 0)) {+ cursor.index = slot;+ cursor.value = (VType) values[slot];+ return cursor;+ }+ }++ if (index == mask + 1 && hasEmptyKey) {+ cursor.index = index;+ cursor.value = (VType) values[index++];+ return cursor;+ }++ return done();+ }+ }++ @Override+ public CharObjectHashMap<VType> clone() {+ try {+ /* */+ CharObjectHashMap<VType> cloned = (CharObjectHashMap<VType>) super.clone();+ cloned.keys = keys.clone();+ cloned.values = values.clone();+ cloned.hasEmptyKey = hasEmptyKey;+ cloned.iterationSeed = ITERATION_SEED.incrementAndGet();+ return cloned;+ } catch (CloneNotSupportedException e) {+ throw new RuntimeException(e);+ }+ }++ /** Convert the contents of this map to a human-friendly string. */+ @Override+ public String toString() {+ final StringBuilder buffer = new StringBuilder();+ buffer.append("[");++ boolean first = true;+ for (CharObjectCursor<VType> cursor : this) {+ if (!first) {+ buffer.append(", ");+ }+ buffer.append(cursor.key);+ buffer.append("=>");+ buffer.append(cursor.value);+ first = false;+ }+ buffer.append("]");+ return buffer.toString();+ }++ /** Creates a hash map from two index-aligned arrays of key-value pairs. */+ public static <VType> CharObjectHashMap<VType> from(char[] keys, VType[] values) {+ if (keys.length != values.length) {+ throw new IllegalArgumentException(+ "Arrays of keys and values must have an identical length.");+ }++ CharObjectHashMap<VType> map = new CharObjectHashMap<>(keys.length);+ for (int i = 0; i < keys.length; i++) {+ map.put(keys[i], values[i]);+ }++ return map;+ }++ /**+ * Returns a hash code for the given key.+ *+ * <p>The output from this function should evenly distribute keys across the entire integer range.+ */+ protected int hashKey(char key) {+ assert !((key) == 0); // Handled as a special case (empty slot marker).+ return BitMixer.mixPhi(key);+ }++ /**+ * Validate load factor range and return it. Override and suppress if you need insane load+ * factors.+ */+ protected double verifyLoadFactor(double loadFactor) {+ checkLoadFactor(loadFactor, MIN_LOAD_FACTOR, MAX_LOAD_FACTOR);+ return loadFactor;+ }++ /** Rehash from old buffers to new buffers. */+ protected void rehash(char[] fromKeys, VType[] fromValues) {+ assert fromKeys.length == fromValues.length && checkPowerOfTwo(fromKeys.length - 1);++ // Rehash all stored key/value pairs into the new buffers.+ final char[] keys = this.keys;+ final VType[] values = (VType[]) this.values;+ final int mask = this.mask;+ char existing;++ // Copy the zero element's slot, then rehash everything else.+ int from = fromKeys.length - 1;+ keys[keys.length - 1] = fromKeys[from];+ values[values.length - 1] = fromValues[from];+ while (--from >= 0) {+ if (!((existing = fromKeys[from]) == 0)) {+ int slot = hashKey(existing) & mask;+ while (!((keys[slot]) == 0)) {+ slot = (slot + 1) & mask;+ }+ keys[slot] = existing;+ values[slot] = fromValues[from];+ }+ }+ }++ /**+ * Allocate new internal buffers. This method attempts to allocate and assign internal buffers+ * atomically (either allocations succeed or not).+ */+ protected void allocateBuffers(int arraySize) {+ assert Integer.bitCount(arraySize) == 1;++ // Ensure no change is done if we hit an OOM.+ char[] prevKeys = this.keys;+ VType[] prevValues = (VType[]) this.values;+ try {+ int emptyElementSlot = 1;+ this.keys = (new char[arraySize + emptyElementSlot]);+ this.values = new Object[arraySize + emptyElementSlot];+ } catch (OutOfMemoryError e) {+ this.keys = prevKeys;+ this.values = prevValues;+ throw new BufferAllocationException(+ "Not enough memory to allocate buffers for rehashing: %,d -> %,d",+ e, this.mask + 1, arraySize);+ }++ this.resizeAt = expandAtCount(arraySize, loadFactor);+ this.mask = arraySize - 1;+ }++ /**+ * This method is invoked when there is a new key/ value pair to be inserted into the buffers but+ * there is not enough empty slots to do so.+ *+ * <p>New buffers are allocated. If this succeeds, we know we can proceed with rehashing so we+ * assign the pending element to the previous buffer (possibly violating the invariant of having+ * at least one empty slot) and rehash all keys, substituting new buffers at the end.+ */+ protected void allocateThenInsertThenRehash(int slot, char pendingKey, VType pendingValue) {+ assert assigned == resizeAt && ((keys[slot]) == 0) && !((pendingKey) == 0);++ // Try to allocate new buffers first. If we OOM, we leave in a consistent state.+ final char[] prevKeys = this.keys;+ final VType[] prevValues = (VType[]) this.values;+ allocateBuffers(nextBufferSize(mask + 1, size(), loadFactor));+ assert this.keys.length > prevKeys.length;++ // We have succeeded at allocating new data so insert the pending key/value at+ // the free slot in the old arrays before rehashing.+ prevKeys[slot] = pendingKey;+ prevValues[slot] = pendingValue;++ // Rehash old keys, including the pending key.+ rehash(prevKeys, prevValues);+ }++ /**+ * Shift all the slot-conflicting keys and values allocated to (and including) <code>slot</code>.+ */+ protected void shiftConflictingKeys(int gapSlot) {+ final char[] keys = this.keys;+ final VType[] values = (VType[]) this.values;+ final int mask = this.mask;++ // Perform shifts of conflicting keys to fill in the gap.+ int distance = 0;+ while (true) {+ final int slot = (gapSlot + (++distance)) & mask;+ final char existing = keys[slot];+ if (((existing) == 0)) {+ break;+ }++ final int idealSlot = hashKey(existing);+ final int shift = (slot - idealSlot) & mask;+ if (shift >= distance) {+ // Entry at this position was originally at or before the gap slot.+ // Move the conflict-shifted entry to the gap's position and repeat the procedure+ // for any entries to the right of the current position, treating it+ // as the new gap.+ keys[gapSlot] = existing;+ values[gapSlot] = values[slot];+ gapSlot = slot;+ distance = 0;+ }+ }++ // Mark the last found gap slot without a conflict as empty.+ keys[gapSlot] = 0;+ values[gapSlot] = null;+ assigned--;+ }++ /** Forked from HPPC, holding int index,key and value */+ public static final class CharObjectCursor<VType> {+ /**+ * The current key and value's index in the container this cursor belongs to. The meaning of+ * this index is defined by the container (usually it will be an index in the underlying storage+ * buffer).+ */+ public int index;++ /** The current key. */+ public char key;++ /** The current value. */+ public VType value;++ @Override+ public String toString() {+ return "[cursor, index: " + index + ", key: " + key + ", value: " + value + "]";+ }+ }+}diff --git a/lucene/core/src/java/org/apache/lucene/util/hppc/HashContainers.java b/lucene/core/src/java/org/apache/lucene/util/hppc/HashContainers.javaindex 08fef9f9606..7859c457eb9 100644--- a/lucene/core/src/java/org/apache/lucene/util/hppc/HashContainers.java+++ b/lucene/core/src/java/org/apache/lucene/util/hppc/HashContainers.java@@ -22,26 +22,26 @@ import static org.apache.lucene.util.BitUtil.nextHighestPowerOfTwo;import java.util.concurrent.atomic.AtomicInteger;/** Constants for primitive maps. */-public class HashContainers {+class HashContainers {- public static final int DEFAULT_EXPECTED_ELEMENTS = 4;+ static final int DEFAULT_EXPECTED_ELEMENTS = 4;- public static final float DEFAULT_LOAD_FACTOR = 0.75f;+ static final float DEFAULT_LOAD_FACTOR = 0.75f;/** Minimal sane load factor (99 empty slots per 100). */- public static final float MIN_LOAD_FACTOR = 1 / 100.0f;+ static final float MIN_LOAD_FACTOR = 1 / 100.0f;/** Maximum sane load factor (1 empty slot per 100). */- public static final float MAX_LOAD_FACTOR = 99 / 100.0f;+ static final float MAX_LOAD_FACTOR = 99 / 100.0f;/** Minimum hash buffer size. */- public static final int MIN_HASH_ARRAY_LENGTH = 4;+ static final int MIN_HASH_ARRAY_LENGTH = 4;/*** Maximum array size for hash containers (power-of-two and still allocable in Java, not a* negative int).*/- public static final int MAX_HASH_ARRAY_LENGTH = 0x80000000 >>> 1;+ static final int MAX_HASH_ARRAY_LENGTH = 0x80000000 >>> 1;static final AtomicInteger ITERATION_SEED = new AtomicInteger();diff --git a/lucene/core/src/java/org/apache/lucene/util/hppc/IntHashSet.java b/lucene/core/src/java/org/apache/lucene/util/hppc/IntHashSet.javaindex c2d72930a93..2b2213a9242 100644--- a/lucene/core/src/java/org/apache/lucene/util/hppc/IntHashSet.java+++ b/lucene/core/src/java/org/apache/lucene/util/hppc/IntHashSet.java@@ -152,6 +152,17 @@ public class IntHashSet implements Iterable<IntCursor>, Accountable, Cloneable {return count;}+ /**+ * Adds all elements from the given set to this set.+ *+ * @return Returns the number of elements actually added as a result of this call (not previously+ * present in the set).+ */+ public int addAll(IntHashSet set) {+ ensureCapacity(set.size());+ return addAll((Iterable<? extends IntCursor>) set);+ }+/*** Adds all elements from the given iterable to this set.*diff --git a/lucene/core/src/java/org/apache/lucene/util/hppc/LongHashSet.java b/lucene/core/src/java/org/apache/lucene/util/hppc/LongHashSet.javaindex d131bfc7386..696c96083f5 100644--- a/lucene/core/src/java/org/apache/lucene/util/hppc/LongHashSet.java+++ b/lucene/core/src/java/org/apache/lucene/util/hppc/LongHashSet.java@@ -145,6 +145,17 @@ public class LongHashSet implements Iterable<LongCursor>, Accountable, Cloneablereturn count;}+ /**+ * Adds all elements from the given set to this set.+ *+ * @return Returns the number of elements actually added as a result of this call (not previously+ * present in the set).+ */+ public int addAll(LongHashSet set) {+ ensureCapacity(set.size());+ return addAll((Iterable<? extends LongCursor>) set);+ }+/*** Adds all elements from the given iterable to this set.*diff --git a/lucene/core/src/test/org/apache/lucene/util/hppc/TestCharHashSet.java b/lucene/core/src/test/org/apache/lucene/util/hppc/TestCharHashSet.javanew file mode 100644index 00000000000..b98c7c854db--- /dev/null+++ b/lucene/core/src/test/org/apache/lucene/util/hppc/TestCharHashSet.java@@ -0,0 +1,473 @@+/*+ * 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.lucene.util.hppc;++import static org.hamcrest.Matchers.empty;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.greaterThanOrEqualTo;+import static org.hamcrest.Matchers.is;+import static org.hamcrest.Matchers.lessThan;+import static org.hamcrest.Matchers.not;++import com.carrotsearch.randomizedtesting.RandomizedTest;+import java.util.Arrays;+import java.util.HashSet;+import java.util.Random;+import java.util.Set;+import java.util.concurrent.atomic.AtomicInteger;+import org.apache.lucene.tests.util.LuceneTestCase;+import org.hamcrest.MatcherAssert;+import org.junit.Before;+import org.junit.Test;++/**+ * Tests for {@link CharHashSet}.+ *+ * <p>Mostly forked and trimmed from com.carrotsearch.hppc.CharHashSetTest+ *+ * <p>github: https://github.com/carrotsearch/hppc release: 0.9.0+ */+public class TestCharHashSet extends LuceneTestCase {+ private static final char EMPTY_KEY = (char) 0;++ private final char keyE = 0;+ private final char key1 = cast(1);+ private final char key2 = cast(2);+ private final char key3 = cast(3);+ private final char key4 = cast(4);++ /** Per-test fresh initialized instance. */+ private CharHashSet set;++ /** Convert to target type from an integer used to test stuff. */+ private static char cast(int v) {+ return (char) ('a' + v);+ }++ @Before+ public void initialize() {+ set = new CharHashSet();+ }++ @Test+ public void testAddAllViaInterface() {+ set.addAll(key1, key2);++ CharHashSet iface = new CharHashSet();+ iface.clear();+ iface.addAll(set);+ MatcherAssert.assertThat(set(iface.toArray()), is(equalTo(set(key1, key2))));+ }++ @Test+ public void testIndexMethods() {+ set.add(keyE);+ set.add(key1);++ MatcherAssert.assertThat(set.indexOf(keyE), is(greaterThanOrEqualTo(0)));+ MatcherAssert.assertThat(set.indexOf(key1), is(greaterThanOrEqualTo(0)));+ MatcherAssert.assertThat(set.indexOf(key2), is(lessThan(0)));++ MatcherAssert.assertThat(set.indexExists(set.indexOf(keyE)), is(true));+ MatcherAssert.assertThat(set.indexExists(set.indexOf(key1)), is(true));+ MatcherAssert.assertThat(set.indexExists(set.indexOf(key2)), is(false));++ MatcherAssert.assertThat(set.indexGet(set.indexOf(keyE)), is(equalTo(keyE)));+ MatcherAssert.assertThat(set.indexGet(set.indexOf(key1)), is(equalTo(key1)));++ expectThrows(+ AssertionError.class,+ () -> {+ set.indexGet(set.indexOf(key2));+ });++ MatcherAssert.assertThat(set.indexReplace(set.indexOf(keyE), keyE), is(equalTo(keyE)));+ MatcherAssert.assertThat(set.indexReplace(set.indexOf(key1), key1), is(equalTo(key1)));++ set.indexInsert(set.indexOf(key2), key2);+ MatcherAssert.assertThat(set.indexGet(set.indexOf(key2)), is(equalTo(key2)));+ MatcherAssert.assertThat(set.size(), is(equalTo(3)));++ set.indexRemove(set.indexOf(keyE));+ MatcherAssert.assertThat(set.size(), is(equalTo(2)));+ set.indexRemove(set.indexOf(key2));+ MatcherAssert.assertThat(set.size(), is(equalTo(1)));+ MatcherAssert.assertThat(set.indexOf(keyE), is(lessThan(0)));+ MatcherAssert.assertThat(set.indexOf(key1), is(greaterThanOrEqualTo(0)));+ MatcherAssert.assertThat(set.indexOf(key2), is(lessThan(0)));+ }++ @Test+ public void testCursorIndexIsValid() {+ set.add(keyE);+ set.add(key1);+ set.add(key2);++ for (CharCursor c : set) {+ MatcherAssert.assertThat(set.indexExists(c.index), is(true));+ MatcherAssert.assertThat(set.indexGet(c.index), is(equalTo(c.value)));+ }+ }++ @Test+ public void testEmptyKey() {+ CharHashSet set = new CharHashSet();++ boolean b = set.add(EMPTY_KEY);++ MatcherAssert.assertThat(b, is(true));+ MatcherAssert.assertThat(set.add(EMPTY_KEY), is(false));+ MatcherAssert.assertThat(set.size(), is(equalTo(1)));+ MatcherAssert.assertThat(set.isEmpty(), is(false));+ MatcherAssert.assertThat(set(set.toArray()), is(equalTo(set(EMPTY_KEY))));+ MatcherAssert.assertThat(set.contains(EMPTY_KEY), is(true));+ int index = set.indexOf(EMPTY_KEY);+ MatcherAssert.assertThat(set.indexExists(index), is(true));+ MatcherAssert.assertThat(set.indexGet(index), is(equalTo(EMPTY_KEY)));+ MatcherAssert.assertThat(set.indexReplace(index, EMPTY_KEY), is(equalTo(EMPTY_KEY)));++ if (random().nextBoolean()) {+ b = set.remove(EMPTY_KEY);+ MatcherAssert.assertThat(b, is(true));+ } else {+ set.indexRemove(index);+ }++ MatcherAssert.assertThat(set.size(), is(equalTo(0)));+ MatcherAssert.assertThat(set.isEmpty(), is(true));+ MatcherAssert.assertThat(set(set.toArray()), is(empty()));+ MatcherAssert.assertThat(set.contains(EMPTY_KEY), is(false));+ index = set.indexOf(EMPTY_KEY);+ MatcherAssert.assertThat(set.indexExists(index), is(false));++ set.indexInsert(index, EMPTY_KEY);+ set.add(key1);+ MatcherAssert.assertThat(set.size(), is(equalTo(2)));+ MatcherAssert.assertThat(set.contains(EMPTY_KEY), is(true));+ index = set.indexOf(EMPTY_KEY);+ MatcherAssert.assertThat(set.indexExists(index), is(true));+ MatcherAssert.assertThat(set.indexGet(index), is(equalTo(EMPTY_KEY)));+ }++ @Test+ public void testEnsureCapacity() {+ final AtomicInteger expands = new AtomicInteger();+ CharHashSet set =+ new CharHashSet(0) {+ @Override+ protected void allocateBuffers(int arraySize) {+ super.allocateBuffers(arraySize);+ expands.incrementAndGet();+ }+ };++ // Add some elements.+ final int max = rarely() ? 0 : randomIntBetween(0, 250);+ for (int i = 0; i < max; i++) {+ set.add(cast(i));+ }++ final int additions = randomIntBetween(max, max + 5000);+ set.ensureCapacity(additions + set.size());+ final int before = expands.get();+ for (int i = 0; i < additions; i++) {+ set.add(cast(i));+ }+ assertEquals(before, expands.get());+ }++ @Test+ public void testInitiallyEmpty() {+ assertEquals(0, set.size());+ }++ @Test+ public void testAdd() {+ assertTrue(set.add(key1));+ assertFalse(set.add(key1));+ assertEquals(1, set.size());+ }++ @Test+ public void testAdd2() {+ set.addAll(key1, key1);+ assertEquals(1, set.size());+ assertEquals(1, set.addAll(key1, key2));+ assertEquals(2, set.size());+ }++ @Test+ public void testAddVarArgs() {+ set.addAll(asArray(0, 1, 2, 1, 0));+ assertEquals(3, set.size());+ assertSortedListEquals(set.toArray(), asArray(0, 1, 2));+ }++ @Test+ public void testAddAll() {+ CharHashSet set2 = new CharHashSet();+ set2.addAll(asArray(1, 2));+ set.addAll(asArray(0, 1));++ assertEquals(1, set.addAll(set2));+ assertEquals(0, set.addAll(set2));++ assertEquals(3, set.size());+ assertSortedListEquals(set.toArray(), asArray(0, 1, 2));+ }++ @Test+ public void testRemove() {+ set.addAll(asArray(0, 1, 2, 3, 4));++ assertTrue(set.remove(key2));+ assertFalse(set.remove(key2));+ assertEquals(4, set.size());+ assertSortedListEquals(set.toArray(), asArray(0, 1, 3, 4));+ }++ @Test+ public void testInitialCapacityAndGrowth() {+ for (int i = 0; i < 256; i++) {+ CharHashSet set = new CharHashSet(i);++ for (int j = 0; j < i; j++) {+ set.add(cast(j));+ }++ assertEquals(i, set.size());+ }+ }++ @Test+ public void testBug_HPPC73_FullCapacityGet() {+ final AtomicInteger reallocations = new AtomicInteger();+ final int elements = 0x7F;+ set =+ new CharHashSet(elements, 1f) {+ @Override+ protected double verifyLoadFactor(double loadFactor) {+ // Skip load factor sanity range checking.+ return loadFactor;+ }++ @Override+ protected void allocateBuffers(int arraySize) {+ super.allocateBuffers(arraySize);+ reallocations.incrementAndGet();+ }+ };++ int reallocationsBefore = reallocations.get();+ assertEquals(reallocationsBefore, 1);+ for (int i = 1; i <= elements; i++) {+ set.add(cast(i));+ }++ // Non-existent key.+ char outOfSet = cast(elements + 1);+ set.remove(outOfSet);+ assertFalse(set.contains(outOfSet));+ assertEquals(reallocationsBefore, reallocations.get());++ // Should not expand because we're replacing an existing element.+ assertFalse(set.add(key1));+ assertEquals(reallocationsBefore, reallocations.get());++ // Remove from a full set.+ set.remove(key1);+ assertEquals(reallocationsBefore, reallocations.get());+ set.add(key1);++ // Check expand on "last slot of a full map" condition.+ set.add(outOfSet);+ assertEquals(reallocationsBefore + 1, reallocations.get());+ }++ @Test+ public void testRemoveAllFromLookupContainer() {+ set.addAll(asArray(0, 1, 2, 3, 4));++ CharHashSet list2 = new CharHashSet();+ list2.addAll(asArray(1, 3, 5));++ assertEquals(2, set.removeAll(list2));+ assertEquals(3, set.size());+ assertSortedListEquals(set.toArray(), asArray(0, 2, 4));+ }++ @Test+ public void testClear() {+ set.addAll(asArray(1, 2, 3));+ set.clear();+ assertEquals(0, set.size());+ }++ @Test+ public void testRelease() {+ set.addAll(asArray(1, 2, 3));+ set.release();+ assertEquals(0, set.size());+ set.addAll(asArray(1, 2, 3));+ assertEquals(3, set.size());+ }++ @Test+ public void testIterable() {+ set.addAll(asArray(1, 2, 2, 3, 4));+ set.remove(key2);+ assertEquals(3, set.size());++ int count = 0;+ for (CharCursor cursor : set) {+ count++;+ assertTrue(set.contains(cursor.value));+ }+ assertEquals(count, set.size());++ set.clear();+ assertFalse(set.iterator().hasNext());+ }++ /** Runs random insertions/deletions/clearing and compares the results against {@link HashSet}. */+ @Test+ @SuppressWarnings({"rawtypes", "unchecked"})+ public void testAgainstHashSet() {+ final Random rnd = RandomizedTest.getRandom();+ final HashSet other = new HashSet();++ for (int size = 1000; size < 20000; size += 4000) {+ other.clear();+ set.clear();++ for (int round = 0; round < size * 20; round++) {+ char key = cast(rnd.nextInt(size));+ if (rnd.nextInt(50) == 0) {+ key = EMPTY_KEY;+ }++ if (rnd.nextBoolean()) {+ if (rnd.nextBoolean()) {+ int index = set.indexOf(key);+ if (set.indexExists(index)) {+ set.indexReplace(index, key);+ } else {+ set.indexInsert(index, key);+ }+ } else {+ set.add(key);+ }+ other.add(key);++ assertTrue(set.contains(key));+ assertTrue(set.indexExists(set.indexOf(key)));+ } else {+ assertEquals(other.contains(key), set.contains(key));+ boolean removed;+ if (set.contains(key) && rnd.nextBoolean()) {+ set.indexRemove(set.indexOf(key));+ removed = true;+ } else {+ removed = set.remove(key);+ }+ assertEquals(other.remove(key), removed);+ }++ assertEquals(other.size(), set.size());+ }+ }+ }++ @Test+ public void testHashCodeEquals() {+ CharHashSet l0 = new CharHashSet();+ assertEquals(0, l0.hashCode());+ assertEquals(l0, new CharHashSet());++ CharHashSet l1 = CharHashSet.from(key1, key2, key3);+ CharHashSet l2 = CharHashSet.from(key1, key2);+ l2.add(key3);++ assertEquals(l1.hashCode(), l2.hashCode());+ assertEquals(l1, l2);+ }++ @Test+ public void testClone() {+ this.set.addAll(asArray(1, 2, 3));++ CharHashSet cloned = set.clone();+ cloned.remove(key1);++ assertSortedListEquals(set.toArray(), asArray(1, 2, 3));+ assertSortedListEquals(cloned.toArray(), asArray(2, 3));+ }++ @Test+ public void testEqualsSameClass() {+ CharHashSet l1 = CharHashSet.from(key1, key2, key3);+ CharHashSet l2 = CharHashSet.from(key1, key2, key3);+ CharHashSet l3 = CharHashSet.from(key1, key2, key4);++ MatcherAssert.assertThat(l1, is(equalTo(l2)));+ MatcherAssert.assertThat(l1.hashCode(), is(equalTo(l2.hashCode())));+ MatcherAssert.assertThat(l1, is(not(equalTo(l3))));+ }++ @Test+ public void testEqualsSubClass() {+ class Sub extends CharHashSet {}+ ;++ CharHashSet l1 = CharHashSet.from(key1, key2, key3);+ CharHashSet l2 = new Sub();+ CharHashSet l3 = new Sub();+ l2.addAll(l1);+ l3.addAll(l1);++ MatcherAssert.assertThat(l2, is(equalTo(l3)));+ MatcherAssert.assertThat(l1, is(not(equalTo(l2))));+ }++ private static int randomIntBetween(int min, int max) {+ return min + random().nextInt(max + 1 - min);+ }++ private static Set<Character> set(char... elements) {+ Set<Character> set = new HashSet<>();+ for (char element : elements) {+ set.add(element);+ }+ return set;+ }++ private static char[] asArray(int... elements) {+ char[] result = new char[elements.length];+ for (int i = 0; i < elements.length; i++) {+ result[i] = cast(elements[i]);+ }+ return result;+ }++ /** Check if the array's content is identical to a given sequence of elements. */+ private static void assertSortedListEquals(char[] array, char[] elements) {+ assertEquals(elements.length, array.length);+ Arrays.sort(array);+ assertArrayEquals(elements, array);+ }+}diff --git a/lucene/core/src/test/org/apache/lucene/util/hppc/TestCharObjectHashMap.java b/lucene/core/src/test/org/apache/lucene/util/hppc/TestCharObjectHashMap.javanew file mode 100644index 00000000000..1a3e58f51a4--- /dev/null+++ b/lucene/core/src/test/org/apache/lucene/util/hppc/TestCharObjectHashMap.java@@ -0,0 +1,671 @@+/*+ * 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.lucene.util.hppc;++import com.carrotsearch.randomizedtesting.RandomizedTest;+import java.util.Arrays;+import java.util.HashMap;+import java.util.HashSet;+import java.util.Random;+import java.util.concurrent.atomic.AtomicInteger;+import org.apache.lucene.tests.util.LuceneTestCase;+import org.junit.After;+import org.junit.Test;++/**+ * Tests for {@link CharObjectHashMap}.+ *+ * <p>Mostly forked and trimmed from com.carrotsearch.hppc.CharObjectHashMapTest+ *+ * <p>github: https://github.com/carrotsearch/hppc release: 0.9.0+ */+@SuppressWarnings({"rawtypes", "unchecked"})+public class TestCharObjectHashMap extends LuceneTestCase {+ /* Ready to use key values. */++ private final char keyE = 0;+ private final char key1 = cast(1);+ private final char key2 = cast(2);+ private final char key3 = cast(3);+ private final char key4 = cast(4);++ /** Convert to target type from an integer used to test stuff. */+ private char cast(int v) {+ return (char) ('a' + v);+ }++ /** Create a new array of a given type and copy the arguments to this array. */+ private char[] newArray(char... elements) {+ return elements;+ }++ private static int randomIntBetween(int min, int max) {+ return min + random().nextInt(max + 1 - min);+ }++ /** Check if the array's content is identical to a given sequence of elements. */+ private static void assertSortedListEquals(char[] array, char... elements) {+ assertEquals(elements.length, array.length);+ Arrays.sort(array);+ Arrays.sort(elements);+ assertArrayEquals(elements, array);+ }++ /** Check if the array's content is identical to a given sequence of elements. */+ private static void assertSortedListEquals(Object[] array, Object... elements) {+ assertEquals(elements.length, array.length);+ Arrays.sort(array);+ assertArrayEquals(elements, array);+ }++ private final int value0 = vcast(0);+ private final int value1 = vcast(1);+ private final int value2 = vcast(2);+ private final int value3 = vcast(3);+ private final int value4 = vcast(4);++ /** Per-test fresh initialized instance. */+ private CharObjectHashMap<Object> map = newInstance();++ private CharObjectHashMap newInstance() {+ return new CharObjectHashMap();+ }++ @After+ public void checkEmptySlotsUninitialized() {+ if (map != null) {+ int occupied = 0;+ for (int i = 0; i <= map.mask; i++) {+ if (((map.keys[i]) == 0)) {++ } else {+ occupied++;+ }+ }+ assertEquals(occupied, map.assigned);++ if (!map.hasEmptyKey) {}+ }+ }++ /** Convert to target type from an integer used to test stuff. */+ private int vcast(int value) {+ return value;+ }++ /** Create a new array of a given type and copy the arguments to this array. */+ /* */+ private Object[] newvArray(Object... elements) {+ return elements;+ }++ private void assertSameMap(+ final CharObjectHashMap<Object> c1, final CharObjectHashMap<Object> c2) {+ assertEquals(c1.size(), c2.size());++ for (CharObjectHashMap.CharObjectCursor entry : c1) {+ assertTrue(c2.containsKey(entry.key));+ assertEquals(entry.value, c2.get(entry.key));+ }+ }++ /* */+ @Test+ public void testEnsureCapacity() {+ final AtomicInteger expands = new AtomicInteger();+ CharObjectHashMap map =+ new CharObjectHashMap(0) {+ @Override+ protected void allocateBuffers(int arraySize) {+ super.allocateBuffers(arraySize);+ expands.incrementAndGet();+ }+ };++ // Add some elements.+ final int max = rarely() ? 0 : randomIntBetween(0, 250);+ for (int i = 0; i < max; i++) {+ map.put(cast(i), value0);+ }++ final int additions = randomIntBetween(max, max + 5000);+ map.ensureCapacity(additions + map.size());+ final int before = expands.get();+ for (int i = 0; i < additions; i++) {+ map.put(cast(i), value0);+ }+ assertEquals(before, expands.get());+ }++ @Test+ public void testCursorIndexIsValid() {+ map.put(keyE, value1);+ map.put(key1, value2);+ map.put(key2, value3);++ for (CharObjectHashMap.CharObjectCursor c : map) {+ assertTrue(map.indexExists(c.index));+ assertEquals(c.value, map.indexGet(c.index));+ }+ }++ @Test+ public void testIndexMethods() {+ map.put(keyE, value1);+ map.put(key1, value2);++ assertTrue(map.indexOf(keyE) >= 0);+ assertTrue(map.indexOf(key1) >= 0);+ assertTrue(map.indexOf(key2) < 0);++ assertTrue(map.indexExists(map.indexOf(keyE)));+ assertTrue(map.indexExists(map.indexOf(key1)));+ assertFalse(map.indexExists(map.indexOf(key2)));++ assertEquals(value1, map.indexGet(map.indexOf(keyE)));+ assertEquals(value2, map.indexGet(map.indexOf(key1)));++ expectThrows(+ AssertionError.class,+ () -> {+ map.indexGet(map.indexOf(key2));+ });++ assertEquals(value1, map.indexReplace(map.indexOf(keyE), value3));+ assertEquals(value2, map.indexReplace(map.indexOf(key1), value4));+ assertEquals(value3, map.indexGet(map.indexOf(keyE)));+ assertEquals(value4, map.indexGet(map.indexOf(key1)));++ map.indexInsert(map.indexOf(key2), key2, value1);+ assertEquals(value1, map.indexGet(map.indexOf(key2)));+ assertEquals(3, map.size());++ assertEquals(value3, map.indexRemove(map.indexOf(keyE)));+ assertEquals(2, map.size());+ assertEquals(value1, map.indexRemove(map.indexOf(key2)));+ assertEquals(1, map.size());+ assertTrue(map.indexOf(keyE) < 0);+ assertTrue(map.indexOf(key1) >= 0);+ assertTrue(map.indexOf(key2) < 0);+ }++ /* */+ @Test+ public void testCloningConstructor() {+ map.put(key1, value1);+ map.put(key2, value2);+ map.put(key3, value3);++ assertSameMap(map, new CharObjectHashMap(map));+ }++ /* */+ @Test+ public void testFromArrays() {+ map.put(key1, value1);+ map.put(key2, value2);+ map.put(key3, value3);++ CharObjectHashMap map2 =+ CharObjectHashMap.from(newArray(key1, key2, key3), newvArray(value1, value2, value3));++ assertSameMap(map, map2);+ }++ @Test+ public void testGetOrDefault() {+ map.put(key2, value2);+ assertTrue(map.containsKey(key2));++ map.put(key1, value1);+ assertEquals(value1, map.getOrDefault(key1, value3));+ assertEquals(value3, map.getOrDefault(key3, value3));+ map.remove(key1);+ assertEquals(value3, map.getOrDefault(key1, value3));+ }++ /* */+ @Test+ public void testPut() {+ map.put(key1, value1);++ assertTrue(map.containsKey(key1));+ assertEquals(value1, map.get(key1));+ }++ /* */+ @Test+ public void testNullValue() {+ map.put(key1, null);++ assertTrue(map.containsKey(key1));+ assertNull(map.get(key1));+ }++ @Test+ public void testPutOverExistingKey() {+ map.put(key1, value1);+ assertEquals(value1, map.put(key1, value3));+ assertEquals(value3, map.get(key1));++ assertEquals(value3, map.put(key1, null));+ assertTrue(map.containsKey(key1));+ assertNull(map.get(key1));++ assertNull(map.put(key1, value1));+ assertEquals(value1, map.get(key1));+ }++ /* */+ @Test+ public void testPutWithExpansions() {+ final int COUNT = 10000;+ final Random rnd = new Random(random().nextLong());+ final HashSet<Object> values = new HashSet<Object>();++ for (int i = 0; i < COUNT; i++) {+ final int v = rnd.nextInt();+ final boolean hadKey = values.contains(cast(v));+ values.add(cast(v));++ assertEquals(hadKey, map.containsKey(cast(v)));+ map.put(cast(v), vcast(v));+ assertEquals(values.size(), map.size());+ }+ assertEquals(values.size(), map.size());+ }++ /* */+ @Test+ public void testPutAll() {+ map.put(key1, value1);+ map.put(key2, value1);++ CharObjectHashMap map2 = newInstance();++ map2.put(key2, value2);+ map2.put(keyE, value1);++ // One new key (keyE).+ assertEquals(1, map.putAll(map2));++ // Assert the value under key2 has been replaced.+ assertEquals(value2, map.get(key2));++ // And key3 has been added.+ assertEquals(value1, map.get(keyE));+ assertEquals(3, map.size());+ }++ /* */+ @Test+ public void testPutIfAbsent() {+ assertTrue(map.putIfAbsent(key1, value1));+ assertFalse(map.putIfAbsent(key1, value2));+ assertEquals(value1, map.get(key1));+ }++ /* */+ @Test+ public void testRemove() {+ map.put(key1, value1);+ assertEquals(value1, map.remove(key1));+ assertEquals(null, map.remove(key1));+ assertEquals(0, map.size());++ // These are internals, but perhaps worth asserting too.+ assertEquals(0, map.assigned);+ }++ /* */+ @Test+ public void testEmptyKey() {+ final char empty = 0;++ map.put(empty, value1);+ assertEquals(1, map.size());+ assertEquals(false, map.isEmpty());+ assertEquals(value1, map.get(empty));+ assertEquals(value1, map.getOrDefault(empty, value2));+ assertEquals(true, map.iterator().hasNext());+ assertEquals(empty, map.iterator().next().key);+ assertEquals(value1, map.iterator().next().value);++ map.remove(empty);+ assertEquals(null, map.get(empty));+ assertEquals(0, map.size());++ map.put(empty, null);+ assertEquals(1, map.size());+ assertTrue(map.containsKey(empty));+ assertNull(map.get(empty));++ map.remove(empty);+ assertEquals(0, map.size());+ assertFalse(map.containsKey(empty));+ assertNull(map.get(empty));++ assertEquals(null, map.put(empty, value1));+ assertEquals(value1, map.put(empty, value2));+ map.clear();+ assertFalse(map.indexExists(map.indexOf(empty)));+ assertEquals(null, map.put(empty, value1));+ map.clear();+ assertEquals(null, map.remove(empty));+ }++ /* */+ @Test+ public void testMapKeySet() {+ map.put(key1, value3);+ map.put(key2, value2);+ map.put(key3, value1);++ assertSortedListEquals(map.keys().toArray(), key1, key2, key3);+ }++ /* */+ @Test+ public void testMapKeySetIterator() {+ map.put(key1, value3);+ map.put(key2, value2);+ map.put(key3, value1);++ int counted = 0;+ for (CharCursor c : map.keys()) {+ assertEquals(map.keys[c.index], c.value);+ counted++;+ }+ assertEquals(counted, map.size());+ }++ /* */+ @Test+ public void testClear() {+ map.put(key1, value1);+ map.put(key2, value1);+ map.clear();+ assertEquals(0, map.size());++ // These are internals, but perhaps worth asserting too.+ assertEquals(0, map.assigned);++ // Check values are cleared.+ assertEquals(null, map.put(key1, value1));+ assertEquals(null, map.remove(key2));+ map.clear();++ // Check if the map behaves properly upon subsequent use.+ testPutWithExpansions();+ }++ /* */+ @Test+ public void testRelease() {+ map.put(key1, value1);+ map.put(key2, value1);+ map.release();+ assertEquals(0, map.size());++ // These are internals, but perhaps worth asserting too.+ assertEquals(0, map.assigned);++ // Check if the map behaves properly upon subsequent use.+ testPutWithExpansions();+ }++ /* */+ @Test+ public void testIterable() {+ map.put(key1, value1);+ map.put(key2, value2);+ map.put(key3, value3);+ map.remove(key2);++ int count = 0;+ for (CharObjectHashMap.CharObjectCursor cursor : map) {+ count++;+ assertTrue(map.containsKey(cursor.key));+ assertEquals(cursor.value, map.get(cursor.key));++ assertEquals(cursor.value, map.values[cursor.index]);+ assertEquals(cursor.key, map.keys[cursor.index]);+ }+ assertEquals(count, map.size());++ map.clear();+ assertFalse(map.iterator().hasNext());+ }++ /* */+ @Test+ public void testBug_HPPC73_FullCapacityGet() {+ final AtomicInteger reallocations = new AtomicInteger();+ final int elements = 0x7F;+ map =+ new CharObjectHashMap(elements, 1f) {+ @Override+ protected double verifyLoadFactor(double loadFactor) {+ // Skip load factor sanity range checking.+ return loadFactor;+ }++ @Override+ protected void allocateBuffers(int arraySize) {+ super.allocateBuffers(arraySize);+ reallocations.incrementAndGet();+ }+ };++ int reallocationsBefore = reallocations.get();+ assertEquals(reallocationsBefore, 1);+ for (int i = 1; i <= elements; i++) {+ map.put(cast(i), value1);+ }++ // Non-existent key.+ char outOfSet = cast(elements + 1);+ map.remove(outOfSet);+ assertFalse(map.containsKey(outOfSet));+ assertEquals(reallocationsBefore, reallocations.get());++ // Should not expand because we're replacing an existing element.+ map.put(key1, value2);+ assertEquals(reallocationsBefore, reallocations.get());++ // Remove from a full map.+ map.remove(key1);+ assertEquals(reallocationsBefore, reallocations.get());+ map.put(key1, value2);++ // Check expand on "last slot of a full map" condition.+ map.put(outOfSet, value1);+ assertEquals(reallocationsBefore + 1, reallocations.get());+ }++ @Test+ public void testHashCodeEquals() {+ CharObjectHashMap l0 = newInstance();+ assertEquals(0, l0.hashCode());+ assertEquals(l0, newInstance());++ CharObjectHashMap l1 =+ CharObjectHashMap.from(newArray(key1, key2, key3), newvArray(value1, value2, value3));++ CharObjectHashMap l2 =+ CharObjectHashMap.from(newArray(key2, key1, key3), newvArray(value2, value1, value3));++ CharObjectHashMap l3 = CharObjectHashMap.from(newArray(key1, key2), newvArray(value2, value1));++ assertEquals(l1.hashCode(), l2.hashCode());+ assertEquals(l1, l2);++ assertFalse(l1.equals(l3));+ assertFalse(l2.equals(l3));+ }++ @Test+ public void testBug_HPPC37() {+ CharObjectHashMap l1 = CharObjectHashMap.from(newArray(key1), newvArray(value1));++ CharObjectHashMap l2 = CharObjectHashMap.from(newArray(key2), newvArray(value1));++ assertFalse(l1.equals(l2));+ assertFalse(l2.equals(l1));+ }++ /** Runs random insertions/deletions/clearing and compares the results against {@link HashMap}. */+ @Test+ @SuppressWarnings({"rawtypes", "unchecked"})+ public void testAgainstHashMap() {+ final Random rnd = RandomizedTest.getRandom();+ final HashMap other = new HashMap();++ for (int size = 1000; size < 20000; size += 4000) {+ other.clear();+ map.clear();++ for (int round = 0; round < size * 20; round++) {+ char key = cast(rnd.nextInt(size));+ if (rnd.nextInt(50) == 0) {+ key = 0;+ }++ int value = vcast(rnd.nextInt());++ if (rnd.nextBoolean()) {+ Object previousValue;+ if (rnd.nextBoolean()) {+ int index = map.indexOf(key);+ if (map.indexExists(index)) {+ previousValue = map.indexReplace(index, value);+ } else {+ map.indexInsert(index, key, value);+ previousValue = null;+ }+ } else {+ previousValue = map.put(key, value);+ }+ assertEquals(other.put(key, value), previousValue);++ assertEquals(value, map.get(key));+ assertEquals(value, map.indexGet(map.indexOf(key)));+ assertTrue(map.containsKey(key));+ assertTrue(map.indexExists(map.indexOf(key)));+ } else {+ assertEquals(other.containsKey(key), map.containsKey(key));+ Object previousValue =+ map.containsKey(key) && rnd.nextBoolean()+ ? map.indexRemove(map.indexOf(key))+ : map.remove(key);+ assertEquals(other.remove(key), previousValue);+ }++ assertEquals(other.size(), map.size());+ }+ }+ }++ /*+ *+ */+ @Test+ public void testClone() {+ this.map.put(key1, value1);+ this.map.put(key2, value2);+ this.map.put(key3, value3);++ CharObjectHashMap cloned = map.clone();+ cloned.remove(key1);++ assertSortedListEquals(map.keys().toArray(), key1, key2, key3);+ assertSortedListEquals(cloned.keys().toArray(), key2, key3);+ }++ /* */+ @Test+ public void testMapValues() {+ map.put(key1, value3);+ map.put(key2, value2);+ map.put(key3, value1);+ assertSortedListEquals(map.values().toArray(), value1, value2, value3);++ map.clear();+ map.put(key1, value1);+ map.put(key2, value2);+ map.put(key3, value2);+ assertSortedListEquals(map.values().toArray(), value1, value2, value2);+ }++ /* */+ @Test+ public void testMapValuesIterator() {+ map.put(key1, value3);+ map.put(key2, value2);+ map.put(key3, value1);++ int counted = 0;+ for (ObjectCursor c : map.values()) {+ assertEquals(map.values[c.index], c.value);+ counted++;+ }+ assertEquals(counted, map.size());+ }++ /* */+ @Test+ public void testEqualsSameClass() {+ CharObjectHashMap l1 = newInstance();+ l1.put(key1, value0);+ l1.put(key2, value1);+ l1.put(key3, value2);++ CharObjectHashMap l2 = new CharObjectHashMap(l1);+ l2.putAll(l1);++ CharObjectHashMap l3 = new CharObjectHashMap(l2);+ l3.putAll(l2);+ l3.put(key4, value0);++ assertEquals(l2, l1);+ assertEquals(l2.hashCode(), l1.hashCode());+ assertNotEquals(l1, l3);+ }++ /* */+ @Test+ public void testEqualsSubClass() {+ class Sub extends CharObjectHashMap {}++ CharObjectHashMap l1 = newInstance();+ l1.put(key1, value0);+ l1.put(key2, value1);+ l1.put(key3, value2);++ CharObjectHashMap l2 = new Sub();+ l2.putAll(l1);+ l2.put(key4, value3);++ CharObjectHashMap l3 = new Sub();+ l3.putAll(l2);++ assertNotEquals(l1, l2);+ assertEquals(l3.hashCode(), l2.hashCode());+ assertEquals(l3, l2);+ }+}diff --git a/lucene/core/src/test/org/apache/lucene/util/hppc/TestIntHashSet.java b/lucene/core/src/test/org/apache/lucene/util/hppc/TestIntHashSet.javaindex b911e0d8a4f..2e76b18a6bc 100644--- a/lucene/core/src/test/org/apache/lucene/util/hppc/TestIntHashSet.java+++ b/lucene/core/src/test/org/apache/lucene/util/hppc/TestIntHashSet.java@@ -215,7 +215,7 @@ public class TestIntHashSet extends LuceneTestCase {public void testAddVarArgs() {set.addAll(asArray(0, 1, 2, 1, 0));assertEquals(3, set.size());- assertSortedListEquals(set.toArray(), 0, 1, 2);+ assertSortedListEquals(set.toArray(), asArray(0, 1, 2));}@Test@@ -228,7 +228,7 @@ public class TestIntHashSet extends LuceneTestCase {assertEquals(0, set.addAll(set2));assertEquals(3, set.size());- assertSortedListEquals(set.toArray(), 0, 1, 2);+ assertSortedListEquals(set.toArray(), asArray(0, 1, 2));}@Test@@ -238,7 +238,7 @@ public class TestIntHashSet extends LuceneTestCase {assertTrue(set.remove(key2));assertFalse(set.remove(key2));assertEquals(4, set.size());- assertSortedListEquals(set.toArray(), 0, 1, 3, 4);+ assertSortedListEquals(set.toArray(), asArray(0, 1, 3, 4));}@Test@@ -308,7 +308,7 @@ public class TestIntHashSet extends LuceneTestCase {assertEquals(2, set.removeAll(list2));assertEquals(3, set.size());- assertSortedListEquals(set.toArray(), 0, 2, 4);+ assertSortedListEquals(set.toArray(), asArray(0, 2, 4));}@Test@@ -409,13 +409,13 @@ public class TestIntHashSet extends LuceneTestCase {@Testpublic void testClone() {- this.set.addAll(key1, key2, key3);+ this.set.addAll(asArray(1, 2, 3));IntHashSet cloned = set.clone();cloned.remove(key1);- assertSortedListEquals(set.toArray(), key1, key2, key3);- assertSortedListEquals(cloned.toArray(), key2, key3);+ assertSortedListEquals(set.toArray(), asArray(1, 2, 3));+ assertSortedListEquals(cloned.toArray(), asArray(2, 3));}@Test@@ -461,7 +461,7 @@ public class TestIntHashSet extends LuceneTestCase {}/** Check if the array's content is identical to a given sequence of elements. */- private static void assertSortedListEquals(int[] array, int... elements) {+ private static void assertSortedListEquals(int[] array, int[] elements) {assertEquals(elements.length, array.length);Arrays.sort(array);assertArrayEquals(elements, array);diff --git a/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongHashSet.java b/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongHashSet.javaindex 14ea848ecb9..4c309cea8e3 100644--- a/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongHashSet.java+++ b/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongHashSet.java@@ -210,7 +210,7 @@ public class TestLongHashSet extends LuceneTestCase {public void testAddVarArgs() {set.addAll(asArray(0, 1, 2, 1, 0));assertEquals(3, set.size());- assertSortedListEquals(set.toArray(), 0, 1, 2);+ assertSortedListEquals(set.toArray(), asArray(0, 1, 2));}@Test@@ -223,7 +223,7 @@ public class TestLongHashSet extends LuceneTestCase {assertEquals(0, set.addAll(set2));assertEquals(3, set.size());- assertSortedListEquals(set.toArray(), 0, 1, 2);+ assertSortedListEquals(set.toArray(), asArray(0, 1, 2));}@Test@@ -233,7 +233,7 @@ public class TestLongHashSet extends LuceneTestCase {assertTrue(set.remove(key2));assertFalse(set.remove(key2));assertEquals(4, set.size());- assertSortedListEquals(set.toArray(), 0, 1, 3, 4);+ assertSortedListEquals(set.toArray(), asArray(0, 1, 3, 4));}@Test@@ -303,7 +303,7 @@ public class TestLongHashSet extends LuceneTestCase {assertEquals(2, set.removeAll(list2));assertEquals(3, set.size());- assertSortedListEquals(set.toArray(), 0, 2, 4);+ assertSortedListEquals(set.toArray(), asArray(0, 2, 4));}@Test@@ -404,13 +404,13 @@ public class TestLongHashSet extends LuceneTestCase {@Testpublic void testClone() {- this.set.addAll(key1, key2, key3);+ this.set.addAll(asArray(1, 2, 3));LongHashSet cloned = set.clone();cloned.remove(key1);- assertSortedListEquals(set.toArray(), key1, key2, key3);- assertSortedListEquals(cloned.toArray(), key2, key3);+ assertSortedListEquals(set.toArray(), asArray(1, 2, 3));+ assertSortedListEquals(cloned.toArray(), asArray(2, 3));}@Test@@ -456,7 +456,7 @@ public class TestLongHashSet extends LuceneTestCase {}/** Check if the array's content is identical to a given sequence of elements. */- private static void assertSortedListEquals(long[] array, long... elements) {+ private static void assertSortedListEquals(long[] array, long[] elements) {assertEquals(elements.length, array.length);Arrays.sort(array);assertArrayEquals(elements, array);diff --git a/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongIntHashMap.java b/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongIntHashMap.javaindex 4dddb081ea5..0d3468c4b5b 100644--- a/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongIntHashMap.java+++ b/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongIntHashMap.java@@ -331,7 +331,7 @@ public class TestLongIntHashMap extends LuceneTestCase {/* */@Testpublic void testEmptyKey() {- final int empty = 0;+ final long empty = 0;map.put(empty, value1);assertEquals(1, map.size());diff --git a/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongObjectHashMap.java b/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongObjectHashMap.javaindex 7d368eed8d3..10b661c258a 100644--- a/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongObjectHashMap.java+++ b/lucene/core/src/test/org/apache/lucene/util/hppc/TestLongObjectHashMap.java@@ -335,7 +335,7 @@ public class TestLongObjectHashMap extends LuceneTestCase {/* */@Testpublic void testEmptyKey() {- final int empty = 0;+ final long empty = 0;map.put(empty, value1);assertEquals(1, map.size());diff --git a/lucene/facet/src/java/org/apache/lucene/facet/StringValueFacetCounts.java b/lucene/facet/src/java/org/apache/lucene/facet/StringValueFacetCounts.javaindex e6c97779905..048582d6e43 100644--- a/lucene/facet/src/java/org/apache/lucene/facet/StringValueFacetCounts.java+++ b/lucene/facet/src/java/org/apache/lucene/facet/StringValueFacetCounts.java@@ -150,9 +150,9 @@ public class StringValueFacetCounts extends Facets {List<LabelAndValue> labelValues = new ArrayList<>();if (sparseCounts != null) {- for (IntIntCursor cursor : sparseCounts) {- int count = cursor.value;- final BytesRef term = docValues.lookupOrd(cursor.key);+ for (IntIntCursor sparseCount : sparseCounts) {+ int count = sparseCount.value;+ final BytesRef term = docValues.lookupOrd(sparseCount.key);labelValues.add(new LabelAndValue(term.utf8ToString(), count));}} else {@@ -186,10 +186,10 @@ public class StringValueFacetCounts extends Facets {int childCount = 0; // total number of labels with non-zero countif (sparseCounts != null) {- for (IntIntCursor cursor : sparseCounts) {+ for (IntIntCursor sparseCount : sparseCounts) {childCount++; // every count in sparseValues should be non-zero- int ord = cursor.key;- int count = cursor.value;+ int ord = sparseCount.key;+ int count = sparseCount.value;if (count > bottomCount || (count == bottomCount && ord < bottomOrd)) {if (q == null) {// Lazy init for sparse case:diff --git a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/SimpleBoundaryScanner.java b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/SimpleBoundaryScanner.javaindex e26d2f3d5a7..b46d7a5d08d 100644--- a/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/SimpleBoundaryScanner.java+++ b/lucene/highlighter/src/java/org/apache/lucene/search/vectorhighlight/SimpleBoundaryScanner.java@@ -16,9 +16,9 @@*/package org.apache.lucene.search.vectorhighlight;-import java.util.Arrays;-import java.util.HashSet;+import java.util.Iterator;import java.util.Set;+import org.apache.lucene.util.hppc.CharHashSet;/*** Simple boundary scanner implementation that divides fragments based on a set of separator@@ -27,10 +27,10 @@ import java.util.Set;public class SimpleBoundaryScanner implements BoundaryScanner {public static final int DEFAULT_MAX_SCAN = 20;- public static final Character[] DEFAULT_BOUNDARY_CHARS = {'.', ',', '!', '?', ' ', '\t', '\n'};+ public static final char[] DEFAULT_BOUNDARY_CHARS = {'.', ',', '!', '?', ' ', '\t', '\n'};protected int maxScan;- protected Set<Character> boundaryChars;+ protected CharHashSet boundaryChars;public SimpleBoundaryScanner() {this(DEFAULT_MAX_SCAN, DEFAULT_BOUNDARY_CHARS);@@ -44,15 +44,34 @@ public class SimpleBoundaryScanner implements BoundaryScanner {this(DEFAULT_MAX_SCAN, boundaryChars);}- public SimpleBoundaryScanner(int maxScan, Character[] boundaryChars) {+ public SimpleBoundaryScanner(int maxScan, char[] boundaryChars) {this.maxScan = maxScan;- this.boundaryChars = new HashSet<>();- this.boundaryChars.addAll(Arrays.asList(boundaryChars));+ this.boundaryChars = CharHashSet.from(boundaryChars);+ }++ public SimpleBoundaryScanner(int maxScan, Character[] boundaryChars) {+ this(maxScan, toCharArray(boundaryChars));}public SimpleBoundaryScanner(int maxScan, Set<Character> boundaryChars) {- this.maxScan = maxScan;- this.boundaryChars = boundaryChars;+ this(maxScan, toCharArray(boundaryChars));+ }++ private static char[] toCharArray(Character[] characters) {+ char[] chars = new char[characters.length];+ for (int i = 0; i < characters.length; i++) {+ chars[i] = characters[i];+ }+ return chars;+ }++ private static char[] toCharArray(Set<Character> characters) {+ Iterator<Character> iterator = characters.iterator();+ char[] chars = new char[characters.size()];+ for (int i = 0; i < chars.length; i++) {+ chars[i] = iterator.next();+ }+ return chars;}@Override