Apache Lucene open-source search software
Move `brToString(BytesRef)` to `ToStringUtils` (#13068)
Dmitry Cherniachenko9206bdeb069c
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex a4cae493b87..b2e96bfbb06 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -205,7 +205,8 @@ Bug FixesOther----------------------(No changes)++* GITHUB#13068: Replace numerous `brToString(BytesRef)` copies with a `ToStringUtils` method (Dmitry Cherniachenko)======================== Lucene 9.10.0 =======================diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/FieldReader.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/FieldReader.javaindex 06f18d3bfd9..3387c2c7b5c 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/FieldReader.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/FieldReader.java@@ -191,7 +191,7 @@ public final class FieldReader extends Terms {@Overridepublic TermsEnum intersect(CompiledAutomaton compiled, BytesRef startTerm) throws IOException {// if (DEBUG) System.out.println(" FieldReader.intersect startTerm=" +- // BlockTreeTermsWriter.brToString(startTerm));+ // ToStringUtils.bytesRefToString(startTerm));// System.out.println("intersect: " + compiled.type + " a=" + compiled.automaton);// TODO: we could push "it's a range" or "it's a prefix" down into IntersectTermsEnum?// can we optimize knowing that...?diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/IntersectTermsEnum.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/IntersectTermsEnum.javaindex c61795be957..888b7f69eec 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/IntersectTermsEnum.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/IntersectTermsEnum.java@@ -543,19 +543,6 @@ final class IntersectTermsEnum extends BaseTermsEnum {}}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-private void copyTerm() {final int len = currentFrame.prefix + currentFrame.suffix;if (term.bytes.length < len) {diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsReader.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsReader.javaindex 6ea2533574c..7a096548502 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsReader.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsReader.java@@ -354,24 +354,6 @@ public final class Lucene40BlockTreeTermsReader extends FieldsProducer {return fieldMap.size();}- // for debugging- String brToString(BytesRef b) {- if (b == null) {- return "null";- } else {- try {- return b.utf8ToString() + " " + b;- } catch (- @SuppressWarnings("unused")- Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- }-@Overridepublic void checkIntegrity() throws IOException {// terms indexdiff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnum.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnum.javaindex 52c0e339128..224906fa5a0 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnum.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnum.java@@ -256,8 +256,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {final SegmentTermsEnumFrame f = getFrame(1 + currentFrame.ord);f.arc = arc;if (f.fpOrig == fp && f.nextEnt != -1) {- // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp + "- // isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" ++ // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp ++ // " isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" +// f.nextEnt + " targetBeforeCurrentLength=" + targetBeforeCurrentLength + " term.length=" +// term.length + " vs prefix=" + f.prefix);// if (f.prefix > targetBeforeCurrentLength) {@@ -279,7 +279,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {// final int sav = term.length;// term.length = length;// System.out.println(" push new frame ord=" + f.ord + " fp=" + f.fp + " hasTerms=" +- // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + brToString(term));+ // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + ToStringUtils.bytesRefToString(term));// term.length = sav;// }}@@ -299,27 +299,6 @@ final class SegmentTermsEnum extends BaseTermsEnum {return true;}- /*- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRefBuilder b) {- return brToString(b.get());- }- */-@Overridepublic boolean seekExact(BytesRef target) throws IOException {@@ -337,8 +316,9 @@ final class SegmentTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nBTTR.seekExact seg=" + fr.parent.segment + " target=" +- // fr.fieldInfo.name + ":" + brToString(target) + " current=" + brToString(term) + " (exists?="- // + termExists + ") validIndexPrefix=" + validIndexPrefix);+ // fr.fieldInfo.name + ":" + ToStringUtils.bytesRefToString(target) + " current=" ++ // ToStringUtils.bytesRefToString(term) + " (exists?=" + termExists ++ // ") validIndexPrefix=" + validIndexPrefix);// printSeekState(System.out);// }@@ -496,8 +476,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {}// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength);// }@@ -528,7 +508,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {term.setByteAt(targetUpto, (byte) targetLabel);term.setLength(1 + targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -544,7 +524,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {} else {// if (DEBUG) {// System.out.println(" got " + result + "; return NOT_FOUND term=" +- // brToString(term));+ // ToStringUtils.bytesRefToString(term));// }return false;}@@ -587,7 +567,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {termExists = false;term.setLength(targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -623,7 +603,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nBTTR.seekCeil seg=" + fr.parent.segment + " target=" +- // fr.fieldInfo.name + ":" + brToString(target) + " " + target + " current=" + brToString(term)+ // fr.fieldInfo.name + ":" + ToStringUtils.bytesRefToString(target) ++ // " current=" + ToStringUtils.bytesRefToString(term)// + " (exists?=" + termExists + ") validIndexPrefix= " + validIndexPrefix);// printSeekState(System.out);// }@@ -667,9 +648,9 @@ final class SegmentTermsEnum extends BaseTermsEnum {cmp = (term.byteAt(targetUpto) & 0xFF) - (target.bytes[target.offset + targetUpto] & 0xFF);// if (DEBUG) {// System.out.println(" cycle targetUpto=" + targetUpto + " (vs limit=" + targetLimit +- // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) + "- // vs termLabel=" + (char) (term.byteAt(targetUpto)) + ")" + " arc.output=" + arc.output +- // " output=" + output);+ // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) ++ // " vs termLabel=" + (char) (term.byteAt(targetUpto)) + ")" + " arc.output=" + arc.output+ // + " output=" + output);// }if (cmp != 0) {break;@@ -781,8 +762,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {}// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength);// }@@ -818,7 +799,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {if (next() != null) {// if (DEBUG) {- // System.out.println(" return NOT_FOUND term=" + brToString(term));+ // System.out.println(" return NOT_FOUND term=" ++ // ToStringUtils.bytesRefToString(term));// }return SeekStatus.NOT_FOUND;} else {@@ -829,7 +811,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {}} else {// if (DEBUG) {- // System.out.println(" return " + result + " term=" + brToString(term));+ // System.out.println(" return " + result + " term=" ++ // ToStringUtils.bytesRefToString(term));// }return result;}@@ -1029,9 +1012,10 @@ final class SegmentTermsEnum extends BaseTermsEnum {assert !eof;// if (DEBUG) {- // System.out.println("\nBTTR.next seg=" + fr.parent.segment + " term=" + brToString(term) + "- // termExists?=" + termExists + " field=" + fr.fieldInfo.name + " termBlockOrd=" +- // currentFrame.state.termBlockOrd + " validIndexPrefix=" + validIndexPrefix);+ // System.out.println("\nBTTR.next seg=" + fr.parent.segment + " term=" ++ // ToStringUtils.bytesRefToString(term) + " termExists?=" + termExists + " field=" ++ // fr.fieldInfo.name + " termBlockOrd=" + currentFrame.state.termBlockOrd ++ // " validIndexPrefix=" + validIndexPrefix);// printSeekState(System.out);// }@@ -1095,8 +1079,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {// try to scan to the right floor frame:currentFrame.loadBlock();} else {- // if (DEBUG) System.out.println(" return term=" + brToString(term) + " currentFrame.ord="- // + currentFrame.ord);+ // if (DEBUG) System.out.println(" return term=" + ToStringUtils.bytesRefToString(term) ++ // " currentFrame.ord=" + currentFrame.ord);return term.get();}}diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnumFrame.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnumFrame.javaindex afe902fa3a8..3003151bbe7 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnumFrame.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene40/blocktree/SegmentTermsEnumFrame.java@@ -317,8 +317,8 @@ final class SegmentTermsEnumFrame {}public void nextLeaf() {- // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt + "- // entCount=" + entCount);+ // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt ++ // " entCount=" + entCount);assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp;nextEnt++;@@ -410,8 +410,8 @@ final class SegmentTermsEnumFrame {newFP = fpOrig + (code >>> 1);hasTerms = (code & 1) != 0;// if (DEBUG) {- // System.out.println(" label=" + toHex(nextFloorLabel) + " fp=" + newFP + "- // hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);+ // System.out.println(" label=" + toHex(nextFloorLabel) + " fp=" + newFP ++ // " hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);// }isLastInFloor = numFollowFloorBlocks == 1;@@ -566,28 +566,14 @@ final class SegmentTermsEnumFrame {private long subCode;CompressionAlgorithm compressionAlg = CompressionAlgorithm.NO_COMPRESSION;- // for debugging- /*- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- */-// Target's prefix matches this block's prefix; we// scan the entries check if the suffix matches.public SeekStatus scanToTermLeaf(BytesRef target, boolean exactOnly) throws IOException {- // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix + "- // nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" +- // brToString(term));+ // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix ++ // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" ++ // ToStringUtils.bytesRefToString(target) ++ // " term=" + ToStringUtils.bytesRefToString(term));assert nextEnt != -1;@@ -617,7 +603,7 @@ final class SegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: term " + (nextEnt-1) + " (of " + entCount + ") suffix="- // + brToString(suffixBytesRef));+ // + ToStringUtils.bytesRefToString(suffixBytesRef));// }startBytePos = suffixesReader.getPosition();@@ -682,8 +668,9 @@ final class SegmentTermsEnumFrame {public SeekStatus scanToTermNonLeaf(BytesRef target, boolean exactOnly) throws IOException {// if (DEBUG) System.out.println(" scanToTermNonLeaf: block fp=" + fp + " prefix=" + prefix +- // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" +- // brToString(target));+ // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" ++ // ToStringUtils.bytesRefToString(target) ++ // " term=" + ToStringUtils.bytesRefToString(term));assert nextEnt != -1;@@ -711,7 +698,8 @@ final class SegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: " + ((code&1)==1 ? "sub-block" : "term") + " " +- // (nextEnt-1) + " (of " + entCount + ") suffix=" + brToString(suffixBytesRef));+ // (nextEnt-1) + " (of " + entCount + ") suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytesRef));// }final int termLen = prefix + suffix;@@ -743,8 +731,8 @@ final class SegmentTermsEnumFrame {// return NOT_FOUND:fillTerm();- // if (DEBUG) System.out.println(" maybe done exactOnly=" + exactOnly + "- // ste.termExists=" + ste.termExists);+ // if (DEBUG) System.out.println(" maybe done exactOnly=" + exactOnly ++ // " ste.termExists=" + ste.termExists);if (!exactOnly && !ste.termExists) {// System.out.println(" now pushFrame");diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsWriter.java b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsWriter.javaindex 2ededb9391f..6bcc0671a5c 100644--- a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsWriter.java+++ b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene40/blocktree/Lucene40BlockTreeTermsWriter.java@@ -46,6 +46,7 @@ import org.apache.lucene.util.FixedBitSet;import org.apache.lucene.util.IOUtils;import org.apache.lucene.util.IntsRefBuilder;import org.apache.lucene.util.StringHelper;+import org.apache.lucene.util.ToStringUtils;import org.apache.lucene.util.compress.LZ4;import org.apache.lucene.util.compress.LowercaseAsciiCompression;import org.apache.lucene.util.fst.ByteSequenceOutputs;@@ -349,7 +350,7 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {}// if (DEBUG) System.out.println("write field=" + fieldInfo.name + " term=" +- // brToString(term));+ // ToStringUtils.bytesRefToString(term));termsWriter.write(term, termsEnum, norms);}@@ -388,33 +389,10 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return "TERM: " + brToString(termBytes);+ return "TERM: " + ToStringUtils.bytesRefToString(termBytes);}}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- if (b == null) {- return "(null)";- } else {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- }-- // for debugging- @SuppressWarnings("unused")- static String brToString(byte[] b) {- return brToString(new BytesRef(b));- }-private static final class PendingBlock extends PendingEntry {public final BytesRef prefix;public final long fp;@@ -442,7 +420,7 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return "BLOCK: prefix=" + brToString(prefix);+ return "BLOCK: prefix=" + ToStringUtils.bytesRefToString(prefix);}public void compileIndex(@@ -600,8 +578,8 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {// if (DEBUG2) {// BytesRef br = new BytesRef(lastTerm.bytes());// br.length = prefixLength;- // System.out.println("writeBlocks: seg=" + segment + " prefix=" + brToString(br) + " count="- // + count);+ // System.out.println("writeBlocks: seg=" + segment + " prefix=" ++ // ToStringUtils.bytesRefToString(br) + " count=" + count);// }// Root block better write all remaining pending entries:@@ -754,9 +732,10 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {prefix.length = prefixLength;// if (DEBUG2) System.out.println(" writeBlock field=" + fieldInfo.name + " prefix=" +- // brToString(prefix) + " fp=" + startFP + " isFloor=" + isFloor + " isLastInFloor=" + (end ==- // pending.size()) + " floorLeadLabel=" + floorLeadLabel + " start=" + start + " end=" + end +- // " hasTerms=" + hasTerms + " hasSubBlocks=" + hasSubBlocks);+ // ToStringUtils.bytesRefToString(prefix) + " fp=" + startFP + " isFloor=" + isFloor ++ // " isLastInFloor=" + (end == pending.size()) + " floorLeadLabel=" + floorLeadLabel ++ // " start=" + start + " end=" + end + " hasTerms=" + hasTerms + " hasSubBlocks=" ++ // hasSubBlocks);// Write block header:int numEntries = end - start;@@ -769,7 +748,9 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {/*if (DEBUG) {- System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment + " pending.size()=" + pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" + brToString(prefix) + " entCount=" + (end-start+1) + " startFP=" + startFP + (isFloor ? (" floorLeadLabel=" + Integer.toHexString(floorLeadLabel)) : ""));+ System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment + " pending.size()=" ++ pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" + ToStringUtils.bytesRefToString(prefix) ++ " entCount=" + (end-start+1) + " startFP=" + startFP + (isFloor ? (" floorLeadLabel=" + Integer.toHexString(floorLeadLabel)) : ""));}*/@@ -804,7 +785,8 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {// BytesRef suffixBytes = new BytesRef(suffix);// System.arraycopy(term.termBytes, prefixLength, suffixBytes.bytes, 0, suffix);// suffixBytes.length = suffix;- // System.out.println(" write term suffix=" + brToString(suffixBytes));+ // System.out.println(" write term suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytes));// }// For leaf block we write suffix straight@@ -837,7 +819,8 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {// BytesRef suffixBytes = new BytesRef(suffix);// System.arraycopy(term.termBytes, prefixLength, suffixBytes.bytes, 0, suffix);// suffixBytes.length = suffix;- // System.out.println(" write term suffix=" + brToString(suffixBytes));+ // System.out.println(" write term suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytes));// }// For non-leaf block we borrow 1 bit to record@@ -879,8 +862,9 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {// BytesRef suffixBytes = new BytesRef(suffix);// System.arraycopy(block.prefix.bytes, prefixLength, suffixBytes.bytes, 0, suffix);// suffixBytes.length = suffix;- // System.out.println(" write sub-block suffix=" + brToString(suffixBytes) + "- // subFP=" + block.fp + " subCode=" + (startFP-block.fp) + " floor=" + block.isFloor);+ // System.out.println(" write sub-block suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytes) ++ // " subFP=" + block.fp + " subCode=" + (startFP-block.fp) + " floor=" + block.isFloor);// }assert floorLeadLabel == -1@@ -998,7 +982,8 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {if (DEBUG) {int[] tmp = new int[lastTerm.length];System.arraycopy(prefixStarts, 0, tmp, 0, tmp.length);- System.out.println("BTTW: write term=" + brToString(text) + " prefixStarts=" + Arrays.toString(tmp) + " pending.size()=" + pending.size());+ System.out.println("BTTW: write term=" + ToStringUtils.bytesRefToString(text) + " prefixStarts=" + Arrays.toString(tmp) ++ " pending.size()=" + pending.size());}*/@@ -1051,8 +1036,8 @@ public final class Lucene40BlockTreeTermsWriter extends FieldsConsumer {// we are closing:int prefixTopSize = pending.size() - prefixStarts[i];if (prefixTopSize >= minItemsInBlock) {- // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize + "- // minItemsInBlock=" + minItemsInBlock);+ // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize ++ // " minItemsInBlock=" + minItemsInBlock);writeBlocks(i + 1, prefixTopSize);prefixStarts[i] -= prefixTopSize - 1;}diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.javaindex a930575756a..ef95f68a697 100644--- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.java+++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsReader.java@@ -230,24 +230,6 @@ public final class OrdsBlockTreeTermsReader extends FieldsProducer {return fields.size();}- // for debugging- String brToString(BytesRef b) {- if (b == null) {- return "null";- } else {- try {- return b.utf8ToString() + " " + b;- } catch (- @SuppressWarnings("unused")- Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- }-@Overridepublic void checkIntegrity() throws IOException {// term dictionarydiff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.javaindex a7ef5ef9932..fb6b0de56b7 100644--- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java+++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java@@ -43,6 +43,7 @@ import org.apache.lucene.util.FixedBitSet;import org.apache.lucene.util.IOUtils;import org.apache.lucene.util.IntsRefBuilder;import org.apache.lucene.util.StringHelper;+import org.apache.lucene.util.ToStringUtils;import org.apache.lucene.util.fst.BytesRefFSTEnum;import org.apache.lucene.util.fst.FST;import org.apache.lucene.util.fst.FSTCompiler;@@ -288,29 +289,10 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return brToString(termBytes);+ return ToStringUtils.bytesRefToString(termBytes);}}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-- // for debugging- @SuppressWarnings("unused")- static String brToString(byte[] b) {- return brToString(new BytesRef(b));- }-private static final class SubIndex {public final FST<Output> index;public final long termOrdStart;@@ -353,7 +335,7 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return "BLOCK: " + brToString(prefix);+ return "BLOCK: " + ToStringUtils.bytesRefToString(prefix);}public void compileIndex(@@ -457,9 +439,9 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {Output newOutput =FST_OUTPUTS.newOutput(output.bytes, termOrdOffset + output.startOrd, output.endOrd - termOrdOffset);- // System.out.println(" append sub=" + indexEnt.input + " output=" + indexEnt.output + "- // termOrdOffset=" + termOrdOffset + " blockTermCount=" + blockTermCount + " newOutput=" +- // newOutput + " endOrd=" + (termOrdOffset+Long.MAX_VALUE-output.endOrd));+ // System.out.println(" append sub=" + indexEnt.input + " output=" + indexEnt.output ++ // " termOrdOffset=" + termOrdOffset + " blockTermCount=" + blockTermCount + " newOutput="+ // + newOutput + " endOrd=" + (termOrdOffset+Long.MAX_VALUE-output.endOrd));fstCompiler.add(Util.toIntsRef(indexEnt.input, scratchIntsRef), newOutput);}}@@ -642,8 +624,8 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {long startFP = out.getFilePointer();- // if (DEBUG) System.out.println(" writeBlock fp=" + startFP + " isFloor=" + isFloor + "- // floorLeadLabel=" + floorLeadLabel + " start=" + start + " end=" + end + " hasTerms=" ++ // if (DEBUG) System.out.println(" writeBlock fp=" + startFP + " isFloor=" + isFloor ++ // " floorLeadLabel=" + floorLeadLabel + " start=" + start + " end=" + end + " hasTerms=" +// hasTerms + " hasSubBlocks=" + hasSubBlocks);boolean hasFloorLeadLabel = isFloor && floorLeadLabel != -1;@@ -662,11 +644,11 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {out.writeVInt(code);// if (DEBUG) {- // System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment + "- // pending.size()=" + pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" +- // brToString(prefix) + " entCount=" + length + " startFP=" + startFP + (isFloor ? ("- // floorLeadByte=" + Integer.toHexString(floorLeadByte&0xff)) : "") + " isLastInFloor=" +- // isLastInFloor);+ // System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment ++ // " pending.size()=" + pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" ++ // ToStringUtils.bytesRefToString(prefix) + " entCount=" + length + " startFP=" + startFP ++ // (isFloor ? (" floorLeadByte=" + Integer.toHexString(floorLeadByte&0xff)) : "") ++ // " isLastInFloor=" + isLastInFloor);// }final List<SubIndex> subIndices;@@ -784,7 +766,8 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {BytesRef suffixBytes = new BytesRef(suffix);System.arraycopy(block.prefix.bytes, prefixLength, suffixBytes.bytes, 0, suffix);suffixBytes.length = suffix;- System.out.println(" write sub-block suffix=" + brToString(suffixBytes) + " subFP=" + block.fp + " subCode=" + (startFP-block.fp) + " floor=" + block.isFloor);+ System.out.println(" write sub-block suffix=" + ToStringUtils.bytesRefToString(suffixBytes) ++ " subFP=" + block.fp + " subCode=" + (startFP-block.fp) + " floor=" + block.isFloor);}*/@@ -842,7 +825,8 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {if (DEBUG) {int[] tmp = new int[lastTerm.length];System.arraycopy(prefixStarts, 0, tmp, 0, tmp.length);- System.out.println("BTTW: write term=" + brToString(text) + " prefixStarts=" + Arrays.toString(tmp) + " pending.size()=" + pending.size());+ System.out.println("BTTW: write term=" + ToStringUtils.bytesRefToString(text) + " prefixStarts=" ++ Arrays.toString(tmp) + " pending.size()=" + pending.size());}*/@@ -885,8 +869,8 @@ public final class OrdsBlockTreeTermsWriter extends FieldsConsumer {// we are closing:int prefixTopSize = pending.size() - prefixStarts[i];if (prefixTopSize >= minItemsInBlock) {- // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize + "- // minItemsInBlock=" + minItemsInBlock);+ // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize ++ // " minItemsInBlock=" + minItemsInBlock);writeBlocks(i + 1, prefixTopSize);prefixStarts[i] -= prefixTopSize - 1;}diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsIntersectTermsEnum.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsIntersectTermsEnum.javaindex a4752eeddd4..8c3c6727329 100644--- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsIntersectTermsEnum.java+++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsIntersectTermsEnum.java@@ -61,7 +61,7 @@ final class OrdsIntersectTermsEnum extends BaseTermsEnum {throws IOException {// if (DEBUG) {// System.out.println("\nintEnum.init seg=" + segment + " commonSuffix=" +- // brToString(compiled.commonSuffixRef));+ // ToStringUtils.bytesRefToString(compiled.commonSuffixRef));// }this.fr = fr;this.byteRunnable = compiled.getByteRunnable();@@ -283,13 +283,15 @@ final class OrdsIntersectTermsEnum extends BaseTermsEnum {currentFrame.loadNextFloorBlock();continue;} else {- // if (DEBUG) System.out.println(" return term=" + brToString(term));+ // if (DEBUG) System.out.println(" return term=" ++ // ToStringUtils.bytesRefToString(term));return;}}continue;} else if (cmp == 0) {- // if (DEBUG) System.out.println(" return term=" + brToString(term));+ // if (DEBUG) System.out.println(" return term=" ++ // ToStringUtils.bytesRefToString(term));return;} else {// Fallback to prior entry: the semantics of@@ -327,10 +329,10 @@ final class OrdsIntersectTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nintEnum.next seg=" + segment);- // System.out.println(" frame ord=" + currentFrame.ord + " prefix=" + brToString(new- // BytesRef(term.bytes, term.offset, currentFrame.prefix)) + " state=" + currentFrame.state + "- // lastInFloor?=" + currentFrame.isLastInFloor + " fp=" + currentFrame.fp + " trans=" +- // (currentFrame.transitions.length == 0 ? "n/a" :+ // System.out.println(" frame ord=" + currentFrame.ord + " prefix=" ++ // ToStringUtils.bytesRefToString(new BytesRef(term.bytes, term.offset, currentFrame.prefix)) ++ // " state=" + currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor ++ // " fp=" + currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" :// currentFrame.transitions[currentFrame.transitionIndex]) + " outputPrefix=" +// currentFrame.outputPrefix);// }@@ -343,9 +345,10 @@ final class OrdsIntersectTermsEnum extends BaseTermsEnum {// if (DEBUG) System.out.println(" next-floor-block");currentFrame.loadNextFloorBlock();// if (DEBUG) System.out.println("\n frame ord=" + currentFrame.ord + " prefix=" +- // brToString(new BytesRef(term.bytes, term.offset, currentFrame.prefix)) + " state=" +- // currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor + " fp=" +- // currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" :+ // ToStringUtils.bytesRefToString(new BytesRef(term.bytes, term.offset,+ // currentFrame.prefix)) ++ // " state=" + currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor ++ // " fp=" + currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" :// currentFrame.transitions[currentFrame.transitionIndex]) + " outputPrefix=" +// currentFrame.outputPrefix);} else {@@ -357,9 +360,10 @@ final class OrdsIntersectTermsEnum extends BaseTermsEnum {currentFrame = stack[currentFrame.ord - 1];assert currentFrame.lastSubFP == lastFP;// if (DEBUG) System.out.println("\n frame ord=" + currentFrame.ord + " prefix=" +- // brToString(new BytesRef(term.bytes, term.offset, currentFrame.prefix)) + " state=" +- // currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor + " fp=" +- // currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" :+ // ToStringUtils.bytesRefToString(new BytesRef(term.bytes, term.offset,+ // currentFrame.prefix)) ++ // " state=" + currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor ++ // " fp=" + currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" :// currentFrame.transitions[currentFrame.transitionIndex]) + " outputPrefix=" +// currentFrame.outputPrefix);}@@ -373,7 +377,7 @@ final class OrdsIntersectTermsEnum extends BaseTermsEnum {// suffixRef.length = currentFrame.suffix;// System.out.println(" " + (isSubBlock ? "sub-block" : "term") + " " +// currentFrame.nextEnt + " (of " + currentFrame.entCount + ") suffix=" +- // brToString(suffixRef));+ // ToStringUtils.bytesRefToString(suffixRef));// }if (currentFrame.suffix != 0) {@@ -480,15 +484,16 @@ final class OrdsIntersectTermsEnum extends BaseTermsEnum {copyTerm();currentFrame = pushFrame(state);// if (DEBUG) System.out.println("\n frame ord=" + currentFrame.ord + " prefix=" +- // brToString(new BytesRef(term.bytes, term.offset, currentFrame.prefix)) + " state=" +- // currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor + " fp=" ++ // ToStringUtils.bytesRefToString(new BytesRef(term.bytes, term.offset,+ // currentFrame.prefix)) ++ // " state=" + currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor + " fp=" +// currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" :// currentFrame.transitions[currentFrame.transitionIndex]) + " outputPrefix=" +// currentFrame.outputPrefix);} else if (byteRunnable.isAccept(state)) {copyTerm();// if (DEBUG) System.out.println(" term match to state=" + state + "; return term=" +- // brToString(term));+ // ToStringUtils.bytesRefToString(term));assert savedStartTerm == null || term.compareTo(savedStartTerm) > 0: "saveStartTerm=" + savedStartTerm.utf8ToString() + " term=" + term.utf8ToString();return term;diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnum.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnum.javaindex d3107849ea1..5b6771e7856 100644--- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnum.java+++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnum.java@@ -32,6 +32,7 @@ import org.apache.lucene.util.BytesRefBuilder;import org.apache.lucene.util.IntsRef;import org.apache.lucene.util.IntsRefBuilder;import org.apache.lucene.util.RamUsageEstimator;+import org.apache.lucene.util.ToStringUtils;import org.apache.lucene.util.fst.FST;import org.apache.lucene.util.fst.Util;@@ -174,11 +175,11 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {throws IOException {final OrdsSegmentTermsEnumFrame f = getFrame(1 + currentFrame.ord);f.arc = arc;- // System.out.println("pushFrame termOrd= " + termOrd + " fpOrig=" + f.fpOrig + " fp=" + fp + "- // nextEnt=" + f.nextEnt);+ // System.out.println("pushFrame termOrd= " + termOrd + " fpOrig=" + f.fpOrig + " fp=" + fp ++ // " nextEnt=" + f.nextEnt);if (f.fpOrig == fp && f.nextEnt != -1) {- // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp + "- // isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" ++ // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp ++ // " isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" +// f.nextEnt + " targetBeforeCurrentLength=" + targetBeforeCurrentLength + " term.length=" +// term.length + " vs prefix=" + f.prefix);if (f.prefix > targetBeforeCurrentLength) {@@ -204,7 +205,7 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {// final int sav = term.length;// term.length = length;// System.out.println(" push new frame ord=" + f.ord + " fp=" + f.fp + " hasTerms=" +- // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + brToString(term));+ // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + ToStringUtils.bytesRefToString(term));// term.length = sav;// }}@@ -224,19 +225,6 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {return true;}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-@Overridepublic boolean seekExact(final BytesRef target) throws IOException {@@ -250,7 +238,9 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {/*if (DEBUG) {- System.out.println("\nBTTR.seekExact seg=" + fr.parent.segment + " target=" + fr.fieldInfo.name + ":" + brToString(target) + " current=" + brToString(term) + " (exists?=" + termExists + ") validIndexPrefix=" + validIndexPrefix);+ System.out.println("\nBTTR.seekExact seg=" + fr.parent.segment + " target=" + fr.fieldInfo.name + ":" ++ ToStringUtils.bytesRefToString(target) + " current=" + ToStringUtils.bytesRefToString(term) + " (exists?=" + termExists ++ ") validIndexPrefix=" + validIndexPrefix);printSeekState(System.out);}*/@@ -411,8 +401,8 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {positioned = true;// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength);// }@@ -443,7 +433,7 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {term.setByteAt(targetUpto, (byte) targetLabel);term.setLength(1 + targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -459,7 +449,7 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {} else {// if (DEBUG) {// System.out.println(" got " + result + "; return NOT_FOUND term=" +- // brToString(term));+ // ToStringUtils.bytesRefToString(term));// }return false;}@@ -502,7 +492,7 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {termExists = false;term.setLength(targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -537,8 +527,8 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nBTTR.seekCeil seg=" + segment + " target=" + fieldInfo.name + ":" +- // target.utf8ToString() + " " + target + " current=" + brToString(term) + " (exists?=" +- // termExists + ") validIndexPrefix= " + validIndexPrefix);+ // target.utf8ToString() + " " + target + " current=" + ToStringUtils.bytesRefToString(term) ++ // " (exists?=" + termExists + ") validIndexPrefix= " + validIndexPrefix);// printSeekState();// }@@ -581,9 +571,9 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {cmp = (term.byteAt(targetUpto) & 0xFF) - (target.bytes[target.offset + targetUpto] & 0xFF);// if (DEBUG) {// System.out.println(" cycle targetUpto=" + targetUpto + " (vs limit=" + targetLimit +- // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) + "- // vs termLabel=" + (char) (term.bytes[targetUpto]) + ")" + " arc.output=" + arc.output +- // " output=" + output);+ // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) ++ // " vs termLabel=" + (char) (term.bytes[targetUpto]) + ")" + " arc.output=" + arc.output+ // + " output=" + output);// }if (cmp != 0) {break;@@ -697,8 +687,8 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {positioned = true;// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength);// }@@ -733,7 +723,8 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {if (next() != null) {// if (DEBUG) {- // System.out.println(" return NOT_FOUND term=" + brToString(term) + " " + term);+ // System.out.println(" return NOT_FOUND term=" ++ // ToStringUtils.bytesRefToString(term));// }return SeekStatus.NOT_FOUND;} else {@@ -744,7 +735,8 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {}} else {// if (DEBUG) {- // System.out.println(" return " + result + " term=" + brToString(term) + " " + term);+ // System.out.println(" return " + result + " term=" ++ // ToStringUtils.bytesRefToString(term));// }return result;}@@ -829,7 +821,7 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {+ " prefixLen="+ f.prefix+ " prefix="- + brToString(prefix)+ + ToStringUtils.bytesRefToString(prefix)+ (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")"))+ " hasTerms="+ f.hasTerms@@ -859,7 +851,7 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {+ " prefixLen="+ f.prefix+ " prefix="- + brToString(prefix)+ + ToStringUtils.bytesRefToString(prefix)+ " nextEnt="+ f.nextEnt+ (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")"))@@ -951,8 +943,9 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {assert !eof;// if (DEBUG) {- // System.out.println("\nBTTR.next seg=" + segment + " term=" + brToString(term) + "- // termExists?=" + termExists + " field=" + fieldInfo.name + " termBlockOrd=" ++ // System.out.println("\nBTTR.next seg=" + segment + " term=" ++ // ToStringUtils.bytesRefToString(term) ++ // " termExists?=" + termExists + " field=" + fieldInfo.name + " termBlockOrd=" +// currentFrame.state.termBlockOrd + " validIndexPrefix=" + validIndexPrefix);// printSeekState();// }@@ -1019,8 +1012,8 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {// currentFrame.hasTerms = true;currentFrame.loadBlock();} else {- // if (DEBUG) System.out.println(" return term=" + term.utf8ToString() + " " + term + "- // currentFrame.ord=" + currentFrame.ord);+ // if (DEBUG) System.out.println(" return term=" + term.utf8ToString() + " " + term ++ // " currentFrame.ord=" + currentFrame.ord);positioned = true;return term.get();}@@ -1235,8 +1228,8 @@ public final class OrdsSegmentTermsEnum extends BaseTermsEnum {int low = 0;int high = arc.numArcs() - 1;int mid = 0;- // System.out.println("bsearch: numArcs=" + arc.numArcs + " target=" + targetOutput + "- // output=" + output);+ // System.out.println("bsearch: numArcs=" + arc.numArcs + " target=" + targetOutput ++ // " output=" + output);boolean found = false;while (low <= high) {mid = (low + high) >>> 1;diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnumFrame.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnumFrame.javaindex 9eca4d14b6b..cd98a3e0f8c 100644--- a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnumFrame.java+++ b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsSegmentTermsEnumFrame.java@@ -119,8 +119,8 @@ final class OrdsSegmentTermsEnumFrame {numFollowFloorBlocks = floorDataReader.readVInt();nextFloorLabel = floorDataReader.readByte() & 0xff;nextFloorTermOrd = termOrdOrig + floorDataReader.readVLong();- // System.out.println(" setFloorData ord=" + ord + " nextFloorTermOrd=" + nextFloorTermOrd + "- // shift=" + (nextFloorTermOrd-termOrdOrig));+ // System.out.println(" setFloorData ord=" + ord + " nextFloorTermOrd=" + nextFloorTermOrd ++ // " shift=" + (nextFloorTermOrd-termOrdOrig));// if (DEBUG) {// System.out.println(" setFloorData fpOrig=" + fpOrig + " bytes=" + new@@ -289,8 +289,8 @@ final class OrdsSegmentTermsEnumFrame {// Decodes next entry; returns true if it's a sub-blockpublic boolean nextLeaf() {- // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt + "- // entCount=" + entCount);+ // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt ++ // " entCount=" + entCount);assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp + " termOrd=" + termOrd;nextEnt++;@@ -306,8 +306,8 @@ final class OrdsSegmentTermsEnumFrame {}public boolean nextNonLeaf() {- // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt + "- // entCount=" + entCount);+ // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt ++ // " entCount=" + entCount);assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp;nextEnt++;@@ -374,8 +374,8 @@ final class OrdsSegmentTermsEnumFrame {newFP = fpOrig + (code >>> 1);hasTerms = (code & 1) != 0;// if (DEBUG) {- // System.out.println(" label=" + ((char) nextFloorLabel) + " fp=" + newFP + "- // hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);+ // System.out.println(" label=" + ((char) nextFloorLabel) + " fp=" + newFP ++ // " hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);// }isLastInFloor = numFollowFloorBlocks == 1;@@ -440,8 +440,8 @@ final class OrdsSegmentTermsEnumFrame {newFP = fpOrig + (code >>> 1);hasTerms = (code & 1) != 0;// if (DEBUG) {- // System.out.println(" label=" + ((char) nextFloorLabel) + " fp=" + newFP + "- // hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);+ // System.out.println(" label=" + ((char) nextFloorLabel) + " fp=" + newFP ++ // " hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);// }isLastInFloor = numFollowFloorBlocks == 1;@@ -495,8 +495,8 @@ final class OrdsSegmentTermsEnumFrame {boolean absolute = metaDataUpto == 0;assert limit > 0 : "limit=" + limit + " isLeafBlock=" + isLeafBlock + " nextEnt=" + nextEnt;- // if (DEBUG) System.out.println("\nBTTR.decodeMetadata seg=" + ste.fr.parent.segment + "- // mdUpto=" + metaDataUpto + " vs termBlockOrd=" + state.termBlockOrd + " limit=" + limit);+ // if (DEBUG) System.out.println("\nBTTR.decodeMetadata seg=" + ste.fr.parent.segment ++ // " mdUpto=" + metaDataUpto + " vs termBlockOrd=" + state.termBlockOrd + " limit=" + limit);// TODO: better API would be "jump straight to term=N"???while (metaDataUpto < limit) {@@ -593,10 +593,10 @@ final class OrdsSegmentTermsEnumFrame {// scan the entries check if the suffix matches.public SeekStatus scanToTermLeaf(BytesRef target, boolean exactOnly) throws IOException {- // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix + "- // nextEnt=" + nextEnt + " (of " + entCount + ") target=" +- // OrdsSegmentTermsEnum.brToString(target) + " term=" +- // OrdsSegmentTermsEnum.brToString(ste.term));+ // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix ++ // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" ++ // ToStringUtils.bytesRefToString(target) + " term=" ++ // ToStringUtils.bytesRefToString(ste.term));assert nextEnt != -1;@@ -627,7 +627,7 @@ final class OrdsSegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: term " + (nextEnt-1) + " (of " + entCount + ") suffix="- // + OrdsSegmentTermsEnum.brToString(suffixBytesRef));+ // + ToStringUtils.bytesRefToString(suffixBytesRef));// }final int termLen = prefix + suffix;@@ -714,8 +714,8 @@ final class OrdsSegmentTermsEnumFrame {// if (DEBUG) System.out.println(" scanToTermNonLeaf: block fp=" + fp + " prefix=" + prefix +// " nextEnt=" + nextEnt + " (of " + entCount + ") target=" +- // OrdsSegmentTermsEnum.brToString(target) + " term=" +- // OrdsSegmentTermsEnum.brToString(ste.term));+ // ToStringUtils.bytesRefToString(target) + " term=" ++ // ToStringUtils.bytesRefToString(ste.term));assert nextEnt != -1;@@ -743,7 +743,8 @@ final class OrdsSegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: " + ((code&1)==1 ? "sub-block" : "term") + " " +- // (nextEnt-1) + " (of " + entCount + ") suffix=" + brToString(suffixBytesRef));+ // (nextEnt-1) + " (of " + entCount + ") suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytesRef));// }ste.termExists = (code & 1) == 0;diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/FieldReader.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/FieldReader.javaindex 2b25863d661..6cef964a6a5 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/FieldReader.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/FieldReader.java@@ -210,7 +210,7 @@ public final class FieldReader extends Terms {@Overridepublic TermsEnum intersect(CompiledAutomaton compiled, BytesRef startTerm) throws IOException {// if (DEBUG) System.out.println(" FieldReader.intersect startTerm=" +- // BlockTreeTermsWriter.brToString(startTerm));+ // ToStringUtils.bytesRefToString(startTerm));// System.out.println("intersect: " + compiled.type + " a=" + compiled.automaton);// TODO: we could push "it's a range" or "it's a prefix" down into IntersectTermsEnum?// can we optimize knowing that...?diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/IntersectTermsEnum.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/IntersectTermsEnum.javaindex fb5e0523f10..e2f284f780d 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/IntersectTermsEnum.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/IntersectTermsEnum.java@@ -549,19 +549,6 @@ final class IntersectTermsEnum extends BaseTermsEnum {}}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-private void copyTerm() {final int len = currentFrame.prefix + currentFrame.suffix;if (term.bytes.length < len) {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 4921101faeb..5d218f55faa 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@@ -307,24 +307,6 @@ public final class Lucene90BlockTreeTermsReader extends FieldsProducer {return fieldMap.size();}- // for debugging- String brToString(BytesRef b) {- if (b == null) {- return "null";- } else {- try {- return b.utf8ToString() + " " + b;- } catch (- @SuppressWarnings("unused")- Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- }-@Overridepublic void checkIntegrity() throws IOException {// terms indexdiff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsWriter.javaindex 1cf045f9c14..90b34750463 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsWriter.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/Lucene90BlockTreeTermsWriter.java@@ -47,6 +47,7 @@ import org.apache.lucene.util.FixedBitSet;import org.apache.lucene.util.IOUtils;import org.apache.lucene.util.IntsRefBuilder;import org.apache.lucene.util.StringHelper;+import org.apache.lucene.util.ToStringUtils;import org.apache.lucene.util.compress.LZ4;import org.apache.lucene.util.compress.LowercaseAsciiCompression;import org.apache.lucene.util.fst.ByteSequenceOutputs;@@ -394,7 +395,7 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {}// if (DEBUG) System.out.println("write field=" + fieldInfo.name + " term=" +- // brToString(term));+ // ToStringUtils.bytesRefToString(term));termsWriter.write(term, termsEnum, norms);}@@ -433,33 +434,10 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return "TERM: " + brToString(termBytes);+ return "TERM: " + ToStringUtils.bytesRefToString(termBytes);}}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- if (b == null) {- return "(null)";- } else {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- }-- // for debugging- @SuppressWarnings("unused")- static String brToString(byte[] b) {- return brToString(new BytesRef(b));- }-/*** Encodes long value to variable length byte[], in MSB order. Use {@link* FieldReader#readMSBVLong} to decode.@@ -506,7 +484,7 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return "BLOCK: prefix=" + brToString(prefix);+ return "BLOCK: prefix=" + ToStringUtils.bytesRefToString(prefix);}public void compileIndex(@@ -689,8 +667,8 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {// if (DEBUG2) {// BytesRef br = new BytesRef(lastTerm.bytes());// br.length = prefixLength;- // System.out.println("writeBlocks: seg=" + segment + " prefix=" + brToString(br) + " count="- // + count);+ // System.out.println("writeBlocks: seg=" + segment + " prefix=" ++ // ToStringUtils.bytesRefToString(br) + " count=" + count);// }// Root block better write all remaining pending entries:@@ -843,9 +821,10 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {prefix.length = prefixLength;// if (DEBUG2) System.out.println(" writeBlock field=" + fieldInfo.name + " prefix=" +- // brToString(prefix) + " fp=" + startFP + " isFloor=" + isFloor + " isLastInFloor=" + (end ==- // pending.size()) + " floorLeadLabel=" + floorLeadLabel + " start=" + start + " end=" + end +- // " hasTerms=" + hasTerms + " hasSubBlocks=" + hasSubBlocks);+ // ToStringUtils.bytesRefToString(prefix) + " fp=" + startFP + " isFloor=" + isFloor ++ // " isLastInFloor=" + (end == pending.size()) + " floorLeadLabel=" + floorLeadLabel ++ // " start=" + start + " end=" + end + " hasTerms=" + hasTerms + " hasSubBlocks=" ++ // hasSubBlocks);// Write block header:int numEntries = end - start;@@ -858,7 +837,9 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {/*if (DEBUG) {- System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment + " pending.size()=" + pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" + brToString(prefix) + " entCount=" + (end-start+1) + " startFP=" + startFP + (isFloor ? (" floorLeadLabel=" + Integer.toHexString(floorLeadLabel)) : ""));+ System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment + " pending.size()=" ++ pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" + ToStringUtils.bytesRefToString(prefix) ++ " entCount=" + (end-start+1) + " startFP=" + startFP + (isFloor ? (" floorLeadLabel=" + Integer.toHexString(floorLeadLabel)) : ""));}*/@@ -893,7 +874,8 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {// BytesRef suffixBytes = new BytesRef(suffix);// System.arraycopy(term.termBytes, prefixLength, suffixBytes.bytes, 0, suffix);// suffixBytes.length = suffix;- // System.out.println(" write term suffix=" + brToString(suffixBytes));+ // System.out.println(" write term suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytes));// }// For leaf block we write suffix straight@@ -926,7 +908,8 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {// BytesRef suffixBytes = new BytesRef(suffix);// System.arraycopy(term.termBytes, prefixLength, suffixBytes.bytes, 0, suffix);// suffixBytes.length = suffix;- // System.out.println(" write term suffix=" + brToString(suffixBytes));+ // System.out.println(" write term suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytes));// }// For non-leaf block we borrow 1 bit to record@@ -968,8 +951,9 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {// BytesRef suffixBytes = new BytesRef(suffix);// System.arraycopy(block.prefix.bytes, prefixLength, suffixBytes.bytes, 0, suffix);// suffixBytes.length = suffix;- // System.out.println(" write sub-block suffix=" + brToString(suffixBytes) + "- // subFP=" + block.fp + " subCode=" + (startFP-block.fp) + " floor=" + block.isFloor);+ // System.out.println(" write sub-block suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytes) + " subFP=" + block.fp + " subCode=" ++ // (startFP-block.fp) + " floor=" + block.isFloor);// }assert floorLeadLabel == -1@@ -1090,7 +1074,8 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {if (DEBUG) {int[] tmp = new int[lastTerm.length];System.arraycopy(prefixStarts, 0, tmp, 0, tmp.length);- System.out.println("BTTW: write term=" + brToString(text) + " prefixStarts=" + Arrays.toString(tmp) + " pending.size()=" + pending.size());+ System.out.println("BTTW: write term=" + ToStringUtils.bytesRefToString(text) + " prefixStarts=" + Arrays.toString(tmp) ++ " pending.size()=" + pending.size());}*/@@ -1143,8 +1128,8 @@ public final class Lucene90BlockTreeTermsWriter extends FieldsConsumer {// we are closing:int prefixTopSize = pending.size() - prefixStarts[i];if (prefixTopSize >= minItemsInBlock) {- // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize + "- // minItemsInBlock=" + minItemsInBlock);+ // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize ++ // " minItemsInBlock=" + minItemsInBlock);writeBlocks(i + 1, prefixTopSize);prefixStarts[i] -= prefixTopSize - 1;}diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnum.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnum.javaindex f8e3c50bcb2..479736099ef 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnum.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnum.java@@ -263,8 +263,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {final SegmentTermsEnumFrame f = getFrame(1 + currentFrame.ord);f.arc = arc;if (f.fpOrig == fp && f.nextEnt != -1) {- // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp + "- // isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" ++ // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp ++ // " isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" +// f.nextEnt + " targetBeforeCurrentLength=" + targetBeforeCurrentLength + " term.length=" +// term.length + " vs prefix=" + f.prefix);// if (f.prefix > targetBeforeCurrentLength) {@@ -286,7 +286,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {// final int sav = term.length;// term.length = length;// System.out.println(" push new frame ord=" + f.ord + " fp=" + f.fp + " hasTerms=" +- // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + brToString(term));+ // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + ToStringUtils.bytesRefToString(term));// term.length = sav;// }}@@ -306,27 +306,6 @@ final class SegmentTermsEnum extends BaseTermsEnum {return true;}- /*- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRefBuilder b) {- return brToString(b.get());- }- */-@Overridepublic boolean seekExact(BytesRef target) throws IOException {@@ -344,8 +323,9 @@ final class SegmentTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nBTTR.seekExact seg=" + fr.parent.segment + " target=" +- // fr.fieldInfo.name + ":" + brToString(target) + " current=" + brToString(term) + " (exists?="- // + termExists + ") validIndexPrefix=" + validIndexPrefix);+ // fr.fieldInfo.name + ":" + ToStringUtils.bytesRefToString(target) + " current=" ++ // ToStringUtils.bytesRefToString(term) ++ // " (exists?=" + termExists + ") validIndexPrefix=" + validIndexPrefix);// printSeekState(System.out);// }@@ -499,8 +479,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {}// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength);// }@@ -531,7 +511,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {term.setByteAt(targetUpto, (byte) targetLabel);term.setLength(1 + targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -547,7 +527,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {} else {// if (DEBUG) {// System.out.println(" got " + result + "; return NOT_FOUND term=" +- // brToString(term));+ // ToStringUtils.bytesRefToString(term));// }return false;}@@ -586,7 +566,7 @@ final class SegmentTermsEnum extends BaseTermsEnum {termExists = false;term.setLength(targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -622,8 +602,9 @@ final class SegmentTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nBTTR.seekCeil seg=" + fr.parent.segment + " target=" +- // fr.fieldInfo.name + ":" + brToString(target) + " " + target + " current=" + brToString(term)- // + " (exists?=" + termExists + ") validIndexPrefix= " + validIndexPrefix);+ // fr.fieldInfo.name + ":" + ToStringUtils.bytesRefToString(target) + " current=" ++ // ToStringUtils.bytesRefToString(term) + " (exists?=" + termExists ++ // ") validIndexPrefix= " + validIndexPrefix);// printSeekState(System.out);// }@@ -663,9 +644,9 @@ final class SegmentTermsEnum extends BaseTermsEnum {cmp = (term.byteAt(targetUpto) & 0xFF) - (target.bytes[target.offset + targetUpto] & 0xFF);// if (DEBUG) {// System.out.println(" cycle targetUpto=" + targetUpto + " (vs limit=" + targetLimit +- // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) + "- // vs termLabel=" + (char) (term.byteAt(targetUpto)) + ")" + " arc.output=" + arc.output +- // " output=" + output);+ // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) ++ // " vs termLabel=" + (char) (term.byteAt(targetUpto)) + ")" + " arc.output=" + arc.output+ // + " output=" + output);// }if (cmp != 0) {break;@@ -771,8 +752,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {}// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength);// }@@ -808,7 +789,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {if (next() != null) {// if (DEBUG) {- // System.out.println(" return NOT_FOUND term=" + brToString(term));+ // System.out.println(" return NOT_FOUND term=" ++ // ToStringUtils.bytesRefToString(term));// }return SeekStatus.NOT_FOUND;} else {@@ -819,7 +801,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {}} else {// if (DEBUG) {- // System.out.println(" return " + result + " term=" + brToString(term));+ // System.out.println(" return " + result + " term=" ++ // ToStringUtils.bytesRefToString(term));// }return result;}@@ -1015,9 +998,10 @@ final class SegmentTermsEnum extends BaseTermsEnum {assert !eof;// if (DEBUG) {- // System.out.println("\nBTTR.next seg=" + fr.parent.segment + " term=" + brToString(term) + "- // termExists?=" + termExists + " field=" + fr.fieldInfo.name + " termBlockOrd=" +- // currentFrame.state.termBlockOrd + " validIndexPrefix=" + validIndexPrefix);+ // System.out.println("\nBTTR.next seg=" + fr.parent.segment + " term=" ++ // ToStringUtils.bytesRefToString(term) + " termExists?=" + termExists + " field=" ++ // fr.fieldInfo.name + " termBlockOrd=" + currentFrame.state.termBlockOrd ++ // " validIndexPrefix=" + validIndexPrefix);// printSeekState(System.out);// }@@ -1081,8 +1065,8 @@ final class SegmentTermsEnum extends BaseTermsEnum {// try to scan to the right floor frame:currentFrame.loadBlock();} else {- // if (DEBUG) System.out.println(" return term=" + brToString(term) + " currentFrame.ord="- // + currentFrame.ord);+ // if (DEBUG) System.out.println(" return term=" + ToStringUtils.bytesRefToString(term) ++ // " currentFrame.ord=" + currentFrame.ord);return term.get();}}diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnumFrame.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnumFrame.javaindex 4016b5c784d..66231313e52 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnumFrame.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene90/blocktree/SegmentTermsEnumFrame.java@@ -295,8 +295,8 @@ final class SegmentTermsEnumFrame {}public void nextLeaf() {- // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt + "- // entCount=" + entCount);+ // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt ++ // " entCount=" + entCount);assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp;nextEnt++;@@ -388,8 +388,8 @@ final class SegmentTermsEnumFrame {newFP = fpOrig + (code >>> 1);hasTerms = (code & 1) != 0;// if (DEBUG) {- // System.out.println(" label=" + toHex(nextFloorLabel) + " fp=" + newFP + "- // hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);+ // System.out.println(" label=" + toHex(nextFloorLabel) + " fp=" + newFP ++ // " hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);// }isLastInFloor = numFollowFloorBlocks == 1;@@ -531,28 +531,14 @@ final class SegmentTermsEnumFrame {private long subCode;CompressionAlgorithm compressionAlg = CompressionAlgorithm.NO_COMPRESSION;- // for debugging- /*- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- */-// Target's prefix matches this block's prefix; we// scan the entries check if the suffix matches.public SeekStatus scanToTermLeaf(BytesRef target, boolean exactOnly) throws IOException {- // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix + "- // nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" +- // brToString(term));+ // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix ++ // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" ++ // ToStringUtils.bytesRefToString(target) ++ // " term=" + ToStringUtils.bytesRefToString(term));assert nextEnt != -1;@@ -582,7 +568,7 @@ final class SegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: term " + (nextEnt-1) + " (of " + entCount + ") suffix="- // + brToString(suffixBytesRef));+ // + ToStringUtils.bytesRefToString(suffixBytesRef));// }startBytePos = suffixesReader.getPosition();@@ -647,8 +633,9 @@ final class SegmentTermsEnumFrame {public SeekStatus scanToTermNonLeaf(BytesRef target, boolean exactOnly) throws IOException {// if (DEBUG) System.out.println(" scanToTermNonLeaf: block fp=" + fp + " prefix=" + prefix +- // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" +- // brToString(target));+ // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" ++ // ToStringUtils.bytesRefToString(target) ++ // " term=" + ToStringUtils.bytesRefToString(term));assert nextEnt != -1;@@ -676,7 +663,8 @@ final class SegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: " + ((code&1)==1 ? "sub-block" : "term") + " " +- // (nextEnt-1) + " (of " + entCount + ") suffix=" + brToString(suffixBytesRef));+ // (nextEnt-1) + " (of " + entCount + ") suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytesRef));// }final int termLen = prefix + suffix;@@ -708,8 +696,8 @@ final class SegmentTermsEnumFrame {// return NOT_FOUND:fillTerm();- // if (DEBUG) System.out.println(" maybe done exactOnly=" + exactOnly + "- // ste.termExists=" + ste.termExists);+ // if (DEBUG) System.out.println(" maybe done exactOnly=" + exactOnly ++ // " ste.termExists=" + ste.termExists);if (!exactOnly && !ste.termExists) {// System.out.println(" now pushFrame");diff --git a/lucene/core/src/java/org/apache/lucene/util/BytesRef.java b/lucene/core/src/java/org/apache/lucene/util/BytesRef.javaindex 1fbdaf95412..351259e87b5 100644--- a/lucene/core/src/java/org/apache/lucene/util/BytesRef.java+++ b/lucene/core/src/java/org/apache/lucene/util/BytesRef.java@@ -130,17 +130,20 @@ public final class BytesRef implements Comparable<BytesRef>, Cloneable {return false;}- /** Interprets stored bytes as UTF8 bytes, returning the resulting string */+ /**+ * Interprets stored bytes as UTF-8 bytes, returning the resulting string. May throw an {@link+ * AssertionError} or a {@link RuntimeException} if the data is not well-formed UTF-8.+ */public String utf8ToString() {final char[] ref = new char[length];final int len = UnicodeUtil.UTF8toUTF16(bytes, offset, length, ref);return new String(ref, 0, len);}- /** Returns hex encoded bytes, eg [0x6c 0x75 0x63 0x65 0x6e 0x65] */+ /** Returns hex encoded bytes, e.g. "[6c 75 63 65 6e 65]" */@Overridepublic String toString() {- StringBuilder sb = new StringBuilder();+ StringBuilder sb = new StringBuilder(2 + 3 * length);sb.append('[');final int end = offset + length;for (int i = offset; i < end; i++) {diff --git a/lucene/core/src/java/org/apache/lucene/util/ToStringUtils.java b/lucene/core/src/java/org/apache/lucene/util/ToStringUtils.javaindex 41647507794..0f079e9a825 100644--- a/lucene/core/src/java/org/apache/lucene/util/ToStringUtils.java+++ b/lucene/core/src/java/org/apache/lucene/util/ToStringUtils.java@@ -32,6 +32,10 @@ public final class ToStringUtils {private static final char[] HEX = "0123456789abcdef".toCharArray();+ /**+ * Unlike {@link Long#toHexString(long)} returns a String with a "0x" prefix and all the leading+ * zeros.+ */public static String longHex(long x) {char[] asHex = new char[16];for (int i = 16; --i >= 0; x >>>= 4) {@@ -39,4 +43,31 @@ public final class ToStringUtils {}return "0x" + new String(asHex);}++ /**+ * Builds a String with both textual representation of the {@link BytesRef} data and the bytes hex+ * values. For example: {@code "hello [68 65 6c 6c 6f]"}. If the content is not a valid UTF-8+ * sequence, only the bytes hex values are returned, as per {@link BytesRef#toString()}.+ */+ @SuppressWarnings("unused")+ public static String bytesRefToString(BytesRef b) {+ if (b == null) {+ return "null";+ }+ try {+ return b.utf8ToString() + " " + b;+ } catch (AssertionError | RuntimeException t) {+ // If BytesRef isn't actually UTF-8, or it's e.g. a prefix of UTF-8+ // that ends mid-unicode-char, we fall back to hex:+ return b.toString();+ }+ }++ public static String bytesRefToString(BytesRefBuilder b) {+ return bytesRefToString(b.get());+ }++ public static String bytesRefToString(byte[] b) {+ return bytesRefToString(new BytesRef(b));+ }}diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnum.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnum.javaindex 163060b3943..ea2cc686b6b 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnum.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnum.java@@ -30,6 +30,7 @@ import org.apache.lucene.util.ArrayUtil;import org.apache.lucene.util.BytesRef;import org.apache.lucene.util.BytesRefBuilder;import org.apache.lucene.util.RamUsageEstimator;+import org.apache.lucene.util.ToStringUtils;import org.apache.lucene.util.fst.FST;import org.apache.lucene.util.fst.PairOutputs.Pair;import org.apache.lucene.util.fst.Util;@@ -175,8 +176,8 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {final IDVersionSegmentTermsEnumFrame f = getFrame(1 + currentFrame.ord);f.arc = arc;if (f.fpOrig == fp && f.nextEnt != -1) {- // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp + "- // isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" ++ // if (DEBUG) System.out.println(" push reused frame ord=" + f.ord + " fp=" + f.fp ++ // " isFloor?=" + f.isFloor + " hasTerms=" + f.hasTerms + " pref=" + term + " nextEnt=" +// f.nextEnt + " targetBeforeCurrentLength=" + targetBeforeCurrentLength + " term.length=" +// term.length + " vs prefix=" + f.prefix);if (f.prefix > targetBeforeCurrentLength) {@@ -197,7 +198,7 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {// final int sav = term.length;// term.length = length;// System.out.println(" push new frame ord=" + f.ord + " fp=" + f.fp + " hasTerms=" +- // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + brToString(term));+ // f.hasTerms + " isFloor=" + f.isFloor + " pref=" + ToStringUtils.bytesRefToString(term));// term.length = sav;// }}@@ -222,19 +223,6 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {return seekExact(target, 0);}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-/** Get the version of the currently seek'd term; only valid if we are positioned. */public long getVersion() {return ((IDVersionTermState) currentFrame.state).idVersion;@@ -258,8 +246,9 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nBTTR.seekExact seg=" + fr.parent.segment + " target=" +- // fr.fieldInfo.name + ":" + brToString(target) + " minIDVersion=" + minIDVersion + " current="- // + brToString(term) + " (exists?=" + termExists + ") validIndexPrefix=" + validIndexPrefix);+ // fr.fieldInfo.name + ":" + ToStringUtils.bytesRefToString(target) + " minIDVersion=" ++ // minIDVersion + " current=" + ToStringUtils.bytesRefToString(term) + " (exists?=" ++ // termExists + ") validIndexPrefix=" + validIndexPrefix);// printSeekState(System.out);// }@@ -460,8 +449,8 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {}// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength + " termExists=" + termExists);// }@@ -492,7 +481,7 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {term.setByteAt(targetUpto, (byte) targetLabel);term.setLength(1 + targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -520,10 +509,11 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {// termExists = false;// }// if (DEBUG) {- // System.out.println(" FAST version NOT_FOUND term=" + brToString(term) + "- // targetUpto=" + targetUpto + " currentFrame.maxIDVersion=" + currentFrame.maxIDVersion +- // " validIndexPrefix=" + validIndexPrefix + " startFrameFP=" + startFrameFP + " vs " +- // currentFrame.fp + " termExists=" + termExists);+ // System.out.println(" FAST version NOT_FOUND term=" ++ // ToStringUtils.bytesRefToString(term) + " targetUpto=" + targetUpto ++ // " currentFrame.maxIDVersion=" + currentFrame.maxIDVersion + " validIndexPrefix=" ++ // validIndexPrefix + " startFrameFP=" + startFrameFP + " vs " + currentFrame.fp ++ // " termExists=" + termExists);// }return false;}@@ -553,7 +543,7 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {} else {// if (DEBUG) {// System.out.println(" got " + result + "; return NOT_FOUND term=" +- // brToString(term));+ // ToStringUtils.bytesRefToString(term));// }return false;}@@ -604,7 +594,7 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {termExists = false;term.setLength(targetUpto);// if (DEBUG) {- // System.out.println(" FAST NOT_FOUND term=" + brToString(term));+ // System.out.println(" FAST NOT_FOUND term=" + ToStringUtils.bytesRefToString(term));// }return false;}@@ -656,8 +646,8 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {// if (DEBUG) {// System.out.println("\nBTTR.seekCeil seg=" + segment + " target=" + fieldInfo.name + ":" +- // target.utf8ToString() + " " + target + " current=" + brToString(term) + " (exists?=" +- // termExists + ") validIndexPrefix= " + validIndexPrefix);+ // target.utf8ToString() + " " + target + " current=" + ToStringUtils.bytesRefToString(term) ++ // " (exists?=" + termExists + ") validIndexPrefix= " + validIndexPrefix);// printSeekState();// }@@ -700,9 +690,9 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {cmp = (term.byteAt(targetUpto) & 0xFF) - (target.bytes[target.offset + targetUpto] & 0xFF);// if (DEBUG) {// System.out.println(" cycle targetUpto=" + targetUpto + " (vs limit=" + targetLimit +- // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) + "- // vs termLabel=" + (char) (term.bytes[targetUpto]) + ")" + " arc.output=" + arc.output +- // " output=" + output);+ // ") cmp=" + cmp + " (targetLabel=" + (char) (target.bytes[target.offset + targetUpto]) ++ // " vs termLabel=" + (char) (term.bytes[targetUpto]) + ")" + " arc.output=" + arc.output+ // + " output=" + output);// }if (cmp != 0) {break;@@ -814,8 +804,8 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {}// if (DEBUG) {- // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output + "- // currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" ++ // System.out.println(" start index loop targetUpto=" + targetUpto + " output=" + output ++ // " currentFrame.ord+1=" + currentFrame.ord + " targetBeforeCurrentLength=" +// targetBeforeCurrentLength);// }@@ -850,7 +840,8 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {if (next() != null) {// if (DEBUG) {- // System.out.println(" return NOT_FOUND term=" + brToString(term) + " " + term);+ // System.out.println(" return NOT_FOUND term=" ++ // ToStringUtils.bytesRefToString(term));// }return SeekStatus.NOT_FOUND;} else {@@ -861,7 +852,8 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {}} else {// if (DEBUG) {- // System.out.println(" return " + result + " term=" + brToString(term) + " " + term);+ // System.out.println(" return " + result + " term=" ++ // ToStringUtils.bytesRefToString(term));// }return result;}@@ -946,7 +938,7 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {+ " prefixLen="+ f.prefix+ " prefix="- + brToString(prefix)+ + ToStringUtils.bytesRefToString(prefix)+ (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")"))+ " hasTerms="+ f.hasTerms@@ -974,7 +966,7 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {+ " prefixLen="+ f.prefix+ " prefix="- + brToString(prefix)+ + ToStringUtils.bytesRefToString(prefix)+ " nextEnt="+ f.nextEnt+ (f.nextEnt == -1 ? "" : (" (of " + f.entCount + ")"))@@ -1063,9 +1055,10 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {assert !eof;// if (DEBUG) {- // System.out.println("\nBTTR.next seg=" + segment + " term=" + brToString(term) + "- // termExists?=" + termExists + " field=" + fieldInfo.name + " termBlockOrd=" +- // currentFrame.state.termBlockOrd + " validIndexPrefix=" + validIndexPrefix);+ // System.out.println("\nBTTR.next seg=" + segment + " term=" ++ // ToStringUtils.bytesRefToString(term) + " termExists?=" + termExists ++ // " field=" + fieldInfo.name + " termBlockOrd=" + currentFrame.state.termBlockOrd ++ // " validIndexPrefix=" + validIndexPrefix);// printSeekState();// }@@ -1129,8 +1122,8 @@ public final class IDVersionSegmentTermsEnum extends BaseTermsEnum {// currentFrame.hasTerms = true;currentFrame.loadBlock();} else {- // if (DEBUG) System.out.println(" return term=" + term.utf8ToString() + " " + term + "- // currentFrame.ord=" + currentFrame.ord);+ // if (DEBUG) System.out.println(" return term=" + term.utf8ToString() + " " + term ++ // " currentFrame.ord=" + currentFrame.ord);return term.get();}}diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnumFrame.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnumFrame.javaindex 9f75b23519b..4ecac0a93ad 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnumFrame.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/IDVersionSegmentTermsEnumFrame.java@@ -257,8 +257,8 @@ final class IDVersionSegmentTermsEnumFrame {// Decodes next entry; returns true if it's a sub-blockpublic boolean nextLeaf() {- // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt + "- // entCount=" + entCount);+ // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt ++ // " entCount=" + entCount);assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp;nextEnt++;@@ -273,8 +273,8 @@ final class IDVersionSegmentTermsEnumFrame {}public boolean nextNonLeaf() {- // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt + "- // entCount=" + entCount);+ // if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt ++ // " entCount=" + entCount);assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp;nextEnt++;@@ -338,8 +338,8 @@ final class IDVersionSegmentTermsEnumFrame {newFP = fpOrig + (code >>> 1);hasTerms = (code & 1) != 0;// if (DEBUG) {- // System.out.println(" label=" + ((char) nextFloorLabel) + " fp=" + newFP + "- // hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);+ // System.out.println(" label=" + ((char) nextFloorLabel) + " fp=" + newFP ++ // " hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);// }isLastInFloor = numFollowFloorBlocks == 1;@@ -379,8 +379,8 @@ final class IDVersionSegmentTermsEnumFrame {public void decodeMetaData() throws IOException {- // if (DEBUG) System.out.println("\nBTTR.decodeMetadata seg=" + ste.fr.parent.segment + "- // mdUpto=" + metaDataUpto + " vs termBlockOrd=" + state.termBlockOrd);+ // if (DEBUG) System.out.println("\nBTTR.decodeMetadata seg=" + ste.fr.parent.segment ++ // " mdUpto=" + metaDataUpto + " vs termBlockOrd=" + state.termBlockOrd);assert nextEnt >= 0;@@ -473,10 +473,10 @@ final class IDVersionSegmentTermsEnumFrame {// scan the entries check if the suffix matches.public SeekStatus scanToTermLeaf(BytesRef target, boolean exactOnly) throws IOException {- // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix + "- // nextEnt=" + nextEnt + " (of " + entCount + ") target=" +- // IDVersionSegmentTermsEnum.brToString(target) + " term=" +- // IDVersionSegmentTermsEnum.brToString(ste.term));+ // if (DEBUG) System.out.println(" scanToTermLeaf: block fp=" + fp + " prefix=" + prefix ++ // " nextEnt=" + nextEnt + " (of " + entCount + ") target=" ++ // ToStringUtils.bytesRefToString(target) ++ // " term=" + ToStringUtils.bytesRefToString(ste.term));assert nextEnt != -1;@@ -506,7 +506,7 @@ final class IDVersionSegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: term " + (nextEnt-1) + " (of " + entCount + ") suffix="- // + IDVersionSegmentTermsEnum.brToString(suffixBytesRef));+ // + ToStringUtils.bytesRefToString(suffixBytesRef));// }final int termLen = prefix + suffix;@@ -606,8 +606,8 @@ final class IDVersionSegmentTermsEnumFrame {// if (DEBUG) System.out.println(" scanToTermNonLeaf: block fp=" + fp + " prefix=" + prefix +// " nextEnt=" + nextEnt + " (of " + entCount + ") target=" +- // IDVersionSegmentTermsEnum.brToString(target) + " term=" +- // IDVersionSegmentTermsEnum.brToString(ste.term));+ // ToStringUtils.bytesRefToString(target) + " term=" ++ // ToStringUtils.bytesRefToString(ste.term));assert nextEnt != -1;@@ -635,7 +635,8 @@ final class IDVersionSegmentTermsEnumFrame {// suffixBytesRef.offset = suffixesReader.getPosition();// suffixBytesRef.length = suffix;// System.out.println(" cycle: " + ((code&1)==1 ? "sub-block" : "term") + " " +- // (nextEnt-1) + " (of " + entCount + ") suffix=" + brToString(suffixBytesRef));+ // (nextEnt-1) + " (of " + entCount + ") suffix=" ++ // ToStringUtils.bytesRefToString(suffixBytesRef));// }ste.termExists = (code & 1) == 0;diff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsReader.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsReader.javaindex 7fabfe3eba5..12157ca652f 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsReader.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsReader.java@@ -237,24 +237,6 @@ public final class VersionBlockTreeTermsReader extends FieldsProducer {return fields.size();}- // for debugging- String brToString(BytesRef b) {- if (b == null) {- return "null";- } else {- try {- return b.utf8ToString() + " " + b;- } catch (- @SuppressWarnings("unused")- Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }- }-@Overridepublic void checkIntegrity() throws IOException {// term dictionarydiff --git a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsWriter.java b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsWriter.javaindex 0e9c2332558..b0abc0b5059 100644--- a/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsWriter.java+++ b/lucene/sandbox/src/java/org/apache/lucene/sandbox/codecs/idversion/VersionBlockTreeTermsWriter.java@@ -42,6 +42,7 @@ import org.apache.lucene.util.FixedBitSet;import org.apache.lucene.util.IOUtils;import org.apache.lucene.util.IntsRefBuilder;import org.apache.lucene.util.StringHelper;+import org.apache.lucene.util.ToStringUtils;import org.apache.lucene.util.fst.ByteSequenceOutputs;import org.apache.lucene.util.fst.BytesRefFSTEnum;import org.apache.lucene.util.fst.FST;@@ -292,29 +293,10 @@ public final class VersionBlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return brToString(termBytes);+ return ToStringUtils.bytesRefToString(termBytes);}}- // for debugging- @SuppressWarnings("unused")- static String brToString(BytesRef b) {- try {- return b.utf8ToString() + " " + b;- } catch (Throwable t) {- // If BytesRef isn't actually UTF8, or it's eg a- // prefix of UTF8 that ends mid-unicode-char, we- // fallback to hex:- return b.toString();- }- }-- // for debugging- @SuppressWarnings("unused")- static String brToString(byte[] b) {- return brToString(new BytesRef(b));- }-private static final class PendingBlock extends PendingEntry {public final BytesRef prefix;public final long fp;@@ -347,7 +329,7 @@ public final class VersionBlockTreeTermsWriter extends FieldsConsumer {@Overridepublic String toString() {- return "BLOCK: " + brToString(prefix);+ return "BLOCK: " + ToStringUtils.bytesRefToString(prefix);}public void compileIndex(@@ -610,8 +592,8 @@ public final class VersionBlockTreeTermsWriter extends FieldsConsumer {long startFP = out.getFilePointer();- // if (DEBUG) System.out.println(" writeBlock fp=" + startFP + " isFloor=" + isFloor + "- // floorLeadLabel=" + floorLeadLabel + " start=" + start + " end=" + end + " hasTerms=" ++ // if (DEBUG) System.out.println(" writeBlock fp=" + startFP + " isFloor=" + isFloor ++ // " floorLeadLabel=" + floorLeadLabel + " start=" + start + " end=" + end + " hasTerms=" +// hasTerms + " hasSubBlocks=" + hasSubBlocks);boolean hasFloorLeadLabel = isFloor && floorLeadLabel != -1;@@ -630,11 +612,11 @@ public final class VersionBlockTreeTermsWriter extends FieldsConsumer {out.writeVInt(code);// if (DEBUG) {- // System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment + "- // pending.size()=" + pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" +- // brToString(prefix) + " entCount=" + length + " startFP=" + startFP + (isFloor ? ("- // floorLeadByte=" + Integer.toHexString(floorLeadByte&0xff)) : "") + " isLastInFloor=" +- // isLastInFloor);+ // System.out.println(" writeBlock " + (isFloor ? "(floor) " : "") + "seg=" + segment ++ // " pending.size()=" + pending.size() + " prefixLength=" + prefixLength + " indexPrefix=" ++ // ToStringUtils.bytesRefToString(prefix) + " entCount=" + length + " startFP=" + startFP ++ // (isFloor ? (" floorLeadByte=" + Integer.toHexString(floorLeadByte&0xff)) : "") ++ // " isLastInFloor=" + isLastInFloor);// }// 1st pass: pack term suffix bytes into byte[] blob@@ -737,7 +719,8 @@ public final class VersionBlockTreeTermsWriter extends FieldsConsumer {BytesRef suffixBytes = new BytesRef(suffix);System.arraycopy(block.prefix.bytes, prefixLength, suffixBytes.bytes, 0, suffix);suffixBytes.length = suffix;- System.out.println(" write sub-block suffix=" + brToString(suffixBytes) + " subFP=" + block.fp + " subCode=" + (startFP-block.fp) + " floor=" + block.isFloor);+ System.out.println(" write sub-block suffix=" + ToStringUtils.bytesRefToString(suffixBytes) ++ " subFP=" + block.fp + " subCode=" + (startFP-block.fp) + " floor=" + block.isFloor);}*/@@ -824,8 +807,8 @@ public final class VersionBlockTreeTermsWriter extends FieldsConsumer {// we are closing:int prefixTopSize = pending.size() - prefixStarts[i];if (prefixTopSize >= minItemsInBlock) {- // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize + "- // minItemsInBlock=" + minItemsInBlock);+ // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize ++ // " minItemsInBlock=" + minItemsInBlock);writeBlocks(i + 1, prefixTopSize);prefixStarts[i] -= prefixTopSize - 1;}