org.apache.lucene.index.CodecReader.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.lucene.index.CodecReader.java

Source

/*
 * 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.index;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.apache.lucene.codecs.DocValuesProducer;
import org.apache.lucene.codecs.FieldsProducer;
import org.apache.lucene.codecs.NormsProducer;
import org.apache.lucene.codecs.PointsReader;
import org.apache.lucene.codecs.StoredFieldsReader;
import org.apache.lucene.codecs.TermVectorsReader;
import org.apache.lucene.util.Accountable;
import org.apache.lucene.util.Accountables;
import org.apache.lucene.util.FutureObjects;

/**
 * LeafReader implemented by codec APIs.
 */
public abstract class CodecReader extends LeafReader implements Accountable {

    /** Sole constructor. (For invocation by subclass 
     * constructors, typically implicit.) */
    protected CodecReader() {
    }

    /** 
     * Expert: retrieve thread-private StoredFieldsReader
     * @lucene.internal 
     */
    public abstract StoredFieldsReader getFieldsReader();

    /** 
     * Expert: retrieve thread-private TermVectorsReader
     * @lucene.internal 
     */
    public abstract TermVectorsReader getTermVectorsReader();

    /** 
     * Expert: retrieve underlying NormsProducer
     * @lucene.internal 
     */
    public abstract NormsProducer getNormsReader();

    /** 
     * Expert: retrieve underlying DocValuesProducer
     * @lucene.internal 
     */
    public abstract DocValuesProducer getDocValuesReader();

    /**
     * Expert: retrieve underlying FieldsProducer
     * @lucene.internal
     */
    public abstract FieldsProducer getPostingsReader();

    /**
     * Expert: retrieve underlying PointsReader
     * @lucene.internal
     */
    public abstract PointsReader getPointsReader();

    @Override
    public final void document(int docID, StoredFieldVisitor visitor) throws IOException {
        checkBounds(docID);
        getFieldsReader().visitDocument(docID, visitor);
    }

    @Override
    public final Fields getTermVectors(int docID) throws IOException {
        TermVectorsReader termVectorsReader = getTermVectorsReader();
        if (termVectorsReader == null) {
            return null;
        }
        checkBounds(docID);
        return termVectorsReader.get(docID);
    }

    private void checkBounds(int docID) {
        FutureObjects.checkIndex(docID, maxDoc());
    }

    @Override
    public final Terms terms(String field) throws IOException {
        //ensureOpen(); no; getPostingsReader calls this
        // We could check the FieldInfo IndexOptions but there's no point since
        //   PostingsReader will simply return null for fields that don't exist or that have no terms index.
        return getPostingsReader().terms(field);
    }

    // returns the FieldInfo that corresponds to the given field and type, or
    // null if the field does not exist, or not indexed as the requested
    // DovDocValuesType.
    private FieldInfo getDVField(String field, DocValuesType type) {
        FieldInfo fi = getFieldInfos().fieldInfo(field);
        if (fi == null) {
            // Field does not exist
            return null;
        }
        if (fi.getDocValuesType() == DocValuesType.NONE) {
            // Field was not indexed with doc values
            return null;
        }
        if (fi.getDocValuesType() != type) {
            // Field DocValues are different than requested type
            return null;
        }

        return fi;
    }

    @Override
    public final NumericDocValues getNumericDocValues(String field) throws IOException {
        ensureOpen();
        FieldInfo fi = getDVField(field, DocValuesType.NUMERIC);
        if (fi == null) {
            return null;
        }
        return getDocValuesReader().getNumeric(fi);
    }

    @Override
    public final BinaryDocValues getBinaryDocValues(String field) throws IOException {
        ensureOpen();
        FieldInfo fi = getDVField(field, DocValuesType.BINARY);
        if (fi == null) {
            return null;
        }
        return getDocValuesReader().getBinary(fi);
    }

    @Override
    public final SortedDocValues getSortedDocValues(String field) throws IOException {
        ensureOpen();
        FieldInfo fi = getDVField(field, DocValuesType.SORTED);
        if (fi == null) {
            return null;
        }
        return getDocValuesReader().getSorted(fi);
    }

