ComparableCharSequence applyBoundaries(ComparableCharSequence seq, boolean requiresLeftBoundary, boolean requiresRightBoundary) { if (requiresLeftBoundary == requiresRightBoundary) { if (requiresLeftBoundary) { return new CompoundCharSequence(" ", TrieMapRulesCollection.BOUNDARY_WORD, seq, TrieMapRulesCollection.BOUNDARY_WORD); } else { return seq; } } else if (requiresLeftBoundary) { return new CompoundCharSequence(" ", TrieMapRulesCollection.BOUNDARY_WORD, seq); } else { return new CompoundCharSequence(" ", seq, TrieMapRulesCollection.BOUNDARY_WORD); } }
@Override public int compareTo(final CharSequence other) { // TODO: avoid calls to this.charAt(i) to make comparison faster final int length = length(); for (int i = 0, len = Math.min(length, other.length()); i < len; i++) { final char ch1 = charAt(i); final char ch2 = other.charAt(i); if (ch1 != ch2) { return ch1 - ch2; } } return length - other.length(); }
@Override public ComparableCharSequence subSequence(final int start, final int end) { if (parts.length == 1) { // TODO: do subsequence as view in wrapper return new ComparableCharSequenceWrapper(parts[0].subSequence(start, end)); } if (start == end) { if (start <= length()) { return ComparableCharSequenceWrapper.EMPTY_SEQUENCE; } else { throw new ArrayIndexOutOfBoundsException(start); } } final PartInfo partInfoStart = getPartInfoForCharIndex(start); final PartInfo partInfoEnd = getPartInfoForCharIndex(end - 1); // end is exclusive if (partInfoStart.partIndex == partInfoEnd.partIndex) { // TODO: do subsequence as view in wrapper return new ComparableCharSequenceWrapper( parts[partInfoStart.partIndex] .subSequence(start - partInfoStart.globalStart, end - partInfoStart.globalStart)); } final CharSequence[] resParts = new CharSequence[partInfoEnd.partIndex - partInfoStart.partIndex + 1]; resParts[0] = parts[partInfoStart.partIndex] .subSequence(start - partInfoStart.globalStart, parts[partInfoStart.partIndex].length()); for (int i = partInfoStart.partIndex + 1, j = 1; i < partInfoEnd.partIndex; i++) { resParts[j++] = parts[i]; } resParts[resParts.length - 1] = parts[partInfoEnd.partIndex].subSequence(0, end - partInfoEnd.globalStart); return new CompoundCharSequence(null, resParts); }
@Test public void testCharAt() throws Exception { CompoundCharSequence seq = new CompoundCharSequence(Arrays.asList("cde-fgh", "-")); assertEquals(8, seq.length()); for (int i = 0; i < 8; i++) { assertEquals("cde-fgh-".charAt(i), seq.charAt(i)); } }
@Test public void testSubSequence() throws Exception { CompoundCharSequence seq = new CompoundCharSequence(Arrays.asList("ab", "cd")); assertEquals("a", seq.subSequence(0, 1).toString()); assertEquals("ab", seq.subSequence(0, 2).toString()); assertEquals("bc", seq.subSequence(1, 3).toString()); assertEquals("d", seq.subSequence(3, 4).toString()); assertEquals("", seq.subSequence(0, 0).toString()); assertEquals("", seq.subSequence(1, 1).toString()); assertEquals("", seq.subSequence(4, 4).toString()); }
@Override public char charAt(final int index) { if (parts.length == 1) { return parts[0].charAt(index); } final PartInfo partInfo = getPartInfoForCharIndex(index); return parts[partInfo.partIndex].charAt(index - partInfo.globalStart); }
public ComparableCharSequence toCharSequenceWithField(final boolean lowerCaseValue) { ComparableCharSequence valueToUse = lowerCaseValue ? new LowerCaseCharSequence(this) : value; return (field == null) ? valueToUse : new CompoundCharSequence(":", field, valueToUse); }
void collectTails(List<ComparableCharSequence> prefix, List<List<ComparableCharSequence>> tailSlots, List<ComparableCharSequence> result) { if (tailSlots.size() == 1) { for (ComparableCharSequence sequence : tailSlots.get(0)) { List<ComparableCharSequence> combined = new LinkedList<>(prefix); combined.add(sequence); result.add(new CompoundCharSequence(" ", combined)); } } else { List<List<ComparableCharSequence>> newTail = tailSlots.subList(1, tailSlots.size()); for (ComparableCharSequence sequence : tailSlots.get(0)) { List<ComparableCharSequence> newPrefix = new LinkedList<>(prefix); newPrefix.add(sequence); collectTails(newPrefix, newTail, result); } } }
public List<ComparableCharSequence> getCharSequences(final boolean lowerCaseValue) { final SimpleComparableCharSequence seq = new SimpleComparableCharSequence(value, start, length); final ComparableCharSequence valueSequence = lowerCaseValue ? new LowerCaseCharSequence(seq) : seq; final List<ComparableCharSequence> seqs = new LinkedList<>(); if (fieldNames == null) { seqs.add(valueSequence); } else { for (final String name : fieldNames) { seqs.add(new CompoundCharSequence(FIELD_CHAR, name, valueSequence)); } } return seqs; }
public ComparableCharSequence fillPlaceholders(final TermMatches termMatches) { if (placeHolders == null || placeHolders.isEmpty()) { return this; } final List<ComparableCharSequence> parts = new LinkedList<>(); int pos = 0; for (final PlaceHolder placeHolder : placeHolders) { if (placeHolder.start > pos) { parts.add(subSequence(pos, placeHolder.start)); } parts.add(termMatches.getReplacement(placeHolder.ref)); pos = placeHolder.start + placeHolder.length; } if (pos < length) { parts.add(subSequence(pos, start + length)); } return new CompoundCharSequence(parts); }
final Term termWithFieldInValue = new Term(null, new CompoundCharSequence(":", fieldname, term.getValue())); fieldBoost = searchFieldsAndBoosting.getFieldBoost(termWithFieldInValue); if (fieldBoost != null) {
@Override public Node visit(final Term term) { if (previousTerm != null && eq(previousTerm.getField(), term.getField()) && (term.isGenerated() == acceptGeneratedTerms || !term.isGenerated()) && (previousTerm.isGenerated() == acceptGeneratedTerms || !previousTerm.isGenerated())) { final CharSequence seq = new CompoundCharSequence(null, previousTerm, term); termsToAdd.add(buildShingle(previousTerm, seq)); termsToAdd.add(buildShingle(term, seq)); } previousTerm = term; return term; }
ComparableCharSequence seq = new CompoundCharSequence(" ", TrieMapRulesCollection.BOUNDARY_WORD, TrieMapRulesCollection.BOUNDARY_WORD); States<List<Instructions>> states = map.get(seq); State<List<Instructions>> state = states.getStateForCompleteSequence();
new CompoundCharSequence(null, " ", charSequenceForLookup), prefix.stateInfo);