Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.lucene.search; import java.io.IOException; import org.apache.lucene.index.DocValues; import org.apache.lucene.index.SortedDocValues; import org.apache.lucene.index.SortedSetDocValues; import org.apache.lucene.util.ArrayUtil; import org.apache.lucene.util.BytesRef; import static org.apache.lucene.index.SortedSetDocValues.NO_MORE_ORDS; /** Selects a value from the document's set to use as the representative value */ public class SortedSetSelector { /** * Type of selection to perform. * <p> * Limitations: * <ul> * <li>Fields containing {@link Integer#MAX_VALUE} or more unique values * are unsupported. * <li>Selectors other than ({@link Type#MIN}) require * optional codec support. However several codecs provided by Lucene, * including the current default codec, support this. * </ul> */ public enum Type { /** * Selects the minimum value in the set */ MIN, /** * Selects the maximum value in the set */ MAX, /** * Selects the middle value in the set. * <p> * If the set has an even number of values, the lower of the middle two is chosen. */ MIDDLE_MIN, /** * Selects the middle value in the set. * <p> * If the set has an even number of values, the higher of the middle two is chosen */ MIDDLE_MAX } /** Wraps a multi-valued SortedSetDocValues as a single-valued view, using the specified selector */ public static SortedDocValues wrap(SortedSetDocValues sortedSet, Type selector) { if (sortedSet.getValueCount() >= Integer.MAX_VALUE) { throw new UnsupportedOperationException( "fields containing more than " + (Integer.MAX_VALUE - 1) + " unique terms are unsupported"); } SortedDocValues singleton = DocValues.unwrapSingleton(sortedSet); if (singleton != null) { // it's actually single-valued in practice, but indexed as multi-valued, // so just sort on the underlying single-valued dv directly. // regardless of selector type, this optimization is safe! return singleton; } else { switch (selector) { case MIN: return new MinValue(sortedSet); case MAX: return new MaxValue(sortedSet); case MIDDLE_MIN: return new MiddleMinValue(sortedSet); case MIDDLE_MAX: return new MiddleMaxValue(sortedSet); default: throw new AssertionError(); } } } /** Wraps a SortedSetDocValues and returns the first ordinal (min) */ static class MinValue extends SortedDocValues { final SortedSetDocValues in; private int ord; MinValue(SortedSetDocValues in) { this.in = in; } @Override public int docID() { return in.docID(); } @Override public int nextDoc() throws IOException { in.nextDoc(); setOrd(); return docID(); } @Override public int advance(int target) throws IOException { in.advance(target); setOrd(); return docID(); } @Override public boolean advanceExact(int target) throws IOException { if (in.advanceExact(target)) { setOrd(); return true; } return false; } @Override public long cost() { return in.cost(); } @Override public int ordValue() { return ord; } @Override public BytesRef lookupOrd(int ord) throws IOException { return in.lookupOrd(ord); } @Override public int getValueCount() { return (int) in.getValueCount(); } @Override public int lookupTerm(BytesRef key) throws IOException { return (int) in.lookupTerm(key); } private void setOrd() throws IOException { if (docID() != NO_MORE_DOCS) { ord = (int) in.nextOrd(); } else { ord = (int) NO_MORE_ORDS; } } } /** Wraps a SortedSetDocValues and returns the last ordinal (max) */ static class MaxValue extends SortedDocValues { final SortedSetDocValues in; private int ord; MaxValue(SortedSetDocValues in) { this.in = in; } @Override public int docID() { return in.docID(); } @Override public int nextDoc() throws IOException { in.nextDoc(); setOrd(); return docID(); } @Override public int advance(int target) throws IOException { in.advance(target); setOrd(); return docID(); } @Override public boolean advanceExact(int target) throws IOException { if (in.advanceExact(target)) { setOrd(); return true; } return false; } @Override public long cost() { return in.cost(); } @Override public int ordValue() { return ord; } @Override public BytesRef lookupOrd(int ord) throws IOException { return in.lookupOrd(ord); } @Override public int getValueCount() { return (int) in.getValueCount(); } @Override public int lookupTerm(BytesRef key) throws IOException { return (int) in.lookupTerm(key); } private void setOrd() throws IOException { if (docID() != NO_MORE_DOCS) { while (true) { long nextOrd = in.nextOrd(); if (nextOrd == NO_MORE_ORDS) { break; } ord = (int) nextOrd; } } else { ord = (int) NO_MORE_ORDS; } } } /** Wraps a SortedSetDocValues and returns the middle ordinal (or min of the two) */ static class MiddleMinValue extends SortedDocValues { final SortedSetDocValues in; private int ord; private int[] ords = new int[8]; MiddleMinValue(SortedSetDocValues in) { this.in = in; } @Override public int docID() { return in.docID(); } @Override public int nextDoc() throws IOException { in.nextDoc(); setOrd(); return docID(); } @Override public int advance(int target) throws IOException { in.advance(target); setOrd(); return docID(); } @Override public boolean advanceExact(int target) throws IOException { if (in.advanceExact(target)) { setOrd(); return true; } return false; } @Override public long cost() { return in.cost(); } @Override public int ordValue() { return ord; } @Override public BytesRef lookupOrd(int ord) throws IOException { return in.lookupOrd(ord); } @Override public int getValueCount() { return (int) in.getValueCount(); } @Override public int lookupTerm(BytesRef key) throws IOException { return (int) in.lookupTerm(key); } private void setOrd() throws IOException { if (docID() != NO_MORE_DOCS) { int upto = 0; while (true) { long nextOrd = in.nextOrd(); if (nextOrd == NO_MORE_ORDS) { break; } if (upto == ords.length) { ords = ArrayUtil.grow(ords); } ords[upto++] = (int) nextOrd; } if (upto == 0) { // iterator should not have returned this docID if it has no ords: assert false; ord = (int) NO_MORE_ORDS; } else { ord = ords[(upto - 1) >>> 1]; } } else { ord = (int) NO_MORE_ORDS; } } } /** Wraps a SortedSetDocValues and returns the middle ordinal (or max of the two) */ static class MiddleMaxValue extends SortedDocValues { final SortedSetDocValues in; private int ord; private int[] ords = new int[8]; MiddleMaxValue(SortedSetDocValues in) { this.in = in; } @Override public int docID() { return in.docID(); } @Override public int nextDoc() throws IOException { in.nextDoc(); setOrd(); return docID(); } @Override public int advance(int target) throws IOException { in.advance(target); setOrd(); return docID(); } @Override public boolean advanceExact(int target) throws IOException { if (in.advanceExact(target)) { setOrd(); return true; } return false; } @Override public long cost() { return in.cost(); } @Override public int ordValue() { return ord; } @Override public BytesRef lookupOrd(int ord) throws IOException { return in.lookupOrd(ord); } @Override public int getValueCount() { return (int) in.getValueCount(); } @Override public int lookupTerm(BytesRef key) throws IOException { return (int) in.lookupTerm(key); } private void setOrd() throws IOException { if (docID() != NO_MORE_DOCS) { int upto = 0; while (true) { long nextOrd = in.nextOrd(); if (nextOrd == NO_MORE_ORDS) { break; } if (upto == ords.length) { ords = ArrayUtil.grow(ords); } ords[upto++] = (int) nextOrd; } if (upto == 0) { // iterator should not have returned this docID if it has no ords: assert false; ord = (int) NO_MORE_ORDS; } else { ord = ords[upto >>> 1]; } } else { ord = (int) NO_MORE_ORDS; } } } }