    @Override
    public final SortedNumericDocValues getSortedNumericDocValues(String field) throws IOException {
        ensureOpen();

        FieldInfo fi = getDVField(field, DocValuesType.SORTED_NUMERIC);
        if (fi == null) {
            return null;
        }
        return getDocValuesReader().getSortedNumeric(fi);
    }

    @Override
    public final SortedSetDocValues getSortedSetDocValues(String field) throws IOException {
        ensureOpen();
        FieldInfo fi = getDVField(field, DocValuesType.SORTED_SET);
        if (fi == null) {
            return null;
        }
        return getDocValuesReader().getSortedSet(fi);
    }

    @Override
    public final NumericDocValues getNormValues(String field) throws IOException {
        ensureOpen();
        FieldInfo fi = getFieldInfos().fieldInfo(field);
        if (fi == null || fi.hasNorms() == false) {
            // Field does not exist or does not index norms
            return null;
        }

        return getNormsReader().getNorms(fi);
    }

    @Override
    public final PointValues getPointValues(String field) throws IOException {
        ensureOpen();
        FieldInfo fi = getFieldInfos().fieldInfo(field);
        if (fi == null || fi.getPointDataDimensionCount() == 0) {
            // Field does not exist or does not index points
            return null;
        }

        return getPointsReader().getValues(field);
    }

    @Override
    protected void doClose() throws IOException {
    }

    @Override
    public long ramBytesUsed() {
        ensureOpen();

        // terms/postings
        long ramBytesUsed = getPostingsReader().ramBytesUsed();

        // norms
        if (getNormsReader() != null) {
            ramBytesUsed += getNormsReader().ramBytesUsed();
        }

        // docvalues
        if (getDocValuesReader() != null) {
            ramBytesUsed += getDocValuesReader().ramBytesUsed();
        }

        // stored fields
        if (getFieldsReader() != null) {
            ramBytesUsed += getFieldsReader().ramBytesUsed();
        }

        // term vectors
        if (getTermVectorsReader() != null) {
            ramBytesUsed += getTermVectorsReader().ramBytesUsed();
        }

        // points
        if (getPointsReader() != null) {
            ramBytesUsed += getPointsReader().ramBytesUsed();
        }

        return ramBytesUsed;
    }

    @Override
    public Collection<Accountable> getChildResources() {
        ensureOpen();
        final List<Accountable> resources = new ArrayList<>(6);

        // terms/postings
        resources.add(Accountables.namedAccountable("postings", getPostingsReader()));

        // norms
        if (getNormsReader() != null) {
            resources.add(Accountables.namedAccountable("norms", getNormsReader()));
        }

        // docvalues
        if (getDocValuesReader() != null) {
            resources.add(Accountables.namedAccountable("docvalues", getDocValuesReader()));
        }

        // stored fields
        if (getFieldsReader() != null) {
            resources.add(Accountables.namedAccountable("stored fields", getFieldsReader()));
        }

        // term vectors
        if (getTermVectorsReader() != null) {
            resources.add(Accountables.namedAccountable("term vectors", getTermVectorsReader()));
        }

        // points
        if (getPointsReader() != null) {
            resources.add(Accountables.namedAccountable("points", getPointsReader()));
        }

        return Collections.unmodifiableList(resources);
    }

    @Override
    public void checkIntegrity() throws IOException {
        ensureOpen();

        // terms/postings
        getPostingsReader().checkIntegrity();

        // norms
        if (getNormsReader() != null) {
            getNormsReader().checkIntegrity();
        }

        // docvalues
        if (getDocValuesReader() != null) {
            getDocValuesReader().checkIntegrity();
        }

        // stored fields
        if (getFieldsReader() != null) {
            getFieldsReader().checkIntegrity();
        }

        // term vectors
        if (getTermVectorsReader() != null) {
            getTermVectorsReader().checkIntegrity();
        }

        // points
        if (getPointsReader() != null) {
            getPointsReader().checkIntegrity();
        }
    }
}